hdfs.pb.h

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

#ifndef PROTOBUF_hdfs_2eproto__INCLUDED
#define PROTOBUF_hdfs_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3000000
#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 3000000 < 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/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "Security.pb.h"
// @@protoc_insertion_point(includes)

namespace hadoop {
namespace hdfs {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_hdfs_2eproto();
void protobuf_AssignDesc_hdfs_2eproto();
void protobuf_ShutdownFile_hdfs_2eproto();

class BlockKeyProto;
class BlockProto;
class BlockStoragePolicyProto;
class BlockWithLocationsProto;
class BlocksWithLocationsProto;
class CheckpointCommandProto;
class CheckpointSignatureProto;
class CipherOptionProto;
class ContentSummaryProto;
class CorruptFileBlocksProto;
class DataEncryptionKeyProto;
class DatanodeIDProto;
class DatanodeInfoProto;
class DatanodeInfosProto;
class DatanodeLocalInfoProto;
class DatanodeStorageProto;
class DirectoryListingProto;
class ECSchemaOptionEntryProto;
class ECSchemaProto;
class ErasureCodingPolicyProto;
class ExportedBlockKeysProto;
class ExtendedBlockProto;
class FileEncryptionInfoProto;
class FsPermissionProto;
class FsServerDefaultsProto;
class HdfsFileStatusProto;
class LocatedBlockProto;
class LocatedBlocksProto;
class NamenodeCommandProto;
class NamenodeRegistrationProto;
class NamespaceInfoProto;
class PerFileEncryptionInfoProto;
class RecoveringBlockProto;
class RemoteEditLogManifestProto;
class RemoteEditLogProto;
class RollingUpgradeStatusProto;
class SnapshotDiffReportEntryProto;
class SnapshotDiffReportProto;
class SnapshotInfoProto;
class SnapshottableDirectoryListingProto;
class SnapshottableDirectoryStatusProto;
class StorageInfoProto;
class StorageReportProto;
class StorageTypeQuotaInfoProto;
class StorageTypeQuotaInfosProto;
class StorageTypesProto;
class StorageUuidsProto;
class VersionRequestProto;
class VersionResponseProto;
class ZoneEncryptionInfoProto;

enum DatanodeInfoProto_AdminState {
  DatanodeInfoProto_AdminState_NORMAL = 0,
  DatanodeInfoProto_AdminState_DECOMMISSION_INPROGRESS = 1,
  DatanodeInfoProto_AdminState_DECOMMISSIONED = 2
};
bool DatanodeInfoProto_AdminState_IsValid(int value);
const DatanodeInfoProto_AdminState DatanodeInfoProto_AdminState_AdminState_MIN = DatanodeInfoProto_AdminState_NORMAL;
const DatanodeInfoProto_AdminState DatanodeInfoProto_AdminState_AdminState_MAX = DatanodeInfoProto_AdminState_DECOMMISSIONED;
const int DatanodeInfoProto_AdminState_AdminState_ARRAYSIZE = DatanodeInfoProto_AdminState_AdminState_MAX + 1;

const ::google::protobuf::EnumDescriptor* DatanodeInfoProto_AdminState_descriptor();
inline const ::std::string& DatanodeInfoProto_AdminState_Name(DatanodeInfoProto_AdminState value) {
  return ::google::protobuf::internal::NameOfEnum(
    DatanodeInfoProto_AdminState_descriptor(), value);
}
inline bool DatanodeInfoProto_AdminState_Parse(
    const ::std::string& name, DatanodeInfoProto_AdminState* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DatanodeInfoProto_AdminState>(
    DatanodeInfoProto_AdminState_descriptor(), name, value);
}
enum DatanodeStorageProto_StorageState {
  DatanodeStorageProto_StorageState_NORMAL = 0,
  DatanodeStorageProto_StorageState_READ_ONLY_SHARED = 1
};
bool DatanodeStorageProto_StorageState_IsValid(int value);
const DatanodeStorageProto_StorageState DatanodeStorageProto_StorageState_StorageState_MIN = DatanodeStorageProto_StorageState_NORMAL;
const DatanodeStorageProto_StorageState DatanodeStorageProto_StorageState_StorageState_MAX = DatanodeStorageProto_StorageState_READ_ONLY_SHARED;
const int DatanodeStorageProto_StorageState_StorageState_ARRAYSIZE = DatanodeStorageProto_StorageState_StorageState_MAX + 1;

const ::google::protobuf::EnumDescriptor* DatanodeStorageProto_StorageState_descriptor();
inline const ::std::string& DatanodeStorageProto_StorageState_Name(DatanodeStorageProto_StorageState value) {
  return ::google::protobuf::internal::NameOfEnum(
    DatanodeStorageProto_StorageState_descriptor(), value);
}
inline bool DatanodeStorageProto_StorageState_Parse(
    const ::std::string& name, DatanodeStorageProto_StorageState* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DatanodeStorageProto_StorageState>(
    DatanodeStorageProto_StorageState_descriptor(), name, value);
}
enum HdfsFileStatusProto_FileType {
  HdfsFileStatusProto_FileType_IS_DIR = 1,
  HdfsFileStatusProto_FileType_IS_FILE = 2,
  HdfsFileStatusProto_FileType_IS_SYMLINK = 3
};
bool HdfsFileStatusProto_FileType_IsValid(int value);
const HdfsFileStatusProto_FileType HdfsFileStatusProto_FileType_FileType_MIN = HdfsFileStatusProto_FileType_IS_DIR;
const HdfsFileStatusProto_FileType HdfsFileStatusProto_FileType_FileType_MAX = HdfsFileStatusProto_FileType_IS_SYMLINK;
const int HdfsFileStatusProto_FileType_FileType_ARRAYSIZE = HdfsFileStatusProto_FileType_FileType_MAX + 1;

const ::google::protobuf::EnumDescriptor* HdfsFileStatusProto_FileType_descriptor();
inline const ::std::string& HdfsFileStatusProto_FileType_Name(HdfsFileStatusProto_FileType value) {
  return ::google::protobuf::internal::NameOfEnum(
    HdfsFileStatusProto_FileType_descriptor(), value);
}
inline bool HdfsFileStatusProto_FileType_Parse(
    const ::std::string& name, HdfsFileStatusProto_FileType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HdfsFileStatusProto_FileType>(
    HdfsFileStatusProto_FileType_descriptor(), name, value);
}
enum NamenodeRegistrationProto_NamenodeRoleProto {
  NamenodeRegistrationProto_NamenodeRoleProto_NAMENODE = 1,
  NamenodeRegistrationProto_NamenodeRoleProto_BACKUP = 2,
  NamenodeRegistrationProto_NamenodeRoleProto_CHECKPOINT = 3
};
bool NamenodeRegistrationProto_NamenodeRoleProto_IsValid(int value);
const NamenodeRegistrationProto_NamenodeRoleProto NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MIN = NamenodeRegistrationProto_NamenodeRoleProto_NAMENODE;
const NamenodeRegistrationProto_NamenodeRoleProto NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MAX = NamenodeRegistrationProto_NamenodeRoleProto_CHECKPOINT;
const int NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_ARRAYSIZE = NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MAX + 1;

const ::google::protobuf::EnumDescriptor* NamenodeRegistrationProto_NamenodeRoleProto_descriptor();
inline const ::std::string& NamenodeRegistrationProto_NamenodeRoleProto_Name(NamenodeRegistrationProto_NamenodeRoleProto value) {
  return ::google::protobuf::internal::NameOfEnum(
    NamenodeRegistrationProto_NamenodeRoleProto_descriptor(), value);
}
inline bool NamenodeRegistrationProto_NamenodeRoleProto_Parse(
    const ::std::string& name, NamenodeRegistrationProto_NamenodeRoleProto* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NamenodeRegistrationProto_NamenodeRoleProto>(
    NamenodeRegistrationProto_NamenodeRoleProto_descriptor(), name, value);
}
enum NamenodeCommandProto_Type {
  NamenodeCommandProto_Type_NamenodeCommand = 0,
  NamenodeCommandProto_Type_CheckPointCommand = 1
};
bool NamenodeCommandProto_Type_IsValid(int value);
const NamenodeCommandProto_Type NamenodeCommandProto_Type_Type_MIN = NamenodeCommandProto_Type_NamenodeCommand;
const NamenodeCommandProto_Type NamenodeCommandProto_Type_Type_MAX = NamenodeCommandProto_Type_CheckPointCommand;
const int NamenodeCommandProto_Type_Type_ARRAYSIZE = NamenodeCommandProto_Type_Type_MAX + 1;

const ::google::protobuf::EnumDescriptor* NamenodeCommandProto_Type_descriptor();
inline const ::std::string& NamenodeCommandProto_Type_Name(NamenodeCommandProto_Type value) {
  return ::google::protobuf::internal::NameOfEnum(
    NamenodeCommandProto_Type_descriptor(), value);
}
inline bool NamenodeCommandProto_Type_Parse(
    const ::std::string& name, NamenodeCommandProto_Type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NamenodeCommandProto_Type>(
    NamenodeCommandProto_Type_descriptor(), name, value);
}
enum StorageTypeProto {
  DISK = 1,
  SSD = 2,
  ARCHIVE = 3,
  RAM_DISK = 4
};
bool StorageTypeProto_IsValid(int value);
const StorageTypeProto StorageTypeProto_MIN = DISK;
const StorageTypeProto StorageTypeProto_MAX = RAM_DISK;
const int StorageTypeProto_ARRAYSIZE = StorageTypeProto_MAX + 1;

const ::google::protobuf::EnumDescriptor* StorageTypeProto_descriptor();
inline const ::std::string& StorageTypeProto_Name(StorageTypeProto value) {
  return ::google::protobuf::internal::NameOfEnum(
    StorageTypeProto_descriptor(), value);
}
inline bool StorageTypeProto_Parse(
    const ::std::string& name, StorageTypeProto* value) {
  return ::google::protobuf::internal::ParseNamedEnum<StorageTypeProto>(
    StorageTypeProto_descriptor(), name, value);
}
enum CipherSuiteProto {
  UNKNOWN = 1,
  AES_CTR_NOPADDING = 2
};
bool CipherSuiteProto_IsValid(int value);
const CipherSuiteProto CipherSuiteProto_MIN = UNKNOWN;
const CipherSuiteProto CipherSuiteProto_MAX = AES_CTR_NOPADDING;
const int CipherSuiteProto_ARRAYSIZE = CipherSuiteProto_MAX + 1;

const ::google::protobuf::EnumDescriptor* CipherSuiteProto_descriptor();
inline const ::std::string& CipherSuiteProto_Name(CipherSuiteProto value) {
  return ::google::protobuf::internal::NameOfEnum(
    CipherSuiteProto_descriptor(), value);
}
inline bool CipherSuiteProto_Parse(
    const ::std::string& name, CipherSuiteProto* value) {
  return ::google::protobuf::internal::ParseNamedEnum<CipherSuiteProto>(
    CipherSuiteProto_descriptor(), name, value);
}
enum CryptoProtocolVersionProto {
  UNKNOWN_PROTOCOL_VERSION = 1,
  ENCRYPTION_ZONES = 2
};
bool CryptoProtocolVersionProto_IsValid(int value);
const CryptoProtocolVersionProto CryptoProtocolVersionProto_MIN = UNKNOWN_PROTOCOL_VERSION;
const CryptoProtocolVersionProto CryptoProtocolVersionProto_MAX = ENCRYPTION_ZONES;
const int CryptoProtocolVersionProto_ARRAYSIZE = CryptoProtocolVersionProto_MAX + 1;

const ::google::protobuf::EnumDescriptor* CryptoProtocolVersionProto_descriptor();
inline const ::std::string& CryptoProtocolVersionProto_Name(CryptoProtocolVersionProto value) {
  return ::google::protobuf::internal::NameOfEnum(
    CryptoProtocolVersionProto_descriptor(), value);
}
inline bool CryptoProtocolVersionProto_Parse(
    const ::std::string& name, CryptoProtocolVersionProto* value) {
  return ::google::protobuf::internal::ParseNamedEnum<CryptoProtocolVersionProto>(
    CryptoProtocolVersionProto_descriptor(), name, value);
}
enum ErasureCodingPolicyState {
  DISABLED = 1,
  ENABLED = 2,
  REMOVED = 3
};
bool ErasureCodingPolicyState_IsValid(int value);
const ErasureCodingPolicyState ErasureCodingPolicyState_MIN = DISABLED;
const ErasureCodingPolicyState ErasureCodingPolicyState_MAX = REMOVED;
const int ErasureCodingPolicyState_ARRAYSIZE = ErasureCodingPolicyState_MAX + 1;

const ::google::protobuf::EnumDescriptor* ErasureCodingPolicyState_descriptor();
inline const ::std::string& ErasureCodingPolicyState_Name(ErasureCodingPolicyState value) {
  return ::google::protobuf::internal::NameOfEnum(
    ErasureCodingPolicyState_descriptor(), value);
}
inline bool ErasureCodingPolicyState_Parse(
    const ::std::string& name, ErasureCodingPolicyState* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ErasureCodingPolicyState>(
    ErasureCodingPolicyState_descriptor(), name, value);
}
enum ChecksumTypeProto {
  CHECKSUM_NULL = 0,
  CHECKSUM_CRC32 = 1,
  CHECKSUM_CRC32C = 2
};
bool ChecksumTypeProto_IsValid(int value);
const ChecksumTypeProto ChecksumTypeProto_MIN = CHECKSUM_NULL;
const ChecksumTypeProto ChecksumTypeProto_MAX = CHECKSUM_CRC32C;
const int ChecksumTypeProto_ARRAYSIZE = ChecksumTypeProto_MAX + 1;

const ::google::protobuf::EnumDescriptor* ChecksumTypeProto_descriptor();
inline const ::std::string& ChecksumTypeProto_Name(ChecksumTypeProto value) {
  return ::google::protobuf::internal::NameOfEnum(
    ChecksumTypeProto_descriptor(), value);
}
inline bool ChecksumTypeProto_Parse(
    const ::std::string& name, ChecksumTypeProto* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ChecksumTypeProto>(
    ChecksumTypeProto_descriptor(), name, value);
}
enum ReplicaStateProto {
  FINALIZED = 0,
  RBW = 1,
  RWR = 2,
  RUR = 3,
  TEMPORARY = 4
};
bool ReplicaStateProto_IsValid(int value);
const ReplicaStateProto ReplicaStateProto_MIN = FINALIZED;
const ReplicaStateProto ReplicaStateProto_MAX = TEMPORARY;
const int ReplicaStateProto_ARRAYSIZE = ReplicaStateProto_MAX + 1;

const ::google::protobuf::EnumDescriptor* ReplicaStateProto_descriptor();
inline const ::std::string& ReplicaStateProto_Name(ReplicaStateProto value) {
  return ::google::protobuf::internal::NameOfEnum(
    ReplicaStateProto_descriptor(), value);
}
inline bool ReplicaStateProto_Parse(
    const ::std::string& name, ReplicaStateProto* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ReplicaStateProto>(
    ReplicaStateProto_descriptor(), name, value);
}
// ===================================================================

class ExtendedBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ExtendedBlockProto) */ {
 public:
  ExtendedBlockProto();
  virtual ~ExtendedBlockProto();

  ExtendedBlockProto(const ExtendedBlockProto& from);

  inline ExtendedBlockProto& operator=(const ExtendedBlockProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ExtendedBlockProto& default_instance();

  void Swap(ExtendedBlockProto* other);

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

  inline ExtendedBlockProto* New() const { return New(NULL); }

  ExtendedBlockProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ExtendedBlockProto& from);
  void MergeFrom(const ExtendedBlockProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ExtendedBlockProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string poolId = 1;
  bool has_poolid() const;
  void clear_poolid();
  static const int kPoolIdFieldNumber = 1;
  const ::std::string& poolid() const;
  void set_poolid(const ::std::string& value);
  void set_poolid(const char* value);
  void set_poolid(const char* value, size_t size);
  ::std::string* mutable_poolid();
  ::std::string* release_poolid();
  void set_allocated_poolid(::std::string* poolid);

  // required uint64 blockId = 2;
  bool has_blockid() const;
  void clear_blockid();
  static const int kBlockIdFieldNumber = 2;
  ::google::protobuf::uint64 blockid() const;
  void set_blockid(::google::protobuf::uint64 value);

  // required uint64 generationStamp = 3;
  bool has_generationstamp() const;
  void clear_generationstamp();
  static const int kGenerationStampFieldNumber = 3;
  ::google::protobuf::uint64 generationstamp() const;
  void set_generationstamp(::google::protobuf::uint64 value);

  // optional uint64 numBytes = 4 [default = 0];
  bool has_numbytes() const;
  void clear_numbytes();
  static const int kNumBytesFieldNumber = 4;
  ::google::protobuf::uint64 numbytes() const;
  void set_numbytes(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ExtendedBlockProto)
 private:
  inline void set_has_poolid();
  inline void clear_has_poolid();
  inline void set_has_blockid();
  inline void clear_has_blockid();
  inline void set_has_generationstamp();
  inline void clear_has_generationstamp();
  inline void set_has_numbytes();
  inline void clear_has_numbytes();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr poolid_;
  ::google::protobuf::uint64 blockid_;
  ::google::protobuf::uint64 generationstamp_;
  ::google::protobuf::uint64 numbytes_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static ExtendedBlockProto* default_instance_;
};
// -------------------------------------------------------------------

class DatanodeIDProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.DatanodeIDProto) */ {
 public:
  DatanodeIDProto();
  virtual ~DatanodeIDProto();

  DatanodeIDProto(const DatanodeIDProto& from);

  inline DatanodeIDProto& operator=(const DatanodeIDProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DatanodeIDProto& default_instance();

  void Swap(DatanodeIDProto* other);

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

  inline DatanodeIDProto* New() const { return New(NULL); }

  DatanodeIDProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DatanodeIDProto& from);
  void MergeFrom(const DatanodeIDProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DatanodeIDProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string ipAddr = 1;
  bool has_ipaddr() const;
  void clear_ipaddr();
  static const int kIpAddrFieldNumber = 1;
  const ::std::string& ipaddr() const;
  void set_ipaddr(const ::std::string& value);
  void set_ipaddr(const char* value);
  void set_ipaddr(const char* value, size_t size);
  ::std::string* mutable_ipaddr();
  ::std::string* release_ipaddr();
  void set_allocated_ipaddr(::std::string* ipaddr);

  // required string hostName = 2;
  bool has_hostname() const;
  void clear_hostname();
  static const int kHostNameFieldNumber = 2;
  const ::std::string& hostname() const;
  void set_hostname(const ::std::string& value);
  void set_hostname(const char* value);
  void set_hostname(const char* value, size_t size);
  ::std::string* mutable_hostname();
  ::std::string* release_hostname();
  void set_allocated_hostname(::std::string* hostname);

  // required string datanodeUuid = 3;
  bool has_datanodeuuid() const;
  void clear_datanodeuuid();
  static const int kDatanodeUuidFieldNumber = 3;
  const ::std::string& datanodeuuid() const;
  void set_datanodeuuid(const ::std::string& value);
  void set_datanodeuuid(const char* value);
  void set_datanodeuuid(const char* value, size_t size);
  ::std::string* mutable_datanodeuuid();
  ::std::string* release_datanodeuuid();
  void set_allocated_datanodeuuid(::std::string* datanodeuuid);

  // required uint32 xferPort = 4;
  bool has_xferport() const;
  void clear_xferport();
  static const int kXferPortFieldNumber = 4;
  ::google::protobuf::uint32 xferport() const;
  void set_xferport(::google::protobuf::uint32 value);

  // required uint32 infoPort = 5;
  bool has_infoport() const;
  void clear_infoport();
  static const int kInfoPortFieldNumber = 5;
  ::google::protobuf::uint32 infoport() const;
  void set_infoport(::google::protobuf::uint32 value);

  // required uint32 ipcPort = 6;
  bool has_ipcport() const;
  void clear_ipcport();
  static const int kIpcPortFieldNumber = 6;
  ::google::protobuf::uint32 ipcport() const;
  void set_ipcport(::google::protobuf::uint32 value);

  // optional uint32 infoSecurePort = 7 [default = 0];
  bool has_infosecureport() const;
  void clear_infosecureport();
  static const int kInfoSecurePortFieldNumber = 7;
  ::google::protobuf::uint32 infosecureport() const;
  void set_infosecureport(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.DatanodeIDProto)
 private:
  inline void set_has_ipaddr();
  inline void clear_has_ipaddr();
  inline void set_has_hostname();
  inline void clear_has_hostname();
  inline void set_has_datanodeuuid();
  inline void clear_has_datanodeuuid();
  inline void set_has_xferport();
  inline void clear_has_xferport();
  inline void set_has_infoport();
  inline void clear_has_infoport();
  inline void set_has_ipcport();
  inline void clear_has_ipcport();
  inline void set_has_infosecureport();
  inline void clear_has_infosecureport();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr ipaddr_;
  ::google::protobuf::internal::ArenaStringPtr hostname_;
  ::google::protobuf::internal::ArenaStringPtr datanodeuuid_;
  ::google::protobuf::uint32 xferport_;
  ::google::protobuf::uint32 infoport_;
  ::google::protobuf::uint32 ipcport_;
  ::google::protobuf::uint32 infosecureport_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static DatanodeIDProto* default_instance_;
};
// -------------------------------------------------------------------

class DatanodeLocalInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.DatanodeLocalInfoProto) */ {
 public:
  DatanodeLocalInfoProto();
  virtual ~DatanodeLocalInfoProto();

  DatanodeLocalInfoProto(const DatanodeLocalInfoProto& from);

  inline DatanodeLocalInfoProto& operator=(const DatanodeLocalInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DatanodeLocalInfoProto& default_instance();

  void Swap(DatanodeLocalInfoProto* other);

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

  inline DatanodeLocalInfoProto* New() const { return New(NULL); }

  DatanodeLocalInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DatanodeLocalInfoProto& from);
  void MergeFrom(const DatanodeLocalInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DatanodeLocalInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string softwareVersion = 1;
  bool has_softwareversion() const;
  void clear_softwareversion();
  static const int kSoftwareVersionFieldNumber = 1;
  const ::std::string& softwareversion() const;
  void set_softwareversion(const ::std::string& value);
  void set_softwareversion(const char* value);
  void set_softwareversion(const char* value, size_t size);
  ::std::string* mutable_softwareversion();
  ::std::string* release_softwareversion();
  void set_allocated_softwareversion(::std::string* softwareversion);

  // required string configVersion = 2;
  bool has_configversion() const;
  void clear_configversion();
  static const int kConfigVersionFieldNumber = 2;
  const ::std::string& configversion() const;
  void set_configversion(const ::std::string& value);
  void set_configversion(const char* value);
  void set_configversion(const char* value, size_t size);
  ::std::string* mutable_configversion();
  ::std::string* release_configversion();
  void set_allocated_configversion(::std::string* configversion);

  // required uint64 uptime = 3;
  bool has_uptime() const;
  void clear_uptime();
  static const int kUptimeFieldNumber = 3;
  ::google::protobuf::uint64 uptime() const;
  void set_uptime(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.DatanodeLocalInfoProto)
 private:
  inline void set_has_softwareversion();
  inline void clear_has_softwareversion();
  inline void set_has_configversion();
  inline void clear_has_configversion();
  inline void set_has_uptime();
  inline void clear_has_uptime();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr softwareversion_;
  ::google::protobuf::internal::ArenaStringPtr configversion_;
  ::google::protobuf::uint64 uptime_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static DatanodeLocalInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class DatanodeInfosProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.DatanodeInfosProto) */ {
 public:
  DatanodeInfosProto();
  virtual ~DatanodeInfosProto();

  DatanodeInfosProto(const DatanodeInfosProto& from);

  inline DatanodeInfosProto& operator=(const DatanodeInfosProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DatanodeInfosProto& default_instance();

  void Swap(DatanodeInfosProto* other);

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

  inline DatanodeInfosProto* New() const { return New(NULL); }

  DatanodeInfosProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DatanodeInfosProto& from);
  void MergeFrom(const DatanodeInfosProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DatanodeInfosProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .hadoop.hdfs.DatanodeInfoProto datanodes = 1;
  int datanodes_size() const;
  void clear_datanodes();
  static const int kDatanodesFieldNumber = 1;
  const ::hadoop::hdfs::DatanodeInfoProto& datanodes(int index) const;
  ::hadoop::hdfs::DatanodeInfoProto* mutable_datanodes(int index);
  ::hadoop::hdfs::DatanodeInfoProto* add_datanodes();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto >*
      mutable_datanodes();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto >&
      datanodes() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.DatanodeInfosProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto > datanodes_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static DatanodeInfosProto* default_instance_;
};
// -------------------------------------------------------------------

class DatanodeInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.DatanodeInfoProto) */ {
 public:
  DatanodeInfoProto();
  virtual ~DatanodeInfoProto();

  DatanodeInfoProto(const DatanodeInfoProto& from);

  inline DatanodeInfoProto& operator=(const DatanodeInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DatanodeInfoProto& default_instance();

  void Swap(DatanodeInfoProto* other);

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

  inline DatanodeInfoProto* New() const { return New(NULL); }

  DatanodeInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DatanodeInfoProto& from);
  void MergeFrom(const DatanodeInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DatanodeInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef DatanodeInfoProto_AdminState AdminState;
  static const AdminState NORMAL =
    DatanodeInfoProto_AdminState_NORMAL;
  static const AdminState DECOMMISSION_INPROGRESS =
    DatanodeInfoProto_AdminState_DECOMMISSION_INPROGRESS;
  static const AdminState DECOMMISSIONED =
    DatanodeInfoProto_AdminState_DECOMMISSIONED;
  static inline bool AdminState_IsValid(int value) {
    return DatanodeInfoProto_AdminState_IsValid(value);
  }
  static const AdminState AdminState_MIN =
    DatanodeInfoProto_AdminState_AdminState_MIN;
  static const AdminState AdminState_MAX =
    DatanodeInfoProto_AdminState_AdminState_MAX;
  static const int AdminState_ARRAYSIZE =
    DatanodeInfoProto_AdminState_AdminState_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  AdminState_descriptor() {
    return DatanodeInfoProto_AdminState_descriptor();
  }
  static inline const ::std::string& AdminState_Name(AdminState value) {
    return DatanodeInfoProto_AdminState_Name(value);
  }
  static inline bool AdminState_Parse(const ::std::string& name,
      AdminState* value) {
    return DatanodeInfoProto_AdminState_Parse(name, value);
  }

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

  // required .hadoop.hdfs.DatanodeIDProto id = 1;
  bool has_id() const;
  void clear_id();
  static const int kIdFieldNumber = 1;
  const ::hadoop::hdfs::DatanodeIDProto& id() const;
  ::hadoop::hdfs::DatanodeIDProto* mutable_id();
  ::hadoop::hdfs::DatanodeIDProto* release_id();
  void set_allocated_id(::hadoop::hdfs::DatanodeIDProto* id);

  // optional uint64 capacity = 2 [default = 0];
  bool has_capacity() const;
  void clear_capacity();
  static const int kCapacityFieldNumber = 2;
  ::google::protobuf::uint64 capacity() const;
  void set_capacity(::google::protobuf::uint64 value);

  // optional uint64 dfsUsed = 3 [default = 0];
  bool has_dfsused() const;
  void clear_dfsused();
  static const int kDfsUsedFieldNumber = 3;
  ::google::protobuf::uint64 dfsused() const;
  void set_dfsused(::google::protobuf::uint64 value);

  // optional uint64 remaining = 4 [default = 0];
  bool has_remaining() const;
  void clear_remaining();
  static const int kRemainingFieldNumber = 4;
  ::google::protobuf::uint64 remaining() const;
  void set_remaining(::google::protobuf::uint64 value);

  // optional uint64 blockPoolUsed = 5 [default = 0];
  bool has_blockpoolused() const;
  void clear_blockpoolused();
  static const int kBlockPoolUsedFieldNumber = 5;
  ::google::protobuf::uint64 blockpoolused() const;
  void set_blockpoolused(::google::protobuf::uint64 value);

  // optional uint64 lastUpdate = 6 [default = 0];
  bool has_lastupdate() const;
  void clear_lastupdate();
  static const int kLastUpdateFieldNumber = 6;
  ::google::protobuf::uint64 lastupdate() const;
  void set_lastupdate(::google::protobuf::uint64 value);

  // optional uint32 xceiverCount = 7 [default = 0];
  bool has_xceivercount() const;
  void clear_xceivercount();
  static const int kXceiverCountFieldNumber = 7;
  ::google::protobuf::uint32 xceivercount() const;
  void set_xceivercount(::google::protobuf::uint32 value);

  // optional string location = 8;
  bool has_location() const;
  void clear_location();
  static const int kLocationFieldNumber = 8;
  const ::std::string& location() const;
  void set_location(const ::std::string& value);
  void set_location(const char* value);
  void set_location(const char* value, size_t size);
  ::std::string* mutable_location();
  ::std::string* release_location();
  void set_allocated_location(::std::string* location);

  // optional .hadoop.hdfs.DatanodeInfoProto.AdminState adminState = 10 [default = NORMAL];
  bool has_adminstate() const;
  void clear_adminstate();
  static const int kAdminStateFieldNumber = 10;
  ::hadoop::hdfs::DatanodeInfoProto_AdminState adminstate() const;
  void set_adminstate(::hadoop::hdfs::DatanodeInfoProto_AdminState value);

  // optional uint64 cacheCapacity = 11 [default = 0];
  bool has_cachecapacity() const;
  void clear_cachecapacity();
  static const int kCacheCapacityFieldNumber = 11;
  ::google::protobuf::uint64 cachecapacity() const;
  void set_cachecapacity(::google::protobuf::uint64 value);

  // optional uint64 cacheUsed = 12 [default = 0];
  bool has_cacheused() const;
  void clear_cacheused();
  static const int kCacheUsedFieldNumber = 12;
  ::google::protobuf::uint64 cacheused() const;
  void set_cacheused(::google::protobuf::uint64 value);

  // optional uint64 lastUpdateMonotonic = 13 [default = 0];
  bool has_lastupdatemonotonic() const;
  void clear_lastupdatemonotonic();
  static const int kLastUpdateMonotonicFieldNumber = 13;
  ::google::protobuf::uint64 lastupdatemonotonic() const;
  void set_lastupdatemonotonic(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.DatanodeInfoProto)
 private:
  inline void set_has_id();
  inline void clear_has_id();
  inline void set_has_capacity();
  inline void clear_has_capacity();
  inline void set_has_dfsused();
  inline void clear_has_dfsused();
  inline void set_has_remaining();
  inline void clear_has_remaining();
  inline void set_has_blockpoolused();
  inline void clear_has_blockpoolused();
  inline void set_has_lastupdate();
  inline void clear_has_lastupdate();
  inline void set_has_xceivercount();
  inline void clear_has_xceivercount();
  inline void set_has_location();
  inline void clear_has_location();
  inline void set_has_adminstate();
  inline void clear_has_adminstate();
  inline void set_has_cachecapacity();
  inline void clear_has_cachecapacity();
  inline void set_has_cacheused();
  inline void clear_has_cacheused();
  inline void set_has_lastupdatemonotonic();
  inline void clear_has_lastupdatemonotonic();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::hadoop::hdfs::DatanodeIDProto* id_;
  ::google::protobuf::uint64 capacity_;
  ::google::protobuf::uint64 dfsused_;
  ::google::protobuf::uint64 remaining_;
  ::google::protobuf::uint64 blockpoolused_;
  ::google::protobuf::uint64 lastupdate_;
  ::google::protobuf::internal::ArenaStringPtr location_;
  ::google::protobuf::uint32 xceivercount_;
  int adminstate_;
  ::google::protobuf::uint64 cachecapacity_;
  ::google::protobuf::uint64 cacheused_;
  ::google::protobuf::uint64 lastupdatemonotonic_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static DatanodeInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class DatanodeStorageProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.DatanodeStorageProto) */ {
 public:
  DatanodeStorageProto();
  virtual ~DatanodeStorageProto();

  DatanodeStorageProto(const DatanodeStorageProto& from);

  inline DatanodeStorageProto& operator=(const DatanodeStorageProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DatanodeStorageProto& default_instance();

  void Swap(DatanodeStorageProto* other);

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

  inline DatanodeStorageProto* New() const { return New(NULL); }

  DatanodeStorageProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DatanodeStorageProto& from);
  void MergeFrom(const DatanodeStorageProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DatanodeStorageProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef DatanodeStorageProto_StorageState StorageState;
  static const StorageState NORMAL =
    DatanodeStorageProto_StorageState_NORMAL;
  static const StorageState READ_ONLY_SHARED =
    DatanodeStorageProto_StorageState_READ_ONLY_SHARED;
  static inline bool StorageState_IsValid(int value) {
    return DatanodeStorageProto_StorageState_IsValid(value);
  }
  static const StorageState StorageState_MIN =
    DatanodeStorageProto_StorageState_StorageState_MIN;
  static const StorageState StorageState_MAX =
    DatanodeStorageProto_StorageState_StorageState_MAX;
  static const int StorageState_ARRAYSIZE =
    DatanodeStorageProto_StorageState_StorageState_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  StorageState_descriptor() {
    return DatanodeStorageProto_StorageState_descriptor();
  }
  static inline const ::std::string& StorageState_Name(StorageState value) {
    return DatanodeStorageProto_StorageState_Name(value);
  }
  static inline bool StorageState_Parse(const ::std::string& name,
      StorageState* value) {
    return DatanodeStorageProto_StorageState_Parse(name, value);
  }

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

  // required string storageUuid = 1;
  bool has_storageuuid() const;
  void clear_storageuuid();
  static const int kStorageUuidFieldNumber = 1;
  const ::std::string& storageuuid() const;
  void set_storageuuid(const ::std::string& value);
  void set_storageuuid(const char* value);
  void set_storageuuid(const char* value, size_t size);
  ::std::string* mutable_storageuuid();
  ::std::string* release_storageuuid();
  void set_allocated_storageuuid(::std::string* storageuuid);

  // optional .hadoop.hdfs.DatanodeStorageProto.StorageState state = 2 [default = NORMAL];
  bool has_state() const;
  void clear_state();
  static const int kStateFieldNumber = 2;
  ::hadoop::hdfs::DatanodeStorageProto_StorageState state() const;
  void set_state(::hadoop::hdfs::DatanodeStorageProto_StorageState value);

  // optional .hadoop.hdfs.StorageTypeProto storageType = 3 [default = DISK];
  bool has_storagetype() const;
  void clear_storagetype();
  static const int kStorageTypeFieldNumber = 3;
  ::hadoop::hdfs::StorageTypeProto storagetype() const;
  void set_storagetype(::hadoop::hdfs::StorageTypeProto value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.DatanodeStorageProto)
 private:
  inline void set_has_storageuuid();
  inline void clear_has_storageuuid();
  inline void set_has_state();
  inline void clear_has_state();
  inline void set_has_storagetype();
  inline void clear_has_storagetype();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr storageuuid_;
  int state_;
  int storagetype_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static DatanodeStorageProto* default_instance_;
};
// -------------------------------------------------------------------

class StorageReportProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.StorageReportProto) */ {
 public:
  StorageReportProto();
  virtual ~StorageReportProto();

  StorageReportProto(const StorageReportProto& from);

  inline StorageReportProto& operator=(const StorageReportProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StorageReportProto& default_instance();

  void Swap(StorageReportProto* other);

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

  inline StorageReportProto* New() const { return New(NULL); }

  StorageReportProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StorageReportProto& from);
  void MergeFrom(const StorageReportProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StorageReportProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string storageUuid = 1 [deprecated = true];
  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool has_storageuuid() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_storageuuid();
  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kStorageUuidFieldNumber = 1;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR const ::std::string& storageuuid() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_storageuuid(const ::std::string& value);
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_storageuuid(const char* value);
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_storageuuid(const char* value, size_t size);
  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::std::string* mutable_storageuuid();
  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::std::string* release_storageuuid();
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_allocated_storageuuid(::std::string* storageuuid);

  // optional bool failed = 2 [default = false];
  bool has_failed() const;
  void clear_failed();
  static const int kFailedFieldNumber = 2;
  bool failed() const;
  void set_failed(bool value);

  // optional uint64 capacity = 3 [default = 0];
  bool has_capacity() const;
  void clear_capacity();
  static const int kCapacityFieldNumber = 3;
  ::google::protobuf::uint64 capacity() const;
  void set_capacity(::google::protobuf::uint64 value);

  // optional uint64 dfsUsed = 4 [default = 0];
  bool has_dfsused() const;
  void clear_dfsused();
  static const int kDfsUsedFieldNumber = 4;
  ::google::protobuf::uint64 dfsused() const;
  void set_dfsused(::google::protobuf::uint64 value);

  // optional uint64 remaining = 5 [default = 0];
  bool has_remaining() const;
  void clear_remaining();
  static const int kRemainingFieldNumber = 5;
  ::google::protobuf::uint64 remaining() const;
  void set_remaining(::google::protobuf::uint64 value);

  // optional uint64 blockPoolUsed = 6 [default = 0];
  bool has_blockpoolused() const;
  void clear_blockpoolused();
  static const int kBlockPoolUsedFieldNumber = 6;
  ::google::protobuf::uint64 blockpoolused() const;
  void set_blockpoolused(::google::protobuf::uint64 value);

  // optional .hadoop.hdfs.DatanodeStorageProto storage = 7;
  bool has_storage() const;
  void clear_storage();
  static const int kStorageFieldNumber = 7;
  const ::hadoop::hdfs::DatanodeStorageProto& storage() const;
  ::hadoop::hdfs::DatanodeStorageProto* mutable_storage();
  ::hadoop::hdfs::DatanodeStorageProto* release_storage();
  void set_allocated_storage(::hadoop::hdfs::DatanodeStorageProto* storage);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.StorageReportProto)
 private:
  inline void set_has_storageuuid();
  inline void clear_has_storageuuid();
  inline void set_has_failed();
  inline void clear_has_failed();
  inline void set_has_capacity();
  inline void clear_has_capacity();
  inline void set_has_dfsused();
  inline void clear_has_dfsused();
  inline void set_has_remaining();
  inline void clear_has_remaining();
  inline void set_has_blockpoolused();
  inline void clear_has_blockpoolused();
  inline void set_has_storage();
  inline void clear_has_storage();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr storageuuid_;
  ::google::protobuf::uint64 capacity_;
  ::google::protobuf::uint64 dfsused_;
  ::google::protobuf::uint64 remaining_;
  ::google::protobuf::uint64 blockpoolused_;
  ::hadoop::hdfs::DatanodeStorageProto* storage_;
  bool failed_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static StorageReportProto* default_instance_;
};
// -------------------------------------------------------------------

class ContentSummaryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ContentSummaryProto) */ {
 public:
  ContentSummaryProto();
  virtual ~ContentSummaryProto();

  ContentSummaryProto(const ContentSummaryProto& from);

  inline ContentSummaryProto& operator=(const ContentSummaryProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ContentSummaryProto& default_instance();

  void Swap(ContentSummaryProto* other);

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

  inline ContentSummaryProto* New() const { return New(NULL); }

  ContentSummaryProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ContentSummaryProto& from);
  void MergeFrom(const ContentSummaryProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ContentSummaryProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint64 length = 1;
  bool has_length() const;
  void clear_length();
  static const int kLengthFieldNumber = 1;
  ::google::protobuf::uint64 length() const;
  void set_length(::google::protobuf::uint64 value);

  // required uint64 fileCount = 2;
  bool has_filecount() const;
  void clear_filecount();
  static const int kFileCountFieldNumber = 2;
  ::google::protobuf::uint64 filecount() const;
  void set_filecount(::google::protobuf::uint64 value);

  // required uint64 directoryCount = 3;
  bool has_directorycount() const;
  void clear_directorycount();
  static const int kDirectoryCountFieldNumber = 3;
  ::google::protobuf::uint64 directorycount() const;
  void set_directorycount(::google::protobuf::uint64 value);

  // required uint64 quota = 4;
  bool has_quota() const;
  void clear_quota();
  static const int kQuotaFieldNumber = 4;
  ::google::protobuf::uint64 quota() const;
  void set_quota(::google::protobuf::uint64 value);

  // required uint64 spaceConsumed = 5;
  bool has_spaceconsumed() const;
  void clear_spaceconsumed();
  static const int kSpaceConsumedFieldNumber = 5;
  ::google::protobuf::uint64 spaceconsumed() const;
  void set_spaceconsumed(::google::protobuf::uint64 value);

  // required uint64 spaceQuota = 6;
  bool has_spacequota() const;
  void clear_spacequota();
  static const int kSpaceQuotaFieldNumber = 6;
  ::google::protobuf::uint64 spacequota() const;
  void set_spacequota(::google::protobuf::uint64 value);

  // optional .hadoop.hdfs.StorageTypeQuotaInfosProto typeQuotaInfos = 7;
  bool has_typequotainfos() const;
  void clear_typequotainfos();
  static const int kTypeQuotaInfosFieldNumber = 7;
  const ::hadoop::hdfs::StorageTypeQuotaInfosProto& typequotainfos() const;
  ::hadoop::hdfs::StorageTypeQuotaInfosProto* mutable_typequotainfos();
  ::hadoop::hdfs::StorageTypeQuotaInfosProto* release_typequotainfos();
  void set_allocated_typequotainfos(::hadoop::hdfs::StorageTypeQuotaInfosProto* typequotainfos);

  // optional uint64 snapshotLength = 8;
  bool has_snapshotlength() const;
  void clear_snapshotlength();
  static const int kSnapshotLengthFieldNumber = 8;
  ::google::protobuf::uint64 snapshotlength() const;
  void set_snapshotlength(::google::protobuf::uint64 value);

  // optional uint64 snapshotFileCount = 9;
  bool has_snapshotfilecount() const;
  void clear_snapshotfilecount();
  static const int kSnapshotFileCountFieldNumber = 9;
  ::google::protobuf::uint64 snapshotfilecount() const;
  void set_snapshotfilecount(::google::protobuf::uint64 value);

  // optional uint64 snapshotDirectoryCount = 10;
  bool has_snapshotdirectorycount() const;
  void clear_snapshotdirectorycount();
  static const int kSnapshotDirectoryCountFieldNumber = 10;
  ::google::protobuf::uint64 snapshotdirectorycount() const;
  void set_snapshotdirectorycount(::google::protobuf::uint64 value);

  // optional uint64 snapshotSpaceConsumed = 11;
  bool has_snapshotspaceconsumed() const;
  void clear_snapshotspaceconsumed();
  static const int kSnapshotSpaceConsumedFieldNumber = 11;
  ::google::protobuf::uint64 snapshotspaceconsumed() const;
  void set_snapshotspaceconsumed(::google::protobuf::uint64 value);

  // optional string erasureCodingPolicy = 12;
  bool has_erasurecodingpolicy() const;
  void clear_erasurecodingpolicy();
  static const int kErasureCodingPolicyFieldNumber = 12;
  const ::std::string& erasurecodingpolicy() const;
  void set_erasurecodingpolicy(const ::std::string& value);
  void set_erasurecodingpolicy(const char* value);
  void set_erasurecodingpolicy(const char* value, size_t size);
  ::std::string* mutable_erasurecodingpolicy();
  ::std::string* release_erasurecodingpolicy();
  void set_allocated_erasurecodingpolicy(::std::string* erasurecodingpolicy);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ContentSummaryProto)
 private:
  inline void set_has_length();
  inline void clear_has_length();
  inline void set_has_filecount();
  inline void clear_has_filecount();
  inline void set_has_directorycount();
  inline void clear_has_directorycount();
  inline void set_has_quota();
  inline void clear_has_quota();
  inline void set_has_spaceconsumed();
  inline void clear_has_spaceconsumed();
  inline void set_has_spacequota();
  inline void clear_has_spacequota();
  inline void set_has_typequotainfos();
  inline void clear_has_typequotainfos();
  inline void set_has_snapshotlength();
  inline void clear_has_snapshotlength();
  inline void set_has_snapshotfilecount();
  inline void clear_has_snapshotfilecount();
  inline void set_has_snapshotdirectorycount();
  inline void clear_has_snapshotdirectorycount();
  inline void set_has_snapshotspaceconsumed();
  inline void clear_has_snapshotspaceconsumed();
  inline void set_has_erasurecodingpolicy();
  inline void clear_has_erasurecodingpolicy();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 length_;
  ::google::protobuf::uint64 filecount_;
  ::google::protobuf::uint64 directorycount_;
  ::google::protobuf::uint64 quota_;
  ::google::protobuf::uint64 spaceconsumed_;
  ::google::protobuf::uint64 spacequota_;
  ::hadoop::hdfs::StorageTypeQuotaInfosProto* typequotainfos_;
  ::google::protobuf::uint64 snapshotlength_;
  ::google::protobuf::uint64 snapshotfilecount_;
  ::google::protobuf::uint64 snapshotdirectorycount_;
  ::google::protobuf::uint64 snapshotspaceconsumed_;
  ::google::protobuf::internal::ArenaStringPtr erasurecodingpolicy_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static ContentSummaryProto* default_instance_;
};
// -------------------------------------------------------------------

class StorageTypeQuotaInfosProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.StorageTypeQuotaInfosProto) */ {
 public:
  StorageTypeQuotaInfosProto();
  virtual ~StorageTypeQuotaInfosProto();

  StorageTypeQuotaInfosProto(const StorageTypeQuotaInfosProto& from);

  inline StorageTypeQuotaInfosProto& operator=(const StorageTypeQuotaInfosProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StorageTypeQuotaInfosProto& default_instance();

  void Swap(StorageTypeQuotaInfosProto* other);

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

  inline StorageTypeQuotaInfosProto* New() const { return New(NULL); }

  StorageTypeQuotaInfosProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StorageTypeQuotaInfosProto& from);
  void MergeFrom(const StorageTypeQuotaInfosProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StorageTypeQuotaInfosProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .hadoop.hdfs.StorageTypeQuotaInfoProto typeQuotaInfo = 1;
  int typequotainfo_size() const;
  void clear_typequotainfo();
  static const int kTypeQuotaInfoFieldNumber = 1;
  const ::hadoop::hdfs::StorageTypeQuotaInfoProto& typequotainfo(int index) const;
  ::hadoop::hdfs::StorageTypeQuotaInfoProto* mutable_typequotainfo(int index);
  ::hadoop::hdfs::StorageTypeQuotaInfoProto* add_typequotainfo();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::StorageTypeQuotaInfoProto >*
      mutable_typequotainfo();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::StorageTypeQuotaInfoProto >&
      typequotainfo() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.StorageTypeQuotaInfosProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::StorageTypeQuotaInfoProto > typequotainfo_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static StorageTypeQuotaInfosProto* default_instance_;
};
// -------------------------------------------------------------------

class StorageTypeQuotaInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.StorageTypeQuotaInfoProto) */ {
 public:
  StorageTypeQuotaInfoProto();
  virtual ~StorageTypeQuotaInfoProto();

  StorageTypeQuotaInfoProto(const StorageTypeQuotaInfoProto& from);

  inline StorageTypeQuotaInfoProto& operator=(const StorageTypeQuotaInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StorageTypeQuotaInfoProto& default_instance();

  void Swap(StorageTypeQuotaInfoProto* other);

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

  inline StorageTypeQuotaInfoProto* New() const { return New(NULL); }

  StorageTypeQuotaInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StorageTypeQuotaInfoProto& from);
  void MergeFrom(const StorageTypeQuotaInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StorageTypeQuotaInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.StorageTypeProto type = 1;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::hadoop::hdfs::StorageTypeProto type() const;
  void set_type(::hadoop::hdfs::StorageTypeProto value);

  // required uint64 quota = 2;
  bool has_quota() const;
  void clear_quota();
  static const int kQuotaFieldNumber = 2;
  ::google::protobuf::uint64 quota() const;
  void set_quota(::google::protobuf::uint64 value);

  // required uint64 consumed = 3;
  bool has_consumed() const;
  void clear_consumed();
  static const int kConsumedFieldNumber = 3;
  ::google::protobuf::uint64 consumed() const;
  void set_consumed(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.StorageTypeQuotaInfoProto)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_quota();
  inline void clear_has_quota();
  inline void set_has_consumed();
  inline void clear_has_consumed();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 quota_;
  ::google::protobuf::uint64 consumed_;
  int type_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static StorageTypeQuotaInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class CorruptFileBlocksProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.CorruptFileBlocksProto) */ {
 public:
  CorruptFileBlocksProto();
  virtual ~CorruptFileBlocksProto();

  CorruptFileBlocksProto(const CorruptFileBlocksProto& from);

  inline CorruptFileBlocksProto& operator=(const CorruptFileBlocksProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CorruptFileBlocksProto& default_instance();

  void Swap(CorruptFileBlocksProto* other);

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

  inline CorruptFileBlocksProto* New() const { return New(NULL); }

  CorruptFileBlocksProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CorruptFileBlocksProto& from);
  void MergeFrom(const CorruptFileBlocksProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CorruptFileBlocksProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated string files = 1;
  int files_size() const;
  void clear_files();
  static const int kFilesFieldNumber = 1;
  const ::std::string& files(int index) const;
  ::std::string* mutable_files(int index);
  void set_files(int index, const ::std::string& value);
  void set_files(int index, const char* value);
  void set_files(int index, const char* value, size_t size);
  ::std::string* add_files();
  void add_files(const ::std::string& value);
  void add_files(const char* value);
  void add_files(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& files() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_files();

  // required string cookie = 2;
  bool has_cookie() const;
  void clear_cookie();
  static const int kCookieFieldNumber = 2;
  const ::std::string& cookie() const;
  void set_cookie(const ::std::string& value);
  void set_cookie(const char* value);
  void set_cookie(const char* value, size_t size);
  ::std::string* mutable_cookie();
  ::std::string* release_cookie();
  void set_allocated_cookie(::std::string* cookie);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.CorruptFileBlocksProto)
 private:
  inline void set_has_cookie();
  inline void clear_has_cookie();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> files_;
  ::google::protobuf::internal::ArenaStringPtr cookie_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static CorruptFileBlocksProto* default_instance_;
};
// -------------------------------------------------------------------

class FsPermissionProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.FsPermissionProto) */ {
 public:
  FsPermissionProto();
  virtual ~FsPermissionProto();

  FsPermissionProto(const FsPermissionProto& from);

  inline FsPermissionProto& operator=(const FsPermissionProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FsPermissionProto& default_instance();

  void Swap(FsPermissionProto* other);

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

  inline FsPermissionProto* New() const { return New(NULL); }

  FsPermissionProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FsPermissionProto& from);
  void MergeFrom(const FsPermissionProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FsPermissionProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint32 perm = 1;
  bool has_perm() const;
  void clear_perm();
  static const int kPermFieldNumber = 1;
  ::google::protobuf::uint32 perm() const;
  void set_perm(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.FsPermissionProto)
 private:
  inline void set_has_perm();
  inline void clear_has_perm();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 perm_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static FsPermissionProto* default_instance_;
};
// -------------------------------------------------------------------

class StorageTypesProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.StorageTypesProto) */ {
 public:
  StorageTypesProto();
  virtual ~StorageTypesProto();

  StorageTypesProto(const StorageTypesProto& from);

  inline StorageTypesProto& operator=(const StorageTypesProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StorageTypesProto& default_instance();

  void Swap(StorageTypesProto* other);

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

  inline StorageTypesProto* New() const { return New(NULL); }

  StorageTypesProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StorageTypesProto& from);
  void MergeFrom(const StorageTypesProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StorageTypesProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .hadoop.hdfs.StorageTypeProto storageTypes = 1;
  int storagetypes_size() const;
  void clear_storagetypes();
  static const int kStorageTypesFieldNumber = 1;
  ::hadoop::hdfs::StorageTypeProto storagetypes(int index) const;
  void set_storagetypes(int index, ::hadoop::hdfs::StorageTypeProto value);
  void add_storagetypes(::hadoop::hdfs::StorageTypeProto value);
  const ::google::protobuf::RepeatedField<int>& storagetypes() const;
  ::google::protobuf::RepeatedField<int>* mutable_storagetypes();

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.StorageTypesProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedField<int> storagetypes_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static StorageTypesProto* default_instance_;
};
// -------------------------------------------------------------------

class BlockStoragePolicyProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.BlockStoragePolicyProto) */ {
 public:
  BlockStoragePolicyProto();
  virtual ~BlockStoragePolicyProto();

  BlockStoragePolicyProto(const BlockStoragePolicyProto& from);

  inline BlockStoragePolicyProto& operator=(const BlockStoragePolicyProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlockStoragePolicyProto& default_instance();

  void Swap(BlockStoragePolicyProto* other);

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

  inline BlockStoragePolicyProto* New() const { return New(NULL); }

  BlockStoragePolicyProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlockStoragePolicyProto& from);
  void MergeFrom(const BlockStoragePolicyProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BlockStoragePolicyProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint32 policyId = 1;
  bool has_policyid() const;
  void clear_policyid();
  static const int kPolicyIdFieldNumber = 1;
  ::google::protobuf::uint32 policyid() const;
  void set_policyid(::google::protobuf::uint32 value);

  // required string name = 2;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 2;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // required .hadoop.hdfs.StorageTypesProto creationPolicy = 3;
  bool has_creationpolicy() const;
  void clear_creationpolicy();
  static const int kCreationPolicyFieldNumber = 3;
  const ::hadoop::hdfs::StorageTypesProto& creationpolicy() const;
  ::hadoop::hdfs::StorageTypesProto* mutable_creationpolicy();
  ::hadoop::hdfs::StorageTypesProto* release_creationpolicy();
  void set_allocated_creationpolicy(::hadoop::hdfs::StorageTypesProto* creationpolicy);

  // optional .hadoop.hdfs.StorageTypesProto creationFallbackPolicy = 4;
  bool has_creationfallbackpolicy() const;
  void clear_creationfallbackpolicy();
  static const int kCreationFallbackPolicyFieldNumber = 4;
  const ::hadoop::hdfs::StorageTypesProto& creationfallbackpolicy() const;
  ::hadoop::hdfs::StorageTypesProto* mutable_creationfallbackpolicy();
  ::hadoop::hdfs::StorageTypesProto* release_creationfallbackpolicy();
  void set_allocated_creationfallbackpolicy(::hadoop::hdfs::StorageTypesProto* creationfallbackpolicy);

  // optional .hadoop.hdfs.StorageTypesProto replicationFallbackPolicy = 5;
  bool has_replicationfallbackpolicy() const;
  void clear_replicationfallbackpolicy();
  static const int kReplicationFallbackPolicyFieldNumber = 5;
  const ::hadoop::hdfs::StorageTypesProto& replicationfallbackpolicy() const;
  ::hadoop::hdfs::StorageTypesProto* mutable_replicationfallbackpolicy();
  ::hadoop::hdfs::StorageTypesProto* release_replicationfallbackpolicy();
  void set_allocated_replicationfallbackpolicy(::hadoop::hdfs::StorageTypesProto* replicationfallbackpolicy);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.BlockStoragePolicyProto)
 private:
  inline void set_has_policyid();
  inline void clear_has_policyid();
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_creationpolicy();
  inline void clear_has_creationpolicy();
  inline void set_has_creationfallbackpolicy();
  inline void clear_has_creationfallbackpolicy();
  inline void set_has_replicationfallbackpolicy();
  inline void clear_has_replicationfallbackpolicy();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::hadoop::hdfs::StorageTypesProto* creationpolicy_;
  ::hadoop::hdfs::StorageTypesProto* creationfallbackpolicy_;
  ::hadoop::hdfs::StorageTypesProto* replicationfallbackpolicy_;
  ::google::protobuf::uint32 policyid_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static BlockStoragePolicyProto* default_instance_;
};
// -------------------------------------------------------------------

class StorageUuidsProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.StorageUuidsProto) */ {
 public:
  StorageUuidsProto();
  virtual ~StorageUuidsProto();

  StorageUuidsProto(const StorageUuidsProto& from);

  inline StorageUuidsProto& operator=(const StorageUuidsProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StorageUuidsProto& default_instance();

  void Swap(StorageUuidsProto* other);

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

  inline StorageUuidsProto* New() const { return New(NULL); }

  StorageUuidsProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StorageUuidsProto& from);
  void MergeFrom(const StorageUuidsProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StorageUuidsProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated string storageUuids = 1;
  int storageuuids_size() const;
  void clear_storageuuids();
  static const int kStorageUuidsFieldNumber = 1;
  const ::std::string& storageuuids(int index) const;
  ::std::string* mutable_storageuuids(int index);
  void set_storageuuids(int index, const ::std::string& value);
  void set_storageuuids(int index, const char* value);
  void set_storageuuids(int index, const char* value, size_t size);
  ::std::string* add_storageuuids();
  void add_storageuuids(const ::std::string& value);
  void add_storageuuids(const char* value);
  void add_storageuuids(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& storageuuids() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_storageuuids();

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.StorageUuidsProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> storageuuids_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static StorageUuidsProto* default_instance_;
};
// -------------------------------------------------------------------

class LocatedBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.LocatedBlockProto) */ {
 public:
  LocatedBlockProto();
  virtual ~LocatedBlockProto();

  LocatedBlockProto(const LocatedBlockProto& from);

  inline LocatedBlockProto& operator=(const LocatedBlockProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LocatedBlockProto& default_instance();

  void Swap(LocatedBlockProto* other);

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

  inline LocatedBlockProto* New() const { return New(NULL); }

  LocatedBlockProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LocatedBlockProto& from);
  void MergeFrom(const LocatedBlockProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LocatedBlockProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.ExtendedBlockProto b = 1;
  bool has_b() const;
  void clear_b();
  static const int kBFieldNumber = 1;
  const ::hadoop::hdfs::ExtendedBlockProto& b() const;
  ::hadoop::hdfs::ExtendedBlockProto* mutable_b();
  ::hadoop::hdfs::ExtendedBlockProto* release_b();
  void set_allocated_b(::hadoop::hdfs::ExtendedBlockProto* b);

  // required uint64 offset = 2;
  bool has_offset() const;
  void clear_offset();
  static const int kOffsetFieldNumber = 2;
  ::google::protobuf::uint64 offset() const;
  void set_offset(::google::protobuf::uint64 value);

  // repeated .hadoop.hdfs.DatanodeInfoProto locs = 3;
  int locs_size() const;
  void clear_locs();
  static const int kLocsFieldNumber = 3;
  const ::hadoop::hdfs::DatanodeInfoProto& locs(int index) const;
  ::hadoop::hdfs::DatanodeInfoProto* mutable_locs(int index);
  ::hadoop::hdfs::DatanodeInfoProto* add_locs();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto >*
      mutable_locs();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto >&
      locs() const;

  // required bool corrupt = 4;
  bool has_corrupt() const;
  void clear_corrupt();
  static const int kCorruptFieldNumber = 4;
  bool corrupt() const;
  void set_corrupt(bool value);

  // required .hadoop.common.TokenProto blockToken = 5;
  bool has_blocktoken() const;
  void clear_blocktoken();
  static const int kBlockTokenFieldNumber = 5;
  const ::hadoop::common::TokenProto& blocktoken() const;
  ::hadoop::common::TokenProto* mutable_blocktoken();
  ::hadoop::common::TokenProto* release_blocktoken();
  void set_allocated_blocktoken(::hadoop::common::TokenProto* blocktoken);

  // repeated bool isCached = 6 [packed = true];
  int iscached_size() const;
  void clear_iscached();
  static const int kIsCachedFieldNumber = 6;
  bool iscached(int index) const;
  void set_iscached(int index, bool value);
  void add_iscached(bool value);
  const ::google::protobuf::RepeatedField< bool >&
      iscached() const;
  ::google::protobuf::RepeatedField< bool >*
      mutable_iscached();

  // repeated .hadoop.hdfs.StorageTypeProto storageTypes = 7;
  int storagetypes_size() const;
  void clear_storagetypes();
  static const int kStorageTypesFieldNumber = 7;
  ::hadoop::hdfs::StorageTypeProto storagetypes(int index) const;
  void set_storagetypes(int index, ::hadoop::hdfs::StorageTypeProto value);
  void add_storagetypes(::hadoop::hdfs::StorageTypeProto value);
  const ::google::protobuf::RepeatedField<int>& storagetypes() const;
  ::google::protobuf::RepeatedField<int>* mutable_storagetypes();

  // repeated string storageIDs = 8;
  int storageids_size() const;
  void clear_storageids();
  static const int kStorageIDsFieldNumber = 8;
  const ::std::string& storageids(int index) const;
  ::std::string* mutable_storageids(int index);
  void set_storageids(int index, const ::std::string& value);
  void set_storageids(int index, const char* value);
  void set_storageids(int index, const char* value, size_t size);
  ::std::string* add_storageids();
  void add_storageids(const ::std::string& value);
  void add_storageids(const char* value);
  void add_storageids(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& storageids() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_storageids();

  // optional bytes blockIndices = 9;
  bool has_blockindices() const;
  void clear_blockindices();
  static const int kBlockIndicesFieldNumber = 9;
  const ::std::string& blockindices() const;
  void set_blockindices(const ::std::string& value);
  void set_blockindices(const char* value);
  void set_blockindices(const void* value, size_t size);
  ::std::string* mutable_blockindices();
  ::std::string* release_blockindices();
  void set_allocated_blockindices(::std::string* blockindices);

  // repeated .hadoop.common.TokenProto blockTokens = 10;
  int blocktokens_size() const;
  void clear_blocktokens();
  static const int kBlockTokensFieldNumber = 10;
  const ::hadoop::common::TokenProto& blocktokens(int index) const;
  ::hadoop::common::TokenProto* mutable_blocktokens(int index);
  ::hadoop::common::TokenProto* add_blocktokens();
  ::google::protobuf::RepeatedPtrField< ::hadoop::common::TokenProto >*
      mutable_blocktokens();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::common::TokenProto >&
      blocktokens() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.LocatedBlockProto)
 private:
  inline void set_has_b();
  inline void clear_has_b();
  inline void set_has_offset();
  inline void clear_has_offset();
  inline void set_has_corrupt();
  inline void clear_has_corrupt();
  inline void set_has_blocktoken();
  inline void clear_has_blocktoken();
  inline void set_has_blockindices();
  inline void clear_has_blockindices();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::hadoop::hdfs::ExtendedBlockProto* b_;
  ::google::protobuf::uint64 offset_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto > locs_;
  ::hadoop::common::TokenProto* blocktoken_;
  ::google::protobuf::RepeatedField< bool > iscached_;
  mutable int _iscached_cached_byte_size_;
  ::google::protobuf::RepeatedField<int> storagetypes_;
  ::google::protobuf::RepeatedPtrField< ::std::string> storageids_;
  ::google::protobuf::internal::ArenaStringPtr blockindices_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::common::TokenProto > blocktokens_;
  bool corrupt_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static LocatedBlockProto* default_instance_;
};
// -------------------------------------------------------------------

class DataEncryptionKeyProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.DataEncryptionKeyProto) */ {
 public:
  DataEncryptionKeyProto();
  virtual ~DataEncryptionKeyProto();

  DataEncryptionKeyProto(const DataEncryptionKeyProto& from);

  inline DataEncryptionKeyProto& operator=(const DataEncryptionKeyProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DataEncryptionKeyProto& default_instance();

  void Swap(DataEncryptionKeyProto* other);

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

  inline DataEncryptionKeyProto* New() const { return New(NULL); }

  DataEncryptionKeyProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DataEncryptionKeyProto& from);
  void MergeFrom(const DataEncryptionKeyProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DataEncryptionKeyProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint32 keyId = 1;
  bool has_keyid() const;
  void clear_keyid();
  static const int kKeyIdFieldNumber = 1;
  ::google::protobuf::uint32 keyid() const;
  void set_keyid(::google::protobuf::uint32 value);

  // required string blockPoolId = 2;
  bool has_blockpoolid() const;
  void clear_blockpoolid();
  static const int kBlockPoolIdFieldNumber = 2;
  const ::std::string& blockpoolid() const;
  void set_blockpoolid(const ::std::string& value);
  void set_blockpoolid(const char* value);
  void set_blockpoolid(const char* value, size_t size);
  ::std::string* mutable_blockpoolid();
  ::std::string* release_blockpoolid();
  void set_allocated_blockpoolid(::std::string* blockpoolid);

  // required bytes nonce = 3;
  bool has_nonce() const;
  void clear_nonce();
  static const int kNonceFieldNumber = 3;
  const ::std::string& nonce() const;
  void set_nonce(const ::std::string& value);
  void set_nonce(const char* value);
  void set_nonce(const void* value, size_t size);
  ::std::string* mutable_nonce();
  ::std::string* release_nonce();
  void set_allocated_nonce(::std::string* nonce);

  // required bytes encryptionKey = 4;
  bool has_encryptionkey() const;
  void clear_encryptionkey();
  static const int kEncryptionKeyFieldNumber = 4;
  const ::std::string& encryptionkey() const;
  void set_encryptionkey(const ::std::string& value);
  void set_encryptionkey(const char* value);
  void set_encryptionkey(const void* value, size_t size);
  ::std::string* mutable_encryptionkey();
  ::std::string* release_encryptionkey();
  void set_allocated_encryptionkey(::std::string* encryptionkey);

  // required uint64 expiryDate = 5;
  bool has_expirydate() const;
  void clear_expirydate();
  static const int kExpiryDateFieldNumber = 5;
  ::google::protobuf::uint64 expirydate() const;
  void set_expirydate(::google::protobuf::uint64 value);

  // optional string encryptionAlgorithm = 6;
  bool has_encryptionalgorithm() const;
  void clear_encryptionalgorithm();
  static const int kEncryptionAlgorithmFieldNumber = 6;
  const ::std::string& encryptionalgorithm() const;
  void set_encryptionalgorithm(const ::std::string& value);
  void set_encryptionalgorithm(const char* value);
  void set_encryptionalgorithm(const char* value, size_t size);
  ::std::string* mutable_encryptionalgorithm();
  ::std::string* release_encryptionalgorithm();
  void set_allocated_encryptionalgorithm(::std::string* encryptionalgorithm);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.DataEncryptionKeyProto)
 private:
  inline void set_has_keyid();
  inline void clear_has_keyid();
  inline void set_has_blockpoolid();
  inline void clear_has_blockpoolid();
  inline void set_has_nonce();
  inline void clear_has_nonce();
  inline void set_has_encryptionkey();
  inline void clear_has_encryptionkey();
  inline void set_has_expirydate();
  inline void clear_has_expirydate();
  inline void set_has_encryptionalgorithm();
  inline void clear_has_encryptionalgorithm();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr blockpoolid_;
  ::google::protobuf::internal::ArenaStringPtr nonce_;
  ::google::protobuf::internal::ArenaStringPtr encryptionkey_;
  ::google::protobuf::uint64 expirydate_;
  ::google::protobuf::internal::ArenaStringPtr encryptionalgorithm_;
  ::google::protobuf::uint32 keyid_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static DataEncryptionKeyProto* default_instance_;
};
// -------------------------------------------------------------------

class FileEncryptionInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.FileEncryptionInfoProto) */ {
 public:
  FileEncryptionInfoProto();
  virtual ~FileEncryptionInfoProto();

  FileEncryptionInfoProto(const FileEncryptionInfoProto& from);

  inline FileEncryptionInfoProto& operator=(const FileEncryptionInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FileEncryptionInfoProto& default_instance();

  void Swap(FileEncryptionInfoProto* other);

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

  inline FileEncryptionInfoProto* New() const { return New(NULL); }

  FileEncryptionInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FileEncryptionInfoProto& from);
  void MergeFrom(const FileEncryptionInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FileEncryptionInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.CipherSuiteProto suite = 1;
  bool has_suite() const;
  void clear_suite();
  static const int kSuiteFieldNumber = 1;
  ::hadoop::hdfs::CipherSuiteProto suite() const;
  void set_suite(::hadoop::hdfs::CipherSuiteProto value);

  // required .hadoop.hdfs.CryptoProtocolVersionProto cryptoProtocolVersion = 2;
  bool has_cryptoprotocolversion() const;
  void clear_cryptoprotocolversion();
  static const int kCryptoProtocolVersionFieldNumber = 2;
  ::hadoop::hdfs::CryptoProtocolVersionProto cryptoprotocolversion() const;
  void set_cryptoprotocolversion(::hadoop::hdfs::CryptoProtocolVersionProto value);

  // required bytes key = 3;
  bool has_key() const;
  void clear_key();
  static const int kKeyFieldNumber = 3;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  void set_key(const char* value);
  void set_key(const void* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // required bytes iv = 4;
  bool has_iv() const;
  void clear_iv();
  static const int kIvFieldNumber = 4;
  const ::std::string& iv() const;
  void set_iv(const ::std::string& value);
  void set_iv(const char* value);
  void set_iv(const void* value, size_t size);
  ::std::string* mutable_iv();
  ::std::string* release_iv();
  void set_allocated_iv(::std::string* iv);

  // required string keyName = 5;
  bool has_keyname() const;
  void clear_keyname();
  static const int kKeyNameFieldNumber = 5;
  const ::std::string& keyname() const;
  void set_keyname(const ::std::string& value);
  void set_keyname(const char* value);
  void set_keyname(const char* value, size_t size);
  ::std::string* mutable_keyname();
  ::std::string* release_keyname();
  void set_allocated_keyname(::std::string* keyname);

  // required string ezKeyVersionName = 6;
  bool has_ezkeyversionname() const;
  void clear_ezkeyversionname();
  static const int kEzKeyVersionNameFieldNumber = 6;
  const ::std::string& ezkeyversionname() const;
  void set_ezkeyversionname(const ::std::string& value);
  void set_ezkeyversionname(const char* value);
  void set_ezkeyversionname(const char* value, size_t size);
  ::std::string* mutable_ezkeyversionname();
  ::std::string* release_ezkeyversionname();
  void set_allocated_ezkeyversionname(::std::string* ezkeyversionname);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.FileEncryptionInfoProto)
 private:
  inline void set_has_suite();
  inline void clear_has_suite();
  inline void set_has_cryptoprotocolversion();
  inline void clear_has_cryptoprotocolversion();
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_iv();
  inline void clear_has_iv();
  inline void set_has_keyname();
  inline void clear_has_keyname();
  inline void set_has_ezkeyversionname();
  inline void clear_has_ezkeyversionname();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  int suite_;
  int cryptoprotocolversion_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr iv_;
  ::google::protobuf::internal::ArenaStringPtr keyname_;
  ::google::protobuf::internal::ArenaStringPtr ezkeyversionname_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static FileEncryptionInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class PerFileEncryptionInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.PerFileEncryptionInfoProto) */ {
 public:
  PerFileEncryptionInfoProto();
  virtual ~PerFileEncryptionInfoProto();

  PerFileEncryptionInfoProto(const PerFileEncryptionInfoProto& from);

  inline PerFileEncryptionInfoProto& operator=(const PerFileEncryptionInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PerFileEncryptionInfoProto& default_instance();

  void Swap(PerFileEncryptionInfoProto* other);

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

  inline PerFileEncryptionInfoProto* New() const { return New(NULL); }

  PerFileEncryptionInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PerFileEncryptionInfoProto& from);
  void MergeFrom(const PerFileEncryptionInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PerFileEncryptionInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required bytes key = 1;
  bool has_key() const;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  void set_key(const char* value);
  void set_key(const void* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // required bytes iv = 2;
  bool has_iv() const;
  void clear_iv();
  static const int kIvFieldNumber = 2;
  const ::std::string& iv() const;
  void set_iv(const ::std::string& value);
  void set_iv(const char* value);
  void set_iv(const void* value, size_t size);
  ::std::string* mutable_iv();
  ::std::string* release_iv();
  void set_allocated_iv(::std::string* iv);

  // required string ezKeyVersionName = 3;
  bool has_ezkeyversionname() const;
  void clear_ezkeyversionname();
  static const int kEzKeyVersionNameFieldNumber = 3;
  const ::std::string& ezkeyversionname() const;
  void set_ezkeyversionname(const ::std::string& value);
  void set_ezkeyversionname(const char* value);
  void set_ezkeyversionname(const char* value, size_t size);
  ::std::string* mutable_ezkeyversionname();
  ::std::string* release_ezkeyversionname();
  void set_allocated_ezkeyversionname(::std::string* ezkeyversionname);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.PerFileEncryptionInfoProto)
 private:
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_iv();
  inline void clear_has_iv();
  inline void set_has_ezkeyversionname();
  inline void clear_has_ezkeyversionname();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr iv_;
  ::google::protobuf::internal::ArenaStringPtr ezkeyversionname_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static PerFileEncryptionInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class ZoneEncryptionInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ZoneEncryptionInfoProto) */ {
 public:
  ZoneEncryptionInfoProto();
  virtual ~ZoneEncryptionInfoProto();

  ZoneEncryptionInfoProto(const ZoneEncryptionInfoProto& from);

  inline ZoneEncryptionInfoProto& operator=(const ZoneEncryptionInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ZoneEncryptionInfoProto& default_instance();

  void Swap(ZoneEncryptionInfoProto* other);

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

  inline ZoneEncryptionInfoProto* New() const { return New(NULL); }

  ZoneEncryptionInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ZoneEncryptionInfoProto& from);
  void MergeFrom(const ZoneEncryptionInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ZoneEncryptionInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.CipherSuiteProto suite = 1;
  bool has_suite() const;
  void clear_suite();
  static const int kSuiteFieldNumber = 1;
  ::hadoop::hdfs::CipherSuiteProto suite() const;
  void set_suite(::hadoop::hdfs::CipherSuiteProto value);

  // required .hadoop.hdfs.CryptoProtocolVersionProto cryptoProtocolVersion = 2;
  bool has_cryptoprotocolversion() const;
  void clear_cryptoprotocolversion();
  static const int kCryptoProtocolVersionFieldNumber = 2;
  ::hadoop::hdfs::CryptoProtocolVersionProto cryptoprotocolversion() const;
  void set_cryptoprotocolversion(::hadoop::hdfs::CryptoProtocolVersionProto value);

  // required string keyName = 3;
  bool has_keyname() const;
  void clear_keyname();
  static const int kKeyNameFieldNumber = 3;
  const ::std::string& keyname() const;
  void set_keyname(const ::std::string& value);
  void set_keyname(const char* value);
  void set_keyname(const char* value, size_t size);
  ::std::string* mutable_keyname();
  ::std::string* release_keyname();
  void set_allocated_keyname(::std::string* keyname);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ZoneEncryptionInfoProto)
 private:
  inline void set_has_suite();
  inline void clear_has_suite();
  inline void set_has_cryptoprotocolversion();
  inline void clear_has_cryptoprotocolversion();
  inline void set_has_keyname();
  inline void clear_has_keyname();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  int suite_;
  int cryptoprotocolversion_;
  ::google::protobuf::internal::ArenaStringPtr keyname_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static ZoneEncryptionInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class CipherOptionProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.CipherOptionProto) */ {
 public:
  CipherOptionProto();
  virtual ~CipherOptionProto();

  CipherOptionProto(const CipherOptionProto& from);

  inline CipherOptionProto& operator=(const CipherOptionProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CipherOptionProto& default_instance();

  void Swap(CipherOptionProto* other);

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

  inline CipherOptionProto* New() const { return New(NULL); }

  CipherOptionProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CipherOptionProto& from);
  void MergeFrom(const CipherOptionProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CipherOptionProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.CipherSuiteProto suite = 1;
  bool has_suite() const;
  void clear_suite();
  static const int kSuiteFieldNumber = 1;
  ::hadoop::hdfs::CipherSuiteProto suite() const;
  void set_suite(::hadoop::hdfs::CipherSuiteProto value);

  // optional bytes inKey = 2;
  bool has_inkey() const;
  void clear_inkey();
  static const int kInKeyFieldNumber = 2;
  const ::std::string& inkey() const;
  void set_inkey(const ::std::string& value);
  void set_inkey(const char* value);
  void set_inkey(const void* value, size_t size);
  ::std::string* mutable_inkey();
  ::std::string* release_inkey();
  void set_allocated_inkey(::std::string* inkey);

  // optional bytes inIv = 3;
  bool has_iniv() const;
  void clear_iniv();
  static const int kInIvFieldNumber = 3;
  const ::std::string& iniv() const;
  void set_iniv(const ::std::string& value);
  void set_iniv(const char* value);
  void set_iniv(const void* value, size_t size);
  ::std::string* mutable_iniv();
  ::std::string* release_iniv();
  void set_allocated_iniv(::std::string* iniv);

  // optional bytes outKey = 4;
  bool has_outkey() const;
  void clear_outkey();
  static const int kOutKeyFieldNumber = 4;
  const ::std::string& outkey() const;
  void set_outkey(const ::std::string& value);
  void set_outkey(const char* value);
  void set_outkey(const void* value, size_t size);
  ::std::string* mutable_outkey();
  ::std::string* release_outkey();
  void set_allocated_outkey(::std::string* outkey);

  // optional bytes outIv = 5;
  bool has_outiv() const;
  void clear_outiv();
  static const int kOutIvFieldNumber = 5;
  const ::std::string& outiv() const;
  void set_outiv(const ::std::string& value);
  void set_outiv(const char* value);
  void set_outiv(const void* value, size_t size);
  ::std::string* mutable_outiv();
  ::std::string* release_outiv();
  void set_allocated_outiv(::std::string* outiv);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.CipherOptionProto)
 private:
  inline void set_has_suite();
  inline void clear_has_suite();
  inline void set_has_inkey();
  inline void clear_has_inkey();
  inline void set_has_iniv();
  inline void clear_has_iniv();
  inline void set_has_outkey();
  inline void clear_has_outkey();
  inline void set_has_outiv();
  inline void clear_has_outiv();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr inkey_;
  ::google::protobuf::internal::ArenaStringPtr iniv_;
  ::google::protobuf::internal::ArenaStringPtr outkey_;
  ::google::protobuf::internal::ArenaStringPtr outiv_;
  int suite_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static CipherOptionProto* default_instance_;
};
// -------------------------------------------------------------------

class LocatedBlocksProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.LocatedBlocksProto) */ {
 public:
  LocatedBlocksProto();
  virtual ~LocatedBlocksProto();

  LocatedBlocksProto(const LocatedBlocksProto& from);

  inline LocatedBlocksProto& operator=(const LocatedBlocksProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LocatedBlocksProto& default_instance();

  void Swap(LocatedBlocksProto* other);

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

  inline LocatedBlocksProto* New() const { return New(NULL); }

  LocatedBlocksProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LocatedBlocksProto& from);
  void MergeFrom(const LocatedBlocksProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LocatedBlocksProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint64 fileLength = 1;
  bool has_filelength() const;
  void clear_filelength();
  static const int kFileLengthFieldNumber = 1;
  ::google::protobuf::uint64 filelength() const;
  void set_filelength(::google::protobuf::uint64 value);

  // repeated .hadoop.hdfs.LocatedBlockProto blocks = 2;
  int blocks_size() const;
  void clear_blocks();
  static const int kBlocksFieldNumber = 2;
  const ::hadoop::hdfs::LocatedBlockProto& blocks(int index) const;
  ::hadoop::hdfs::LocatedBlockProto* mutable_blocks(int index);
  ::hadoop::hdfs::LocatedBlockProto* add_blocks();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::LocatedBlockProto >*
      mutable_blocks();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::LocatedBlockProto >&
      blocks() const;

  // required bool underConstruction = 3;
  bool has_underconstruction() const;
  void clear_underconstruction();
  static const int kUnderConstructionFieldNumber = 3;
  bool underconstruction() const;
  void set_underconstruction(bool value);

  // optional .hadoop.hdfs.LocatedBlockProto lastBlock = 4;
  bool has_lastblock() const;
  void clear_lastblock();
  static const int kLastBlockFieldNumber = 4;
  const ::hadoop::hdfs::LocatedBlockProto& lastblock() const;
  ::hadoop::hdfs::LocatedBlockProto* mutable_lastblock();
  ::hadoop::hdfs::LocatedBlockProto* release_lastblock();
  void set_allocated_lastblock(::hadoop::hdfs::LocatedBlockProto* lastblock);

  // required bool isLastBlockComplete = 5;
  bool has_islastblockcomplete() const;
  void clear_islastblockcomplete();
  static const int kIsLastBlockCompleteFieldNumber = 5;
  bool islastblockcomplete() const;
  void set_islastblockcomplete(bool value);

  // optional .hadoop.hdfs.FileEncryptionInfoProto fileEncryptionInfo = 6;
  bool has_fileencryptioninfo() const;
  void clear_fileencryptioninfo();
  static const int kFileEncryptionInfoFieldNumber = 6;
  const ::hadoop::hdfs::FileEncryptionInfoProto& fileencryptioninfo() const;
  ::hadoop::hdfs::FileEncryptionInfoProto* mutable_fileencryptioninfo();
  ::hadoop::hdfs::FileEncryptionInfoProto* release_fileencryptioninfo();
  void set_allocated_fileencryptioninfo(::hadoop::hdfs::FileEncryptionInfoProto* fileencryptioninfo);

  // optional .hadoop.hdfs.ErasureCodingPolicyProto ecPolicy = 7;
  bool has_ecpolicy() const;
  void clear_ecpolicy();
  static const int kEcPolicyFieldNumber = 7;
  const ::hadoop::hdfs::ErasureCodingPolicyProto& ecpolicy() const;
  ::hadoop::hdfs::ErasureCodingPolicyProto* mutable_ecpolicy();
  ::hadoop::hdfs::ErasureCodingPolicyProto* release_ecpolicy();
  void set_allocated_ecpolicy(::hadoop::hdfs::ErasureCodingPolicyProto* ecpolicy);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.LocatedBlocksProto)
 private:
  inline void set_has_filelength();
  inline void clear_has_filelength();
  inline void set_has_underconstruction();
  inline void clear_has_underconstruction();
  inline void set_has_lastblock();
  inline void clear_has_lastblock();
  inline void set_has_islastblockcomplete();
  inline void clear_has_islastblockcomplete();
  inline void set_has_fileencryptioninfo();
  inline void clear_has_fileencryptioninfo();
  inline void set_has_ecpolicy();
  inline void clear_has_ecpolicy();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 filelength_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::LocatedBlockProto > blocks_;
  ::hadoop::hdfs::LocatedBlockProto* lastblock_;
  ::hadoop::hdfs::FileEncryptionInfoProto* fileencryptioninfo_;
  ::hadoop::hdfs::ErasureCodingPolicyProto* ecpolicy_;
  bool underconstruction_;
  bool islastblockcomplete_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static LocatedBlocksProto* default_instance_;
};
// -------------------------------------------------------------------

class ECSchemaOptionEntryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ECSchemaOptionEntryProto) */ {
 public:
  ECSchemaOptionEntryProto();
  virtual ~ECSchemaOptionEntryProto();

  ECSchemaOptionEntryProto(const ECSchemaOptionEntryProto& from);

  inline ECSchemaOptionEntryProto& operator=(const ECSchemaOptionEntryProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ECSchemaOptionEntryProto& default_instance();

  void Swap(ECSchemaOptionEntryProto* other);

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

  inline ECSchemaOptionEntryProto* New() const { return New(NULL); }

  ECSchemaOptionEntryProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ECSchemaOptionEntryProto& from);
  void MergeFrom(const ECSchemaOptionEntryProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ECSchemaOptionEntryProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string key = 1;
  bool has_key() const;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // required string value = 2;
  bool has_value() const;
  void clear_value();
  static const int kValueFieldNumber = 2;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ECSchemaOptionEntryProto)
 private:
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_value();
  inline void clear_has_value();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static ECSchemaOptionEntryProto* default_instance_;
};
// -------------------------------------------------------------------

class ECSchemaProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ECSchemaProto) */ {
 public:
  ECSchemaProto();
  virtual ~ECSchemaProto();

  ECSchemaProto(const ECSchemaProto& from);

  inline ECSchemaProto& operator=(const ECSchemaProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ECSchemaProto& default_instance();

  void Swap(ECSchemaProto* other);

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

  inline ECSchemaProto* New() const { return New(NULL); }

  ECSchemaProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ECSchemaProto& from);
  void MergeFrom(const ECSchemaProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ECSchemaProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string codecName = 1;
  bool has_codecname() const;
  void clear_codecname();
  static const int kCodecNameFieldNumber = 1;
  const ::std::string& codecname() const;
  void set_codecname(const ::std::string& value);
  void set_codecname(const char* value);
  void set_codecname(const char* value, size_t size);
  ::std::string* mutable_codecname();
  ::std::string* release_codecname();
  void set_allocated_codecname(::std::string* codecname);

  // required uint32 dataUnits = 2;
  bool has_dataunits() const;
  void clear_dataunits();
  static const int kDataUnitsFieldNumber = 2;
  ::google::protobuf::uint32 dataunits() const;
  void set_dataunits(::google::protobuf::uint32 value);

  // required uint32 parityUnits = 3;
  bool has_parityunits() const;
  void clear_parityunits();
  static const int kParityUnitsFieldNumber = 3;
  ::google::protobuf::uint32 parityunits() const;
  void set_parityunits(::google::protobuf::uint32 value);

  // repeated .hadoop.hdfs.ECSchemaOptionEntryProto options = 4;
  int options_size() const;
  void clear_options();
  static const int kOptionsFieldNumber = 4;
  const ::hadoop::hdfs::ECSchemaOptionEntryProto& options(int index) const;
  ::hadoop::hdfs::ECSchemaOptionEntryProto* mutable_options(int index);
  ::hadoop::hdfs::ECSchemaOptionEntryProto* add_options();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::ECSchemaOptionEntryProto >*
      mutable_options();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::ECSchemaOptionEntryProto >&
      options() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ECSchemaProto)
 private:
  inline void set_has_codecname();
  inline void clear_has_codecname();
  inline void set_has_dataunits();
  inline void clear_has_dataunits();
  inline void set_has_parityunits();
  inline void clear_has_parityunits();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr codecname_;
  ::google::protobuf::uint32 dataunits_;
  ::google::protobuf::uint32 parityunits_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::ECSchemaOptionEntryProto > options_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static ECSchemaProto* default_instance_;
};
// -------------------------------------------------------------------

class ErasureCodingPolicyProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ErasureCodingPolicyProto) */ {
 public:
  ErasureCodingPolicyProto();
  virtual ~ErasureCodingPolicyProto();

  ErasureCodingPolicyProto(const ErasureCodingPolicyProto& from);

  inline ErasureCodingPolicyProto& operator=(const ErasureCodingPolicyProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ErasureCodingPolicyProto& default_instance();

  void Swap(ErasureCodingPolicyProto* other);

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

  inline ErasureCodingPolicyProto* New() const { return New(NULL); }

  ErasureCodingPolicyProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ErasureCodingPolicyProto& from);
  void MergeFrom(const ErasureCodingPolicyProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ErasureCodingPolicyProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string name = 1;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // optional .hadoop.hdfs.ECSchemaProto schema = 2;
  bool has_schema() const;
  void clear_schema();
  static const int kSchemaFieldNumber = 2;
  const ::hadoop::hdfs::ECSchemaProto& schema() const;
  ::hadoop::hdfs::ECSchemaProto* mutable_schema();
  ::hadoop::hdfs::ECSchemaProto* release_schema();
  void set_allocated_schema(::hadoop::hdfs::ECSchemaProto* schema);

  // optional uint32 cellSize = 3;
  bool has_cellsize() const;
  void clear_cellsize();
  static const int kCellSizeFieldNumber = 3;
  ::google::protobuf::uint32 cellsize() const;
  void set_cellsize(::google::protobuf::uint32 value);

  // required uint32 id = 4;
  bool has_id() const;
  void clear_id();
  static const int kIdFieldNumber = 4;
  ::google::protobuf::uint32 id() const;
  void set_id(::google::protobuf::uint32 value);

  // optional .hadoop.hdfs.ErasureCodingPolicyState state = 5 [default = ENABLED];
  bool has_state() const;
  void clear_state();
  static const int kStateFieldNumber = 5;
  ::hadoop::hdfs::ErasureCodingPolicyState state() const;
  void set_state(::hadoop::hdfs::ErasureCodingPolicyState value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ErasureCodingPolicyProto)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_schema();
  inline void clear_has_schema();
  inline void set_has_cellsize();
  inline void clear_has_cellsize();
  inline void set_has_id();
  inline void clear_has_id();
  inline void set_has_state();
  inline void clear_has_state();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::hadoop::hdfs::ECSchemaProto* schema_;
  ::google::protobuf::uint32 cellsize_;
  ::google::protobuf::uint32 id_;
  int state_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static ErasureCodingPolicyProto* default_instance_;
};
// -------------------------------------------------------------------

class HdfsFileStatusProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.HdfsFileStatusProto) */ {
 public:
  HdfsFileStatusProto();
  virtual ~HdfsFileStatusProto();

  HdfsFileStatusProto(const HdfsFileStatusProto& from);

  inline HdfsFileStatusProto& operator=(const HdfsFileStatusProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const HdfsFileStatusProto& default_instance();

  void Swap(HdfsFileStatusProto* other);

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

  inline HdfsFileStatusProto* New() const { return New(NULL); }

  HdfsFileStatusProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const HdfsFileStatusProto& from);
  void MergeFrom(const HdfsFileStatusProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(HdfsFileStatusProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef HdfsFileStatusProto_FileType FileType;
  static const FileType IS_DIR =
    HdfsFileStatusProto_FileType_IS_DIR;
  static const FileType IS_FILE =
    HdfsFileStatusProto_FileType_IS_FILE;
  static const FileType IS_SYMLINK =
    HdfsFileStatusProto_FileType_IS_SYMLINK;
  static inline bool FileType_IsValid(int value) {
    return HdfsFileStatusProto_FileType_IsValid(value);
  }
  static const FileType FileType_MIN =
    HdfsFileStatusProto_FileType_FileType_MIN;
  static const FileType FileType_MAX =
    HdfsFileStatusProto_FileType_FileType_MAX;
  static const int FileType_ARRAYSIZE =
    HdfsFileStatusProto_FileType_FileType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  FileType_descriptor() {
    return HdfsFileStatusProto_FileType_descriptor();
  }
  static inline const ::std::string& FileType_Name(FileType value) {
    return HdfsFileStatusProto_FileType_Name(value);
  }
  static inline bool FileType_Parse(const ::std::string& name,
      FileType* value) {
    return HdfsFileStatusProto_FileType_Parse(name, value);
  }

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

  // required .hadoop.hdfs.HdfsFileStatusProto.FileType fileType = 1;
  bool has_filetype() const;
  void clear_filetype();
  static const int kFileTypeFieldNumber = 1;
  ::hadoop::hdfs::HdfsFileStatusProto_FileType filetype() const;
  void set_filetype(::hadoop::hdfs::HdfsFileStatusProto_FileType value);

  // required bytes path = 2;
  bool has_path() const;
  void clear_path();
  static const int kPathFieldNumber = 2;
  const ::std::string& path() const;
  void set_path(const ::std::string& value);
  void set_path(const char* value);
  void set_path(const void* value, size_t size);
  ::std::string* mutable_path();
  ::std::string* release_path();
  void set_allocated_path(::std::string* path);

  // required uint64 length = 3;
  bool has_length() const;
  void clear_length();
  static const int kLengthFieldNumber = 3;
  ::google::protobuf::uint64 length() const;
  void set_length(::google::protobuf::uint64 value);

  // required .hadoop.hdfs.FsPermissionProto permission = 4;
  bool has_permission() const;
  void clear_permission();
  static const int kPermissionFieldNumber = 4;
  const ::hadoop::hdfs::FsPermissionProto& permission() const;
  ::hadoop::hdfs::FsPermissionProto* mutable_permission();
  ::hadoop::hdfs::FsPermissionProto* release_permission();
  void set_allocated_permission(::hadoop::hdfs::FsPermissionProto* permission);

  // required string owner = 5;
  bool has_owner() const;
  void clear_owner();
  static const int kOwnerFieldNumber = 5;
  const ::std::string& owner() const;
  void set_owner(const ::std::string& value);
  void set_owner(const char* value);
  void set_owner(const char* value, size_t size);
  ::std::string* mutable_owner();
  ::std::string* release_owner();
  void set_allocated_owner(::std::string* owner);

  // required string group = 6;
  bool has_group() const;
  void clear_group();
  static const int kGroupFieldNumber = 6;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // required uint64 modification_time = 7;
  bool has_modification_time() const;
  void clear_modification_time();
  static const int kModificationTimeFieldNumber = 7;
  ::google::protobuf::uint64 modification_time() const;
  void set_modification_time(::google::protobuf::uint64 value);

  // required uint64 access_time = 8;
  bool has_access_time() const;
  void clear_access_time();
  static const int kAccessTimeFieldNumber = 8;
  ::google::protobuf::uint64 access_time() const;
  void set_access_time(::google::protobuf::uint64 value);

  // optional bytes symlink = 9;
  bool has_symlink() const;
  void clear_symlink();
  static const int kSymlinkFieldNumber = 9;
  const ::std::string& symlink() const;
  void set_symlink(const ::std::string& value);
  void set_symlink(const char* value);
  void set_symlink(const void* value, size_t size);
  ::std::string* mutable_symlink();
  ::std::string* release_symlink();
  void set_allocated_symlink(::std::string* symlink);

  // optional uint32 block_replication = 10 [default = 0];
  bool has_block_replication() const;
  void clear_block_replication();
  static const int kBlockReplicationFieldNumber = 10;
  ::google::protobuf::uint32 block_replication() const;
  void set_block_replication(::google::protobuf::uint32 value);

  // optional uint64 blocksize = 11 [default = 0];
  bool has_blocksize() const;
  void clear_blocksize();
  static const int kBlocksizeFieldNumber = 11;
  ::google::protobuf::uint64 blocksize() const;
  void set_blocksize(::google::protobuf::uint64 value);

  // optional .hadoop.hdfs.LocatedBlocksProto locations = 12;
  bool has_locations() const;
  void clear_locations();
  static const int kLocationsFieldNumber = 12;
  const ::hadoop::hdfs::LocatedBlocksProto& locations() const;
  ::hadoop::hdfs::LocatedBlocksProto* mutable_locations();
  ::hadoop::hdfs::LocatedBlocksProto* release_locations();
  void set_allocated_locations(::hadoop::hdfs::LocatedBlocksProto* locations);

  // optional uint64 fileId = 13 [default = 0];
  bool has_fileid() const;
  void clear_fileid();
  static const int kFileIdFieldNumber = 13;
  ::google::protobuf::uint64 fileid() const;
  void set_fileid(::google::protobuf::uint64 value);

  // optional int32 childrenNum = 14 [default = -1];
  bool has_childrennum() const;
  void clear_childrennum();
  static const int kChildrenNumFieldNumber = 14;
  ::google::protobuf::int32 childrennum() const;
  void set_childrennum(::google::protobuf::int32 value);

  // optional .hadoop.hdfs.FileEncryptionInfoProto fileEncryptionInfo = 15;
  bool has_fileencryptioninfo() const;
  void clear_fileencryptioninfo();
  static const int kFileEncryptionInfoFieldNumber = 15;
  const ::hadoop::hdfs::FileEncryptionInfoProto& fileencryptioninfo() const;
  ::hadoop::hdfs::FileEncryptionInfoProto* mutable_fileencryptioninfo();
  ::hadoop::hdfs::FileEncryptionInfoProto* release_fileencryptioninfo();
  void set_allocated_fileencryptioninfo(::hadoop::hdfs::FileEncryptionInfoProto* fileencryptioninfo);

  // optional uint32 storagePolicy = 16 [default = 0];
  bool has_storagepolicy() const;
  void clear_storagepolicy();
  static const int kStoragePolicyFieldNumber = 16;
  ::google::protobuf::uint32 storagepolicy() const;
  void set_storagepolicy(::google::protobuf::uint32 value);

  // optional .hadoop.hdfs.ErasureCodingPolicyProto ecPolicy = 17;
  bool has_ecpolicy() const;
  void clear_ecpolicy();
  static const int kEcPolicyFieldNumber = 17;
  const ::hadoop::hdfs::ErasureCodingPolicyProto& ecpolicy() const;
  ::hadoop::hdfs::ErasureCodingPolicyProto* mutable_ecpolicy();
  ::hadoop::hdfs::ErasureCodingPolicyProto* release_ecpolicy();
  void set_allocated_ecpolicy(::hadoop::hdfs::ErasureCodingPolicyProto* ecpolicy);

  // optional uint32 flags = 18 [default = 0];
  bool has_flags() const;
  void clear_flags();
  static const int kFlagsFieldNumber = 18;
  ::google::protobuf::uint32 flags() const;
  void set_flags(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.HdfsFileStatusProto)
 private:
  inline void set_has_filetype();
  inline void clear_has_filetype();
  inline void set_has_path();
  inline void clear_has_path();
  inline void set_has_length();
  inline void clear_has_length();
  inline void set_has_permission();
  inline void clear_has_permission();
  inline void set_has_owner();
  inline void clear_has_owner();
  inline void set_has_group();
  inline void clear_has_group();
  inline void set_has_modification_time();
  inline void clear_has_modification_time();
  inline void set_has_access_time();
  inline void clear_has_access_time();
  inline void set_has_symlink();
  inline void clear_has_symlink();
  inline void set_has_block_replication();
  inline void clear_has_block_replication();
  inline void set_has_blocksize();
  inline void clear_has_blocksize();
  inline void set_has_locations();
  inline void clear_has_locations();
  inline void set_has_fileid();
  inline void clear_has_fileid();
  inline void set_has_childrennum();
  inline void clear_has_childrennum();
  inline void set_has_fileencryptioninfo();
  inline void clear_has_fileencryptioninfo();
  inline void set_has_storagepolicy();
  inline void clear_has_storagepolicy();
  inline void set_has_ecpolicy();
  inline void clear_has_ecpolicy();
  inline void set_has_flags();
  inline void clear_has_flags();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr path_;
  ::google::protobuf::uint64 length_;
  ::hadoop::hdfs::FsPermissionProto* permission_;
  ::google::protobuf::internal::ArenaStringPtr owner_;
  int filetype_;
  ::google::protobuf::uint32 block_replication_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  ::google::protobuf::uint64 modification_time_;
  ::google::protobuf::uint64 access_time_;
  ::google::protobuf::internal::ArenaStringPtr symlink_;
  ::google::protobuf::uint64 blocksize_;
  ::hadoop::hdfs::LocatedBlocksProto* locations_;
  ::google::protobuf::uint64 fileid_;
  ::hadoop::hdfs::FileEncryptionInfoProto* fileencryptioninfo_;
  ::google::protobuf::int32 childrennum_;
  ::google::protobuf::uint32 storagepolicy_;
  ::hadoop::hdfs::ErasureCodingPolicyProto* ecpolicy_;
  ::google::protobuf::uint32 flags_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static HdfsFileStatusProto* default_instance_;
};
// -------------------------------------------------------------------

class FsServerDefaultsProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.FsServerDefaultsProto) */ {
 public:
  FsServerDefaultsProto();
  virtual ~FsServerDefaultsProto();

  FsServerDefaultsProto(const FsServerDefaultsProto& from);

  inline FsServerDefaultsProto& operator=(const FsServerDefaultsProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FsServerDefaultsProto& default_instance();

  void Swap(FsServerDefaultsProto* other);

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

  inline FsServerDefaultsProto* New() const { return New(NULL); }

  FsServerDefaultsProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FsServerDefaultsProto& from);
  void MergeFrom(const FsServerDefaultsProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FsServerDefaultsProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint64 blockSize = 1;
  bool has_blocksize() const;
  void clear_blocksize();
  static const int kBlockSizeFieldNumber = 1;
  ::google::protobuf::uint64 blocksize() const;
  void set_blocksize(::google::protobuf::uint64 value);

  // required uint32 bytesPerChecksum = 2;
  bool has_bytesperchecksum() const;
  void clear_bytesperchecksum();
  static const int kBytesPerChecksumFieldNumber = 2;
  ::google::protobuf::uint32 bytesperchecksum() const;
  void set_bytesperchecksum(::google::protobuf::uint32 value);

  // required uint32 writePacketSize = 3;
  bool has_writepacketsize() const;
  void clear_writepacketsize();
  static const int kWritePacketSizeFieldNumber = 3;
  ::google::protobuf::uint32 writepacketsize() const;
  void set_writepacketsize(::google::protobuf::uint32 value);

  // required uint32 replication = 4;
  bool has_replication() const;
  void clear_replication();
  static const int kReplicationFieldNumber = 4;
  ::google::protobuf::uint32 replication() const;
  void set_replication(::google::protobuf::uint32 value);

  // required uint32 fileBufferSize = 5;
  bool has_filebuffersize() const;
  void clear_filebuffersize();
  static const int kFileBufferSizeFieldNumber = 5;
  ::google::protobuf::uint32 filebuffersize() const;
  void set_filebuffersize(::google::protobuf::uint32 value);

  // optional bool encryptDataTransfer = 6 [default = false];
  bool has_encryptdatatransfer() const;
  void clear_encryptdatatransfer();
  static const int kEncryptDataTransferFieldNumber = 6;
  bool encryptdatatransfer() const;
  void set_encryptdatatransfer(bool value);

  // optional uint64 trashInterval = 7 [default = 0];
  bool has_trashinterval() const;
  void clear_trashinterval();
  static const int kTrashIntervalFieldNumber = 7;
  ::google::protobuf::uint64 trashinterval() const;
  void set_trashinterval(::google::protobuf::uint64 value);

  // optional .hadoop.hdfs.ChecksumTypeProto checksumType = 8 [default = CHECKSUM_CRC32];
  bool has_checksumtype() const;
  void clear_checksumtype();
  static const int kChecksumTypeFieldNumber = 8;
  ::hadoop::hdfs::ChecksumTypeProto checksumtype() const;
  void set_checksumtype(::hadoop::hdfs::ChecksumTypeProto value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.FsServerDefaultsProto)
 private:
  inline void set_has_blocksize();
  inline void clear_has_blocksize();
  inline void set_has_bytesperchecksum();
  inline void clear_has_bytesperchecksum();
  inline void set_has_writepacketsize();
  inline void clear_has_writepacketsize();
  inline void set_has_replication();
  inline void clear_has_replication();
  inline void set_has_filebuffersize();
  inline void clear_has_filebuffersize();
  inline void set_has_encryptdatatransfer();
  inline void clear_has_encryptdatatransfer();
  inline void set_has_trashinterval();
  inline void clear_has_trashinterval();
  inline void set_has_checksumtype();
  inline void clear_has_checksumtype();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 blocksize_;
  ::google::protobuf::uint32 bytesperchecksum_;
  ::google::protobuf::uint32 writepacketsize_;
  ::google::protobuf::uint32 replication_;
  ::google::protobuf::uint32 filebuffersize_;
  ::google::protobuf::uint64 trashinterval_;
  bool encryptdatatransfer_;
  int checksumtype_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static FsServerDefaultsProto* default_instance_;
};
// -------------------------------------------------------------------

class DirectoryListingProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.DirectoryListingProto) */ {
 public:
  DirectoryListingProto();
  virtual ~DirectoryListingProto();

  DirectoryListingProto(const DirectoryListingProto& from);

  inline DirectoryListingProto& operator=(const DirectoryListingProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DirectoryListingProto& default_instance();

  void Swap(DirectoryListingProto* other);

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

  inline DirectoryListingProto* New() const { return New(NULL); }

  DirectoryListingProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirectoryListingProto& from);
  void MergeFrom(const DirectoryListingProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DirectoryListingProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .hadoop.hdfs.HdfsFileStatusProto partialListing = 1;
  int partiallisting_size() const;
  void clear_partiallisting();
  static const int kPartialListingFieldNumber = 1;
  const ::hadoop::hdfs::HdfsFileStatusProto& partiallisting(int index) const;
  ::hadoop::hdfs::HdfsFileStatusProto* mutable_partiallisting(int index);
  ::hadoop::hdfs::HdfsFileStatusProto* add_partiallisting();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::HdfsFileStatusProto >*
      mutable_partiallisting();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::HdfsFileStatusProto >&
      partiallisting() const;

  // required uint32 remainingEntries = 2;
  bool has_remainingentries() const;
  void clear_remainingentries();
  static const int kRemainingEntriesFieldNumber = 2;
  ::google::protobuf::uint32 remainingentries() const;
  void set_remainingentries(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.DirectoryListingProto)
 private:
  inline void set_has_remainingentries();
  inline void clear_has_remainingentries();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::HdfsFileStatusProto > partiallisting_;
  ::google::protobuf::uint32 remainingentries_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static DirectoryListingProto* default_instance_;
};
// -------------------------------------------------------------------

class SnapshottableDirectoryStatusProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SnapshottableDirectoryStatusProto) */ {
 public:
  SnapshottableDirectoryStatusProto();
  virtual ~SnapshottableDirectoryStatusProto();

  SnapshottableDirectoryStatusProto(const SnapshottableDirectoryStatusProto& from);

  inline SnapshottableDirectoryStatusProto& operator=(const SnapshottableDirectoryStatusProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SnapshottableDirectoryStatusProto& default_instance();

  void Swap(SnapshottableDirectoryStatusProto* other);

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

  inline SnapshottableDirectoryStatusProto* New() const { return New(NULL); }

  SnapshottableDirectoryStatusProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SnapshottableDirectoryStatusProto& from);
  void MergeFrom(const SnapshottableDirectoryStatusProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SnapshottableDirectoryStatusProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.HdfsFileStatusProto dirStatus = 1;
  bool has_dirstatus() const;
  void clear_dirstatus();
  static const int kDirStatusFieldNumber = 1;
  const ::hadoop::hdfs::HdfsFileStatusProto& dirstatus() const;
  ::hadoop::hdfs::HdfsFileStatusProto* mutable_dirstatus();
  ::hadoop::hdfs::HdfsFileStatusProto* release_dirstatus();
  void set_allocated_dirstatus(::hadoop::hdfs::HdfsFileStatusProto* dirstatus);

  // required uint32 snapshot_quota = 2;
  bool has_snapshot_quota() const;
  void clear_snapshot_quota();
  static const int kSnapshotQuotaFieldNumber = 2;
  ::google::protobuf::uint32 snapshot_quota() const;
  void set_snapshot_quota(::google::protobuf::uint32 value);

  // required uint32 snapshot_number = 3;
  bool has_snapshot_number() const;
  void clear_snapshot_number();
  static const int kSnapshotNumberFieldNumber = 3;
  ::google::protobuf::uint32 snapshot_number() const;
  void set_snapshot_number(::google::protobuf::uint32 value);

  // required bytes parent_fullpath = 4;
  bool has_parent_fullpath() const;
  void clear_parent_fullpath();
  static const int kParentFullpathFieldNumber = 4;
  const ::std::string& parent_fullpath() const;
  void set_parent_fullpath(const ::std::string& value);
  void set_parent_fullpath(const char* value);
  void set_parent_fullpath(const void* value, size_t size);
  ::std::string* mutable_parent_fullpath();
  ::std::string* release_parent_fullpath();
  void set_allocated_parent_fullpath(::std::string* parent_fullpath);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SnapshottableDirectoryStatusProto)
 private:
  inline void set_has_dirstatus();
  inline void clear_has_dirstatus();
  inline void set_has_snapshot_quota();
  inline void clear_has_snapshot_quota();
  inline void set_has_snapshot_number();
  inline void clear_has_snapshot_number();
  inline void set_has_parent_fullpath();
  inline void clear_has_parent_fullpath();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::hadoop::hdfs::HdfsFileStatusProto* dirstatus_;
  ::google::protobuf::uint32 snapshot_quota_;
  ::google::protobuf::uint32 snapshot_number_;
  ::google::protobuf::internal::ArenaStringPtr parent_fullpath_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static SnapshottableDirectoryStatusProto* default_instance_;
};
// -------------------------------------------------------------------

class SnapshottableDirectoryListingProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SnapshottableDirectoryListingProto) */ {
 public:
  SnapshottableDirectoryListingProto();
  virtual ~SnapshottableDirectoryListingProto();

  SnapshottableDirectoryListingProto(const SnapshottableDirectoryListingProto& from);

  inline SnapshottableDirectoryListingProto& operator=(const SnapshottableDirectoryListingProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SnapshottableDirectoryListingProto& default_instance();

  void Swap(SnapshottableDirectoryListingProto* other);

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

  inline SnapshottableDirectoryListingProto* New() const { return New(NULL); }

  SnapshottableDirectoryListingProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SnapshottableDirectoryListingProto& from);
  void MergeFrom(const SnapshottableDirectoryListingProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SnapshottableDirectoryListingProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .hadoop.hdfs.SnapshottableDirectoryStatusProto snapshottableDirListing = 1;
  int snapshottabledirlisting_size() const;
  void clear_snapshottabledirlisting();
  static const int kSnapshottableDirListingFieldNumber = 1;
  const ::hadoop::hdfs::SnapshottableDirectoryStatusProto& snapshottabledirlisting(int index) const;
  ::hadoop::hdfs::SnapshottableDirectoryStatusProto* mutable_snapshottabledirlisting(int index);
  ::hadoop::hdfs::SnapshottableDirectoryStatusProto* add_snapshottabledirlisting();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshottableDirectoryStatusProto >*
      mutable_snapshottabledirlisting();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshottableDirectoryStatusProto >&
      snapshottabledirlisting() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SnapshottableDirectoryListingProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshottableDirectoryStatusProto > snapshottabledirlisting_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static SnapshottableDirectoryListingProto* default_instance_;
};
// -------------------------------------------------------------------

class SnapshotDiffReportEntryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SnapshotDiffReportEntryProto) */ {
 public:
  SnapshotDiffReportEntryProto();
  virtual ~SnapshotDiffReportEntryProto();

  SnapshotDiffReportEntryProto(const SnapshotDiffReportEntryProto& from);

  inline SnapshotDiffReportEntryProto& operator=(const SnapshotDiffReportEntryProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SnapshotDiffReportEntryProto& default_instance();

  void Swap(SnapshotDiffReportEntryProto* other);

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

  inline SnapshotDiffReportEntryProto* New() const { return New(NULL); }

  SnapshotDiffReportEntryProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SnapshotDiffReportEntryProto& from);
  void MergeFrom(const SnapshotDiffReportEntryProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SnapshotDiffReportEntryProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required bytes fullpath = 1;
  bool has_fullpath() const;
  void clear_fullpath();
  static const int kFullpathFieldNumber = 1;
  const ::std::string& fullpath() const;
  void set_fullpath(const ::std::string& value);
  void set_fullpath(const char* value);
  void set_fullpath(const void* value, size_t size);
  ::std::string* mutable_fullpath();
  ::std::string* release_fullpath();
  void set_allocated_fullpath(::std::string* fullpath);

  // required string modificationLabel = 2;
  bool has_modificationlabel() const;
  void clear_modificationlabel();
  static const int kModificationLabelFieldNumber = 2;
  const ::std::string& modificationlabel() const;
  void set_modificationlabel(const ::std::string& value);
  void set_modificationlabel(const char* value);
  void set_modificationlabel(const char* value, size_t size);
  ::std::string* mutable_modificationlabel();
  ::std::string* release_modificationlabel();
  void set_allocated_modificationlabel(::std::string* modificationlabel);

  // optional bytes targetPath = 3;
  bool has_targetpath() const;
  void clear_targetpath();
  static const int kTargetPathFieldNumber = 3;
  const ::std::string& targetpath() const;
  void set_targetpath(const ::std::string& value);
  void set_targetpath(const char* value);
  void set_targetpath(const void* value, size_t size);
  ::std::string* mutable_targetpath();
  ::std::string* release_targetpath();
  void set_allocated_targetpath(::std::string* targetpath);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SnapshotDiffReportEntryProto)
 private:
  inline void set_has_fullpath();
  inline void clear_has_fullpath();
  inline void set_has_modificationlabel();
  inline void clear_has_modificationlabel();
  inline void set_has_targetpath();
  inline void clear_has_targetpath();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr fullpath_;
  ::google::protobuf::internal::ArenaStringPtr modificationlabel_;
  ::google::protobuf::internal::ArenaStringPtr targetpath_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static SnapshotDiffReportEntryProto* default_instance_;
};
// -------------------------------------------------------------------

class SnapshotDiffReportProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SnapshotDiffReportProto) */ {
 public:
  SnapshotDiffReportProto();
  virtual ~SnapshotDiffReportProto();

  SnapshotDiffReportProto(const SnapshotDiffReportProto& from);

  inline SnapshotDiffReportProto& operator=(const SnapshotDiffReportProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SnapshotDiffReportProto& default_instance();

  void Swap(SnapshotDiffReportProto* other);

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

  inline SnapshotDiffReportProto* New() const { return New(NULL); }

  SnapshotDiffReportProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SnapshotDiffReportProto& from);
  void MergeFrom(const SnapshotDiffReportProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SnapshotDiffReportProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string snapshotRoot = 1;
  bool has_snapshotroot() const;
  void clear_snapshotroot();
  static const int kSnapshotRootFieldNumber = 1;
  const ::std::string& snapshotroot() const;
  void set_snapshotroot(const ::std::string& value);
  void set_snapshotroot(const char* value);
  void set_snapshotroot(const char* value, size_t size);
  ::std::string* mutable_snapshotroot();
  ::std::string* release_snapshotroot();
  void set_allocated_snapshotroot(::std::string* snapshotroot);

  // required string fromSnapshot = 2;
  bool has_fromsnapshot() const;
  void clear_fromsnapshot();
  static const int kFromSnapshotFieldNumber = 2;
  const ::std::string& fromsnapshot() const;
  void set_fromsnapshot(const ::std::string& value);
  void set_fromsnapshot(const char* value);
  void set_fromsnapshot(const char* value, size_t size);
  ::std::string* mutable_fromsnapshot();
  ::std::string* release_fromsnapshot();
  void set_allocated_fromsnapshot(::std::string* fromsnapshot);

  // required string toSnapshot = 3;
  bool has_tosnapshot() const;
  void clear_tosnapshot();
  static const int kToSnapshotFieldNumber = 3;
  const ::std::string& tosnapshot() const;
  void set_tosnapshot(const ::std::string& value);
  void set_tosnapshot(const char* value);
  void set_tosnapshot(const char* value, size_t size);
  ::std::string* mutable_tosnapshot();
  ::std::string* release_tosnapshot();
  void set_allocated_tosnapshot(::std::string* tosnapshot);

  // repeated .hadoop.hdfs.SnapshotDiffReportEntryProto diffReportEntries = 4;
  int diffreportentries_size() const;
  void clear_diffreportentries();
  static const int kDiffReportEntriesFieldNumber = 4;
  const ::hadoop::hdfs::SnapshotDiffReportEntryProto& diffreportentries(int index) const;
  ::hadoop::hdfs::SnapshotDiffReportEntryProto* mutable_diffreportentries(int index);
  ::hadoop::hdfs::SnapshotDiffReportEntryProto* add_diffreportentries();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshotDiffReportEntryProto >*
      mutable_diffreportentries();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshotDiffReportEntryProto >&
      diffreportentries() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SnapshotDiffReportProto)
 private:
  inline void set_has_snapshotroot();
  inline void clear_has_snapshotroot();
  inline void set_has_fromsnapshot();
  inline void clear_has_fromsnapshot();
  inline void set_has_tosnapshot();
  inline void clear_has_tosnapshot();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr snapshotroot_;
  ::google::protobuf::internal::ArenaStringPtr fromsnapshot_;
  ::google::protobuf::internal::ArenaStringPtr tosnapshot_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshotDiffReportEntryProto > diffreportentries_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static SnapshotDiffReportProto* default_instance_;
};
// -------------------------------------------------------------------

class StorageInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.StorageInfoProto) */ {
 public:
  StorageInfoProto();
  virtual ~StorageInfoProto();

  StorageInfoProto(const StorageInfoProto& from);

  inline StorageInfoProto& operator=(const StorageInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StorageInfoProto& default_instance();

  void Swap(StorageInfoProto* other);

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

  inline StorageInfoProto* New() const { return New(NULL); }

  StorageInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StorageInfoProto& from);
  void MergeFrom(const StorageInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StorageInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint32 layoutVersion = 1;
  bool has_layoutversion() const;
  void clear_layoutversion();
  static const int kLayoutVersionFieldNumber = 1;
  ::google::protobuf::uint32 layoutversion() const;
  void set_layoutversion(::google::protobuf::uint32 value);

  // required uint32 namespceID = 2;
  bool has_namespceid() const;
  void clear_namespceid();
  static const int kNamespceIDFieldNumber = 2;
  ::google::protobuf::uint32 namespceid() const;
  void set_namespceid(::google::protobuf::uint32 value);

  // required string clusterID = 3;
  bool has_clusterid() const;
  void clear_clusterid();
  static const int kClusterIDFieldNumber = 3;
  const ::std::string& clusterid() const;
  void set_clusterid(const ::std::string& value);
  void set_clusterid(const char* value);
  void set_clusterid(const char* value, size_t size);
  ::std::string* mutable_clusterid();
  ::std::string* release_clusterid();
  void set_allocated_clusterid(::std::string* clusterid);

  // required uint64 cTime = 4;
  bool has_ctime() const;
  void clear_ctime();
  static const int kCTimeFieldNumber = 4;
  ::google::protobuf::uint64 ctime() const;
  void set_ctime(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.StorageInfoProto)
 private:
  inline void set_has_layoutversion();
  inline void clear_has_layoutversion();
  inline void set_has_namespceid();
  inline void clear_has_namespceid();
  inline void set_has_clusterid();
  inline void clear_has_clusterid();
  inline void set_has_ctime();
  inline void clear_has_ctime();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 layoutversion_;
  ::google::protobuf::uint32 namespceid_;
  ::google::protobuf::internal::ArenaStringPtr clusterid_;
  ::google::protobuf::uint64 ctime_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static StorageInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class NamenodeRegistrationProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.NamenodeRegistrationProto) */ {
 public:
  NamenodeRegistrationProto();
  virtual ~NamenodeRegistrationProto();

  NamenodeRegistrationProto(const NamenodeRegistrationProto& from);

  inline NamenodeRegistrationProto& operator=(const NamenodeRegistrationProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NamenodeRegistrationProto& default_instance();

  void Swap(NamenodeRegistrationProto* other);

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

  inline NamenodeRegistrationProto* New() const { return New(NULL); }

  NamenodeRegistrationProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NamenodeRegistrationProto& from);
  void MergeFrom(const NamenodeRegistrationProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(NamenodeRegistrationProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef NamenodeRegistrationProto_NamenodeRoleProto NamenodeRoleProto;
  static const NamenodeRoleProto NAMENODE =
    NamenodeRegistrationProto_NamenodeRoleProto_NAMENODE;
  static const NamenodeRoleProto BACKUP =
    NamenodeRegistrationProto_NamenodeRoleProto_BACKUP;
  static const NamenodeRoleProto CHECKPOINT =
    NamenodeRegistrationProto_NamenodeRoleProto_CHECKPOINT;
  static inline bool NamenodeRoleProto_IsValid(int value) {
    return NamenodeRegistrationProto_NamenodeRoleProto_IsValid(value);
  }
  static const NamenodeRoleProto NamenodeRoleProto_MIN =
    NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MIN;
  static const NamenodeRoleProto NamenodeRoleProto_MAX =
    NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MAX;
  static const int NamenodeRoleProto_ARRAYSIZE =
    NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  NamenodeRoleProto_descriptor() {
    return NamenodeRegistrationProto_NamenodeRoleProto_descriptor();
  }
  static inline const ::std::string& NamenodeRoleProto_Name(NamenodeRoleProto value) {
    return NamenodeRegistrationProto_NamenodeRoleProto_Name(value);
  }
  static inline bool NamenodeRoleProto_Parse(const ::std::string& name,
      NamenodeRoleProto* value) {
    return NamenodeRegistrationProto_NamenodeRoleProto_Parse(name, value);
  }

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

  // required string rpcAddress = 1;
  bool has_rpcaddress() const;
  void clear_rpcaddress();
  static const int kRpcAddressFieldNumber = 1;
  const ::std::string& rpcaddress() const;
  void set_rpcaddress(const ::std::string& value);
  void set_rpcaddress(const char* value);
  void set_rpcaddress(const char* value, size_t size);
  ::std::string* mutable_rpcaddress();
  ::std::string* release_rpcaddress();
  void set_allocated_rpcaddress(::std::string* rpcaddress);

  // required string httpAddress = 2;
  bool has_httpaddress() const;
  void clear_httpaddress();
  static const int kHttpAddressFieldNumber = 2;
  const ::std::string& httpaddress() const;
  void set_httpaddress(const ::std::string& value);
  void set_httpaddress(const char* value);
  void set_httpaddress(const char* value, size_t size);
  ::std::string* mutable_httpaddress();
  ::std::string* release_httpaddress();
  void set_allocated_httpaddress(::std::string* httpaddress);

  // required .hadoop.hdfs.StorageInfoProto storageInfo = 3;
  bool has_storageinfo() const;
  void clear_storageinfo();
  static const int kStorageInfoFieldNumber = 3;
  const ::hadoop::hdfs::StorageInfoProto& storageinfo() const;
  ::hadoop::hdfs::StorageInfoProto* mutable_storageinfo();
  ::hadoop::hdfs::StorageInfoProto* release_storageinfo();
  void set_allocated_storageinfo(::hadoop::hdfs::StorageInfoProto* storageinfo);

  // optional .hadoop.hdfs.NamenodeRegistrationProto.NamenodeRoleProto role = 4 [default = NAMENODE];
  bool has_role() const;
  void clear_role();
  static const int kRoleFieldNumber = 4;
  ::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto role() const;
  void set_role(::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.NamenodeRegistrationProto)
 private:
  inline void set_has_rpcaddress();
  inline void clear_has_rpcaddress();
  inline void set_has_httpaddress();
  inline void clear_has_httpaddress();
  inline void set_has_storageinfo();
  inline void clear_has_storageinfo();
  inline void set_has_role();
  inline void clear_has_role();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr rpcaddress_;
  ::google::protobuf::internal::ArenaStringPtr httpaddress_;
  ::hadoop::hdfs::StorageInfoProto* storageinfo_;
  int role_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static NamenodeRegistrationProto* default_instance_;
};
// -------------------------------------------------------------------

class CheckpointSignatureProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.CheckpointSignatureProto) */ {
 public:
  CheckpointSignatureProto();
  virtual ~CheckpointSignatureProto();

  CheckpointSignatureProto(const CheckpointSignatureProto& from);

  inline CheckpointSignatureProto& operator=(const CheckpointSignatureProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CheckpointSignatureProto& default_instance();

  void Swap(CheckpointSignatureProto* other);

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

  inline CheckpointSignatureProto* New() const { return New(NULL); }

  CheckpointSignatureProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CheckpointSignatureProto& from);
  void MergeFrom(const CheckpointSignatureProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CheckpointSignatureProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string blockPoolId = 1;
  bool has_blockpoolid() const;
  void clear_blockpoolid();
  static const int kBlockPoolIdFieldNumber = 1;
  const ::std::string& blockpoolid() const;
  void set_blockpoolid(const ::std::string& value);
  void set_blockpoolid(const char* value);
  void set_blockpoolid(const char* value, size_t size);
  ::std::string* mutable_blockpoolid();
  ::std::string* release_blockpoolid();
  void set_allocated_blockpoolid(::std::string* blockpoolid);

  // required uint64 mostRecentCheckpointTxId = 2;
  bool has_mostrecentcheckpointtxid() const;
  void clear_mostrecentcheckpointtxid();
  static const int kMostRecentCheckpointTxIdFieldNumber = 2;
  ::google::protobuf::uint64 mostrecentcheckpointtxid() const;
  void set_mostrecentcheckpointtxid(::google::protobuf::uint64 value);

  // required uint64 curSegmentTxId = 3;
  bool has_cursegmenttxid() const;
  void clear_cursegmenttxid();
  static const int kCurSegmentTxIdFieldNumber = 3;
  ::google::protobuf::uint64 cursegmenttxid() const;
  void set_cursegmenttxid(::google::protobuf::uint64 value);

  // required .hadoop.hdfs.StorageInfoProto storageInfo = 4;
  bool has_storageinfo() const;
  void clear_storageinfo();
  static const int kStorageInfoFieldNumber = 4;
  const ::hadoop::hdfs::StorageInfoProto& storageinfo() const;
  ::hadoop::hdfs::StorageInfoProto* mutable_storageinfo();
  ::hadoop::hdfs::StorageInfoProto* release_storageinfo();
  void set_allocated_storageinfo(::hadoop::hdfs::StorageInfoProto* storageinfo);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.CheckpointSignatureProto)
 private:
  inline void set_has_blockpoolid();
  inline void clear_has_blockpoolid();
  inline void set_has_mostrecentcheckpointtxid();
  inline void clear_has_mostrecentcheckpointtxid();
  inline void set_has_cursegmenttxid();
  inline void clear_has_cursegmenttxid();
  inline void set_has_storageinfo();
  inline void clear_has_storageinfo();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr blockpoolid_;
  ::google::protobuf::uint64 mostrecentcheckpointtxid_;
  ::google::protobuf::uint64 cursegmenttxid_;
  ::hadoop::hdfs::StorageInfoProto* storageinfo_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static CheckpointSignatureProto* default_instance_;
};
// -------------------------------------------------------------------

class NamenodeCommandProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.NamenodeCommandProto) */ {
 public:
  NamenodeCommandProto();
  virtual ~NamenodeCommandProto();

  NamenodeCommandProto(const NamenodeCommandProto& from);

  inline NamenodeCommandProto& operator=(const NamenodeCommandProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NamenodeCommandProto& default_instance();

  void Swap(NamenodeCommandProto* other);

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

  inline NamenodeCommandProto* New() const { return New(NULL); }

  NamenodeCommandProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NamenodeCommandProto& from);
  void MergeFrom(const NamenodeCommandProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(NamenodeCommandProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef NamenodeCommandProto_Type Type;
  static const Type NamenodeCommand =
    NamenodeCommandProto_Type_NamenodeCommand;
  static const Type CheckPointCommand =
    NamenodeCommandProto_Type_CheckPointCommand;
  static inline bool Type_IsValid(int value) {
    return NamenodeCommandProto_Type_IsValid(value);
  }
  static const Type Type_MIN =
    NamenodeCommandProto_Type_Type_MIN;
  static const Type Type_MAX =
    NamenodeCommandProto_Type_Type_MAX;
  static const int Type_ARRAYSIZE =
    NamenodeCommandProto_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Type_descriptor() {
    return NamenodeCommandProto_Type_descriptor();
  }
  static inline const ::std::string& Type_Name(Type value) {
    return NamenodeCommandProto_Type_Name(value);
  }
  static inline bool Type_Parse(const ::std::string& name,
      Type* value) {
    return NamenodeCommandProto_Type_Parse(name, value);
  }

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

  // required uint32 action = 1;
  bool has_action() const;
  void clear_action();
  static const int kActionFieldNumber = 1;
  ::google::protobuf::uint32 action() const;
  void set_action(::google::protobuf::uint32 value);

  // required .hadoop.hdfs.NamenodeCommandProto.Type type = 2;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 2;
  ::hadoop::hdfs::NamenodeCommandProto_Type type() const;
  void set_type(::hadoop::hdfs::NamenodeCommandProto_Type value);

  // optional .hadoop.hdfs.CheckpointCommandProto checkpointCmd = 3;
  bool has_checkpointcmd() const;
  void clear_checkpointcmd();
  static const int kCheckpointCmdFieldNumber = 3;
  const ::hadoop::hdfs::CheckpointCommandProto& checkpointcmd() const;
  ::hadoop::hdfs::CheckpointCommandProto* mutable_checkpointcmd();
  ::hadoop::hdfs::CheckpointCommandProto* release_checkpointcmd();
  void set_allocated_checkpointcmd(::hadoop::hdfs::CheckpointCommandProto* checkpointcmd);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.NamenodeCommandProto)
 private:
  inline void set_has_action();
  inline void clear_has_action();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_checkpointcmd();
  inline void clear_has_checkpointcmd();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 action_;
  int type_;
  ::hadoop::hdfs::CheckpointCommandProto* checkpointcmd_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static NamenodeCommandProto* default_instance_;
};
// -------------------------------------------------------------------

class CheckpointCommandProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.CheckpointCommandProto) */ {
 public:
  CheckpointCommandProto();
  virtual ~CheckpointCommandProto();

  CheckpointCommandProto(const CheckpointCommandProto& from);

  inline CheckpointCommandProto& operator=(const CheckpointCommandProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CheckpointCommandProto& default_instance();

  void Swap(CheckpointCommandProto* other);

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

  inline CheckpointCommandProto* New() const { return New(NULL); }

  CheckpointCommandProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CheckpointCommandProto& from);
  void MergeFrom(const CheckpointCommandProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CheckpointCommandProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.CheckpointSignatureProto signature = 1;
  bool has_signature() const;
  void clear_signature();
  static const int kSignatureFieldNumber = 1;
  const ::hadoop::hdfs::CheckpointSignatureProto& signature() const;
  ::hadoop::hdfs::CheckpointSignatureProto* mutable_signature();
  ::hadoop::hdfs::CheckpointSignatureProto* release_signature();
  void set_allocated_signature(::hadoop::hdfs::CheckpointSignatureProto* signature);

  // required bool needToReturnImage = 2;
  bool has_needtoreturnimage() const;
  void clear_needtoreturnimage();
  static const int kNeedToReturnImageFieldNumber = 2;
  bool needtoreturnimage() const;
  void set_needtoreturnimage(bool value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.CheckpointCommandProto)
 private:
  inline void set_has_signature();
  inline void clear_has_signature();
  inline void set_has_needtoreturnimage();
  inline void clear_has_needtoreturnimage();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::hadoop::hdfs::CheckpointSignatureProto* signature_;
  bool needtoreturnimage_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static CheckpointCommandProto* default_instance_;
};
// -------------------------------------------------------------------

class BlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.BlockProto) */ {
 public:
  BlockProto();
  virtual ~BlockProto();

  BlockProto(const BlockProto& from);

  inline BlockProto& operator=(const BlockProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlockProto& default_instance();

  void Swap(BlockProto* other);

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

  inline BlockProto* New() const { return New(NULL); }

  BlockProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlockProto& from);
  void MergeFrom(const BlockProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BlockProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint64 blockId = 1;
  bool has_blockid() const;
  void clear_blockid();
  static const int kBlockIdFieldNumber = 1;
  ::google::protobuf::uint64 blockid() const;
  void set_blockid(::google::protobuf::uint64 value);

  // required uint64 genStamp = 2;
  bool has_genstamp() const;
  void clear_genstamp();
  static const int kGenStampFieldNumber = 2;
  ::google::protobuf::uint64 genstamp() const;
  void set_genstamp(::google::protobuf::uint64 value);

  // optional uint64 numBytes = 3 [default = 0];
  bool has_numbytes() const;
  void clear_numbytes();
  static const int kNumBytesFieldNumber = 3;
  ::google::protobuf::uint64 numbytes() const;
  void set_numbytes(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.BlockProto)
 private:
  inline void set_has_blockid();
  inline void clear_has_blockid();
  inline void set_has_genstamp();
  inline void clear_has_genstamp();
  inline void set_has_numbytes();
  inline void clear_has_numbytes();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 blockid_;
  ::google::protobuf::uint64 genstamp_;
  ::google::protobuf::uint64 numbytes_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static BlockProto* default_instance_;
};
// -------------------------------------------------------------------

class BlockWithLocationsProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.BlockWithLocationsProto) */ {
 public:
  BlockWithLocationsProto();
  virtual ~BlockWithLocationsProto();

  BlockWithLocationsProto(const BlockWithLocationsProto& from);

  inline BlockWithLocationsProto& operator=(const BlockWithLocationsProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlockWithLocationsProto& default_instance();

  void Swap(BlockWithLocationsProto* other);

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

  inline BlockWithLocationsProto* New() const { return New(NULL); }

  BlockWithLocationsProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlockWithLocationsProto& from);
  void MergeFrom(const BlockWithLocationsProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BlockWithLocationsProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.BlockProto block = 1;
  bool has_block() const;
  void clear_block();
  static const int kBlockFieldNumber = 1;
  const ::hadoop::hdfs::BlockProto& block() const;
  ::hadoop::hdfs::BlockProto* mutable_block();
  ::hadoop::hdfs::BlockProto* release_block();
  void set_allocated_block(::hadoop::hdfs::BlockProto* block);

  // repeated string datanodeUuids = 2;
  int datanodeuuids_size() const;
  void clear_datanodeuuids();
  static const int kDatanodeUuidsFieldNumber = 2;
  const ::std::string& datanodeuuids(int index) const;
  ::std::string* mutable_datanodeuuids(int index);
  void set_datanodeuuids(int index, const ::std::string& value);
  void set_datanodeuuids(int index, const char* value);
  void set_datanodeuuids(int index, const char* value, size_t size);
  ::std::string* add_datanodeuuids();
  void add_datanodeuuids(const ::std::string& value);
  void add_datanodeuuids(const char* value);
  void add_datanodeuuids(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& datanodeuuids() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_datanodeuuids();

  // repeated string storageUuids = 3;
  int storageuuids_size() const;
  void clear_storageuuids();
  static const int kStorageUuidsFieldNumber = 3;
  const ::std::string& storageuuids(int index) const;
  ::std::string* mutable_storageuuids(int index);
  void set_storageuuids(int index, const ::std::string& value);
  void set_storageuuids(int index, const char* value);
  void set_storageuuids(int index, const char* value, size_t size);
  ::std::string* add_storageuuids();
  void add_storageuuids(const ::std::string& value);
  void add_storageuuids(const char* value);
  void add_storageuuids(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& storageuuids() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_storageuuids();

  // repeated .hadoop.hdfs.StorageTypeProto storageTypes = 4;
  int storagetypes_size() const;
  void clear_storagetypes();
  static const int kStorageTypesFieldNumber = 4;
  ::hadoop::hdfs::StorageTypeProto storagetypes(int index) const;
  void set_storagetypes(int index, ::hadoop::hdfs::StorageTypeProto value);
  void add_storagetypes(::hadoop::hdfs::StorageTypeProto value);
  const ::google::protobuf::RepeatedField<int>& storagetypes() const;
  ::google::protobuf::RepeatedField<int>* mutable_storagetypes();

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.BlockWithLocationsProto)
 private:
  inline void set_has_block();
  inline void clear_has_block();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::hadoop::hdfs::BlockProto* block_;
  ::google::protobuf::RepeatedPtrField< ::std::string> datanodeuuids_;
  ::google::protobuf::RepeatedPtrField< ::std::string> storageuuids_;
  ::google::protobuf::RepeatedField<int> storagetypes_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static BlockWithLocationsProto* default_instance_;
};
// -------------------------------------------------------------------

class BlocksWithLocationsProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.BlocksWithLocationsProto) */ {
 public:
  BlocksWithLocationsProto();
  virtual ~BlocksWithLocationsProto();

  BlocksWithLocationsProto(const BlocksWithLocationsProto& from);

  inline BlocksWithLocationsProto& operator=(const BlocksWithLocationsProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlocksWithLocationsProto& default_instance();

  void Swap(BlocksWithLocationsProto* other);

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

  inline BlocksWithLocationsProto* New() const { return New(NULL); }

  BlocksWithLocationsProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlocksWithLocationsProto& from);
  void MergeFrom(const BlocksWithLocationsProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BlocksWithLocationsProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .hadoop.hdfs.BlockWithLocationsProto blocks = 1;
  int blocks_size() const;
  void clear_blocks();
  static const int kBlocksFieldNumber = 1;
  const ::hadoop::hdfs::BlockWithLocationsProto& blocks(int index) const;
  ::hadoop::hdfs::BlockWithLocationsProto* mutable_blocks(int index);
  ::hadoop::hdfs::BlockWithLocationsProto* add_blocks();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockWithLocationsProto >*
      mutable_blocks();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockWithLocationsProto >&
      blocks() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.BlocksWithLocationsProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockWithLocationsProto > blocks_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static BlocksWithLocationsProto* default_instance_;
};
// -------------------------------------------------------------------

class RemoteEditLogProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoteEditLogProto) */ {
 public:
  RemoteEditLogProto();
  virtual ~RemoteEditLogProto();

  RemoteEditLogProto(const RemoteEditLogProto& from);

  inline RemoteEditLogProto& operator=(const RemoteEditLogProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RemoteEditLogProto& default_instance();

  void Swap(RemoteEditLogProto* other);

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

  inline RemoteEditLogProto* New() const { return New(NULL); }

  RemoteEditLogProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RemoteEditLogProto& from);
  void MergeFrom(const RemoteEditLogProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RemoteEditLogProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint64 startTxId = 1;
  bool has_starttxid() const;
  void clear_starttxid();
  static const int kStartTxIdFieldNumber = 1;
  ::google::protobuf::uint64 starttxid() const;
  void set_starttxid(::google::protobuf::uint64 value);

  // required uint64 endTxId = 2;
  bool has_endtxid() const;
  void clear_endtxid();
  static const int kEndTxIdFieldNumber = 2;
  ::google::protobuf::uint64 endtxid() const;
  void set_endtxid(::google::protobuf::uint64 value);

  // optional bool isInProgress = 3 [default = false];
  bool has_isinprogress() const;
  void clear_isinprogress();
  static const int kIsInProgressFieldNumber = 3;
  bool isinprogress() const;
  void set_isinprogress(bool value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoteEditLogProto)
 private:
  inline void set_has_starttxid();
  inline void clear_has_starttxid();
  inline void set_has_endtxid();
  inline void clear_has_endtxid();
  inline void set_has_isinprogress();
  inline void clear_has_isinprogress();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 starttxid_;
  ::google::protobuf::uint64 endtxid_;
  bool isinprogress_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static RemoteEditLogProto* default_instance_;
};
// -------------------------------------------------------------------

class RemoteEditLogManifestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoteEditLogManifestProto) */ {
 public:
  RemoteEditLogManifestProto();
  virtual ~RemoteEditLogManifestProto();

  RemoteEditLogManifestProto(const RemoteEditLogManifestProto& from);

  inline RemoteEditLogManifestProto& operator=(const RemoteEditLogManifestProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RemoteEditLogManifestProto& default_instance();

  void Swap(RemoteEditLogManifestProto* other);

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

  inline RemoteEditLogManifestProto* New() const { return New(NULL); }

  RemoteEditLogManifestProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RemoteEditLogManifestProto& from);
  void MergeFrom(const RemoteEditLogManifestProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RemoteEditLogManifestProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .hadoop.hdfs.RemoteEditLogProto logs = 1;
  int logs_size() const;
  void clear_logs();
  static const int kLogsFieldNumber = 1;
  const ::hadoop::hdfs::RemoteEditLogProto& logs(int index) const;
  ::hadoop::hdfs::RemoteEditLogProto* mutable_logs(int index);
  ::hadoop::hdfs::RemoteEditLogProto* add_logs();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::RemoteEditLogProto >*
      mutable_logs();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::RemoteEditLogProto >&
      logs() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoteEditLogManifestProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::RemoteEditLogProto > logs_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static RemoteEditLogManifestProto* default_instance_;
};
// -------------------------------------------------------------------

class NamespaceInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.NamespaceInfoProto) */ {
 public:
  NamespaceInfoProto();
  virtual ~NamespaceInfoProto();

  NamespaceInfoProto(const NamespaceInfoProto& from);

  inline NamespaceInfoProto& operator=(const NamespaceInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NamespaceInfoProto& default_instance();

  void Swap(NamespaceInfoProto* other);

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

  inline NamespaceInfoProto* New() const { return New(NULL); }

  NamespaceInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NamespaceInfoProto& from);
  void MergeFrom(const NamespaceInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(NamespaceInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string buildVersion = 1;
  bool has_buildversion() const;
  void clear_buildversion();
  static const int kBuildVersionFieldNumber = 1;
  const ::std::string& buildversion() const;
  void set_buildversion(const ::std::string& value);
  void set_buildversion(const char* value);
  void set_buildversion(const char* value, size_t size);
  ::std::string* mutable_buildversion();
  ::std::string* release_buildversion();
  void set_allocated_buildversion(::std::string* buildversion);

  // required uint32 unused = 2;
  bool has_unused() const;
  void clear_unused();
  static const int kUnusedFieldNumber = 2;
  ::google::protobuf::uint32 unused() const;
  void set_unused(::google::protobuf::uint32 value);

  // required string blockPoolID = 3;
  bool has_blockpoolid() const;
  void clear_blockpoolid();
  static const int kBlockPoolIDFieldNumber = 3;
  const ::std::string& blockpoolid() const;
  void set_blockpoolid(const ::std::string& value);
  void set_blockpoolid(const char* value);
  void set_blockpoolid(const char* value, size_t size);
  ::std::string* mutable_blockpoolid();
  ::std::string* release_blockpoolid();
  void set_allocated_blockpoolid(::std::string* blockpoolid);

  // required .hadoop.hdfs.StorageInfoProto storageInfo = 4;
  bool has_storageinfo() const;
  void clear_storageinfo();
  static const int kStorageInfoFieldNumber = 4;
  const ::hadoop::hdfs::StorageInfoProto& storageinfo() const;
  ::hadoop::hdfs::StorageInfoProto* mutable_storageinfo();
  ::hadoop::hdfs::StorageInfoProto* release_storageinfo();
  void set_allocated_storageinfo(::hadoop::hdfs::StorageInfoProto* storageinfo);

  // required string softwareVersion = 5;
  bool has_softwareversion() const;
  void clear_softwareversion();
  static const int kSoftwareVersionFieldNumber = 5;
  const ::std::string& softwareversion() const;
  void set_softwareversion(const ::std::string& value);
  void set_softwareversion(const char* value);
  void set_softwareversion(const char* value, size_t size);
  ::std::string* mutable_softwareversion();
  ::std::string* release_softwareversion();
  void set_allocated_softwareversion(::std::string* softwareversion);

  // optional uint64 capabilities = 6 [default = 0];
  bool has_capabilities() const;
  void clear_capabilities();
  static const int kCapabilitiesFieldNumber = 6;
  ::google::protobuf::uint64 capabilities() const;
  void set_capabilities(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.NamespaceInfoProto)
 private:
  inline void set_has_buildversion();
  inline void clear_has_buildversion();
  inline void set_has_unused();
  inline void clear_has_unused();
  inline void set_has_blockpoolid();
  inline void clear_has_blockpoolid();
  inline void set_has_storageinfo();
  inline void clear_has_storageinfo();
  inline void set_has_softwareversion();
  inline void clear_has_softwareversion();
  inline void set_has_capabilities();
  inline void clear_has_capabilities();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr buildversion_;
  ::google::protobuf::internal::ArenaStringPtr blockpoolid_;
  ::hadoop::hdfs::StorageInfoProto* storageinfo_;
  ::google::protobuf::internal::ArenaStringPtr softwareversion_;
  ::google::protobuf::uint64 capabilities_;
  ::google::protobuf::uint32 unused_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static NamespaceInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class BlockKeyProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.BlockKeyProto) */ {
 public:
  BlockKeyProto();
  virtual ~BlockKeyProto();

  BlockKeyProto(const BlockKeyProto& from);

  inline BlockKeyProto& operator=(const BlockKeyProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlockKeyProto& default_instance();

  void Swap(BlockKeyProto* other);

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

  inline BlockKeyProto* New() const { return New(NULL); }

  BlockKeyProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlockKeyProto& from);
  void MergeFrom(const BlockKeyProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BlockKeyProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint32 keyId = 1;
  bool has_keyid() const;
  void clear_keyid();
  static const int kKeyIdFieldNumber = 1;
  ::google::protobuf::uint32 keyid() const;
  void set_keyid(::google::protobuf::uint32 value);

  // required uint64 expiryDate = 2;
  bool has_expirydate() const;
  void clear_expirydate();
  static const int kExpiryDateFieldNumber = 2;
  ::google::protobuf::uint64 expirydate() const;
  void set_expirydate(::google::protobuf::uint64 value);

  // optional bytes keyBytes = 3;
  bool has_keybytes() const;
  void clear_keybytes();
  static const int kKeyBytesFieldNumber = 3;
  const ::std::string& keybytes() const;
  void set_keybytes(const ::std::string& value);
  void set_keybytes(const char* value);
  void set_keybytes(const void* value, size_t size);
  ::std::string* mutable_keybytes();
  ::std::string* release_keybytes();
  void set_allocated_keybytes(::std::string* keybytes);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.BlockKeyProto)
 private:
  inline void set_has_keyid();
  inline void clear_has_keyid();
  inline void set_has_expirydate();
  inline void clear_has_expirydate();
  inline void set_has_keybytes();
  inline void clear_has_keybytes();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 expirydate_;
  ::google::protobuf::internal::ArenaStringPtr keybytes_;
  ::google::protobuf::uint32 keyid_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static BlockKeyProto* default_instance_;
};
// -------------------------------------------------------------------

class ExportedBlockKeysProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ExportedBlockKeysProto) */ {
 public:
  ExportedBlockKeysProto();
  virtual ~ExportedBlockKeysProto();

  ExportedBlockKeysProto(const ExportedBlockKeysProto& from);

  inline ExportedBlockKeysProto& operator=(const ExportedBlockKeysProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ExportedBlockKeysProto& default_instance();

  void Swap(ExportedBlockKeysProto* other);

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

  inline ExportedBlockKeysProto* New() const { return New(NULL); }

  ExportedBlockKeysProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ExportedBlockKeysProto& from);
  void MergeFrom(const ExportedBlockKeysProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ExportedBlockKeysProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required bool isBlockTokenEnabled = 1;
  bool has_isblocktokenenabled() const;
  void clear_isblocktokenenabled();
  static const int kIsBlockTokenEnabledFieldNumber = 1;
  bool isblocktokenenabled() const;
  void set_isblocktokenenabled(bool value);

  // required uint64 keyUpdateInterval = 2;
  bool has_keyupdateinterval() const;
  void clear_keyupdateinterval();
  static const int kKeyUpdateIntervalFieldNumber = 2;
  ::google::protobuf::uint64 keyupdateinterval() const;
  void set_keyupdateinterval(::google::protobuf::uint64 value);

  // required uint64 tokenLifeTime = 3;
  bool has_tokenlifetime() const;
  void clear_tokenlifetime();
  static const int kTokenLifeTimeFieldNumber = 3;
  ::google::protobuf::uint64 tokenlifetime() const;
  void set_tokenlifetime(::google::protobuf::uint64 value);

  // required .hadoop.hdfs.BlockKeyProto currentKey = 4;
  bool has_currentkey() const;
  void clear_currentkey();
  static const int kCurrentKeyFieldNumber = 4;
  const ::hadoop::hdfs::BlockKeyProto& currentkey() const;
  ::hadoop::hdfs::BlockKeyProto* mutable_currentkey();
  ::hadoop::hdfs::BlockKeyProto* release_currentkey();
  void set_allocated_currentkey(::hadoop::hdfs::BlockKeyProto* currentkey);

  // repeated .hadoop.hdfs.BlockKeyProto allKeys = 5;
  int allkeys_size() const;
  void clear_allkeys();
  static const int kAllKeysFieldNumber = 5;
  const ::hadoop::hdfs::BlockKeyProto& allkeys(int index) const;
  ::hadoop::hdfs::BlockKeyProto* mutable_allkeys(int index);
  ::hadoop::hdfs::BlockKeyProto* add_allkeys();
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockKeyProto >*
      mutable_allkeys();
  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockKeyProto >&
      allkeys() const;

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ExportedBlockKeysProto)
 private:
  inline void set_has_isblocktokenenabled();
  inline void clear_has_isblocktokenenabled();
  inline void set_has_keyupdateinterval();
  inline void clear_has_keyupdateinterval();
  inline void set_has_tokenlifetime();
  inline void clear_has_tokenlifetime();
  inline void set_has_currentkey();
  inline void clear_has_currentkey();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 keyupdateinterval_;
  ::google::protobuf::uint64 tokenlifetime_;
  ::hadoop::hdfs::BlockKeyProto* currentkey_;
  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockKeyProto > allkeys_;
  bool isblocktokenenabled_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static ExportedBlockKeysProto* default_instance_;
};
// -------------------------------------------------------------------

class RecoveringBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RecoveringBlockProto) */ {
 public:
  RecoveringBlockProto();
  virtual ~RecoveringBlockProto();

  RecoveringBlockProto(const RecoveringBlockProto& from);

  inline RecoveringBlockProto& operator=(const RecoveringBlockProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RecoveringBlockProto& default_instance();

  void Swap(RecoveringBlockProto* other);

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

  inline RecoveringBlockProto* New() const { return New(NULL); }

  RecoveringBlockProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RecoveringBlockProto& from);
  void MergeFrom(const RecoveringBlockProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RecoveringBlockProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint64 newGenStamp = 1;
  bool has_newgenstamp() const;
  void clear_newgenstamp();
  static const int kNewGenStampFieldNumber = 1;
  ::google::protobuf::uint64 newgenstamp() const;
  void set_newgenstamp(::google::protobuf::uint64 value);

  // required .hadoop.hdfs.LocatedBlockProto block = 2;
  bool has_block() const;
  void clear_block();
  static const int kBlockFieldNumber = 2;
  const ::hadoop::hdfs::LocatedBlockProto& block() const;
  ::hadoop::hdfs::LocatedBlockProto* mutable_block();
  ::hadoop::hdfs::LocatedBlockProto* release_block();
  void set_allocated_block(::hadoop::hdfs::LocatedBlockProto* block);

  // optional .hadoop.hdfs.BlockProto truncateBlock = 3;
  bool has_truncateblock() const;
  void clear_truncateblock();
  static const int kTruncateBlockFieldNumber = 3;
  const ::hadoop::hdfs::BlockProto& truncateblock() const;
  ::hadoop::hdfs::BlockProto* mutable_truncateblock();
  ::hadoop::hdfs::BlockProto* release_truncateblock();
  void set_allocated_truncateblock(::hadoop::hdfs::BlockProto* truncateblock);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RecoveringBlockProto)
 private:
  inline void set_has_newgenstamp();
  inline void clear_has_newgenstamp();
  inline void set_has_block();
  inline void clear_has_block();
  inline void set_has_truncateblock();
  inline void clear_has_truncateblock();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 newgenstamp_;
  ::hadoop::hdfs::LocatedBlockProto* block_;
  ::hadoop::hdfs::BlockProto* truncateblock_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static RecoveringBlockProto* default_instance_;
};
// -------------------------------------------------------------------

class VersionRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.VersionRequestProto) */ {
 public:
  VersionRequestProto();
  virtual ~VersionRequestProto();

  VersionRequestProto(const VersionRequestProto& from);

  inline VersionRequestProto& operator=(const VersionRequestProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const VersionRequestProto& default_instance();

  void Swap(VersionRequestProto* other);

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

  inline VersionRequestProto* New() const { return New(NULL); }

  VersionRequestProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const VersionRequestProto& from);
  void MergeFrom(const VersionRequestProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(VersionRequestProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.VersionRequestProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static VersionRequestProto* default_instance_;
};
// -------------------------------------------------------------------

class VersionResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.VersionResponseProto) */ {
 public:
  VersionResponseProto();
  virtual ~VersionResponseProto();

  VersionResponseProto(const VersionResponseProto& from);

  inline VersionResponseProto& operator=(const VersionResponseProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const VersionResponseProto& default_instance();

  void Swap(VersionResponseProto* other);

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

  inline VersionResponseProto* New() const { return New(NULL); }

  VersionResponseProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const VersionResponseProto& from);
  void MergeFrom(const VersionResponseProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(VersionResponseProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .hadoop.hdfs.NamespaceInfoProto info = 1;
  bool has_info() const;
  void clear_info();
  static const int kInfoFieldNumber = 1;
  const ::hadoop::hdfs::NamespaceInfoProto& info() const;
  ::hadoop::hdfs::NamespaceInfoProto* mutable_info();
  ::hadoop::hdfs::NamespaceInfoProto* release_info();
  void set_allocated_info(::hadoop::hdfs::NamespaceInfoProto* info);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.VersionResponseProto)
 private:
  inline void set_has_info();
  inline void clear_has_info();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::hadoop::hdfs::NamespaceInfoProto* info_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static VersionResponseProto* default_instance_;
};
// -------------------------------------------------------------------

class SnapshotInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SnapshotInfoProto) */ {
 public:
  SnapshotInfoProto();
  virtual ~SnapshotInfoProto();

  SnapshotInfoProto(const SnapshotInfoProto& from);

  inline SnapshotInfoProto& operator=(const SnapshotInfoProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SnapshotInfoProto& default_instance();

  void Swap(SnapshotInfoProto* other);

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

  inline SnapshotInfoProto* New() const { return New(NULL); }

  SnapshotInfoProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SnapshotInfoProto& from);
  void MergeFrom(const SnapshotInfoProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SnapshotInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string snapshotName = 1;
  bool has_snapshotname() const;
  void clear_snapshotname();
  static const int kSnapshotNameFieldNumber = 1;
  const ::std::string& snapshotname() const;
  void set_snapshotname(const ::std::string& value);
  void set_snapshotname(const char* value);
  void set_snapshotname(const char* value, size_t size);
  ::std::string* mutable_snapshotname();
  ::std::string* release_snapshotname();
  void set_allocated_snapshotname(::std::string* snapshotname);

  // required string snapshotRoot = 2;
  bool has_snapshotroot() const;
  void clear_snapshotroot();
  static const int kSnapshotRootFieldNumber = 2;
  const ::std::string& snapshotroot() const;
  void set_snapshotroot(const ::std::string& value);
  void set_snapshotroot(const char* value);
  void set_snapshotroot(const char* value, size_t size);
  ::std::string* mutable_snapshotroot();
  ::std::string* release_snapshotroot();
  void set_allocated_snapshotroot(::std::string* snapshotroot);

  // required .hadoop.hdfs.FsPermissionProto permission = 3;
  bool has_permission() const;
  void clear_permission();
  static const int kPermissionFieldNumber = 3;
  const ::hadoop::hdfs::FsPermissionProto& permission() const;
  ::hadoop::hdfs::FsPermissionProto* mutable_permission();
  ::hadoop::hdfs::FsPermissionProto* release_permission();
  void set_allocated_permission(::hadoop::hdfs::FsPermissionProto* permission);

  // required string owner = 4;
  bool has_owner() const;
  void clear_owner();
  static const int kOwnerFieldNumber = 4;
  const ::std::string& owner() const;
  void set_owner(const ::std::string& value);
  void set_owner(const char* value);
  void set_owner(const char* value, size_t size);
  ::std::string* mutable_owner();
  ::std::string* release_owner();
  void set_allocated_owner(::std::string* owner);

  // required string group = 5;
  bool has_group() const;
  void clear_group();
  static const int kGroupFieldNumber = 5;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // required string createTime = 6;
  bool has_createtime() const;
  void clear_createtime();
  static const int kCreateTimeFieldNumber = 6;
  const ::std::string& createtime() const;
  void set_createtime(const ::std::string& value);
  void set_createtime(const char* value);
  void set_createtime(const char* value, size_t size);
  ::std::string* mutable_createtime();
  ::std::string* release_createtime();
  void set_allocated_createtime(::std::string* createtime);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SnapshotInfoProto)
 private:
  inline void set_has_snapshotname();
  inline void clear_has_snapshotname();
  inline void set_has_snapshotroot();
  inline void clear_has_snapshotroot();
  inline void set_has_permission();
  inline void clear_has_permission();
  inline void set_has_owner();
  inline void clear_has_owner();
  inline void set_has_group();
  inline void clear_has_group();
  inline void set_has_createtime();
  inline void clear_has_createtime();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr snapshotname_;
  ::google::protobuf::internal::ArenaStringPtr snapshotroot_;
  ::hadoop::hdfs::FsPermissionProto* permission_;
  ::google::protobuf::internal::ArenaStringPtr owner_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  ::google::protobuf::internal::ArenaStringPtr createtime_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static SnapshotInfoProto* default_instance_;
};
// -------------------------------------------------------------------

class RollingUpgradeStatusProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RollingUpgradeStatusProto) */ {
 public:
  RollingUpgradeStatusProto();
  virtual ~RollingUpgradeStatusProto();

  RollingUpgradeStatusProto(const RollingUpgradeStatusProto& from);

  inline RollingUpgradeStatusProto& operator=(const RollingUpgradeStatusProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RollingUpgradeStatusProto& default_instance();

  void Swap(RollingUpgradeStatusProto* other);

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

  inline RollingUpgradeStatusProto* New() const { return New(NULL); }

  RollingUpgradeStatusProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RollingUpgradeStatusProto& from);
  void MergeFrom(const RollingUpgradeStatusProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RollingUpgradeStatusProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string blockPoolId = 1;
  bool has_blockpoolid() const;
  void clear_blockpoolid();
  static const int kBlockPoolIdFieldNumber = 1;
  const ::std::string& blockpoolid() const;
  void set_blockpoolid(const ::std::string& value);
  void set_blockpoolid(const char* value);
  void set_blockpoolid(const char* value, size_t size);
  ::std::string* mutable_blockpoolid();
  ::std::string* release_blockpoolid();
  void set_allocated_blockpoolid(::std::string* blockpoolid);

  // optional bool finalized = 2 [default = false];
  bool has_finalized() const;
  void clear_finalized();
  static const int kFinalizedFieldNumber = 2;
  bool finalized() const;
  void set_finalized(bool value);

  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RollingUpgradeStatusProto)
 private:
  inline void set_has_blockpoolid();
  inline void clear_has_blockpoolid();
  inline void set_has_finalized();
  inline void clear_has_finalized();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr blockpoolid_;
  bool finalized_;
  friend void  protobuf_AddDesc_hdfs_2eproto();
  friend void protobuf_AssignDesc_hdfs_2eproto();
  friend void protobuf_ShutdownFile_hdfs_2eproto();

  void InitAsDefaultInstance();
  static RollingUpgradeStatusProto* default_instance_;
};
// ===================================================================


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// ExtendedBlockProto

// required string poolId = 1;
inline bool ExtendedBlockProto::has_poolid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ExtendedBlockProto::set_has_poolid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ExtendedBlockProto::clear_has_poolid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ExtendedBlockProto::clear_poolid() {
  poolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_poolid();
}
inline const ::std::string& ExtendedBlockProto::poolid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExtendedBlockProto.poolId)
  return poolid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ExtendedBlockProto::set_poolid(const ::std::string& value) {
  set_has_poolid();
  poolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ExtendedBlockProto.poolId)
}
inline void ExtendedBlockProto::set_poolid(const char* value) {
  set_has_poolid();
  poolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ExtendedBlockProto.poolId)
}
inline void ExtendedBlockProto::set_poolid(const char* value, size_t size) {
  set_has_poolid();
  poolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ExtendedBlockProto.poolId)
}
inline ::std::string* ExtendedBlockProto::mutable_poolid() {
  set_has_poolid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ExtendedBlockProto.poolId)
  return poolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ExtendedBlockProto::release_poolid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ExtendedBlockProto.poolId)
  clear_has_poolid();
  return poolid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ExtendedBlockProto::set_allocated_poolid(::std::string* poolid) {
  if (poolid != NULL) {
    set_has_poolid();
  } else {
    clear_has_poolid();
  }
  poolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), poolid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ExtendedBlockProto.poolId)
}

// required uint64 blockId = 2;
inline bool ExtendedBlockProto::has_blockid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ExtendedBlockProto::set_has_blockid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ExtendedBlockProto::clear_has_blockid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ExtendedBlockProto::clear_blockid() {
  blockid_ = GOOGLE_ULONGLONG(0);
  clear_has_blockid();
}
inline ::google::protobuf::uint64 ExtendedBlockProto::blockid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExtendedBlockProto.blockId)
  return blockid_;
}
inline void ExtendedBlockProto::set_blockid(::google::protobuf::uint64 value) {
  set_has_blockid();
  blockid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ExtendedBlockProto.blockId)
}

// required uint64 generationStamp = 3;
inline bool ExtendedBlockProto::has_generationstamp() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ExtendedBlockProto::set_has_generationstamp() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ExtendedBlockProto::clear_has_generationstamp() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ExtendedBlockProto::clear_generationstamp() {
  generationstamp_ = GOOGLE_ULONGLONG(0);
  clear_has_generationstamp();
}
inline ::google::protobuf::uint64 ExtendedBlockProto::generationstamp() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExtendedBlockProto.generationStamp)
  return generationstamp_;
}
inline void ExtendedBlockProto::set_generationstamp(::google::protobuf::uint64 value) {
  set_has_generationstamp();
  generationstamp_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ExtendedBlockProto.generationStamp)
}

// optional uint64 numBytes = 4 [default = 0];
inline bool ExtendedBlockProto::has_numbytes() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ExtendedBlockProto::set_has_numbytes() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ExtendedBlockProto::clear_has_numbytes() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ExtendedBlockProto::clear_numbytes() {
  numbytes_ = GOOGLE_ULONGLONG(0);
  clear_has_numbytes();
}
inline ::google::protobuf::uint64 ExtendedBlockProto::numbytes() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExtendedBlockProto.numBytes)
  return numbytes_;
}
inline void ExtendedBlockProto::set_numbytes(::google::protobuf::uint64 value) {
  set_has_numbytes();
  numbytes_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ExtendedBlockProto.numBytes)
}

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

// DatanodeIDProto

// required string ipAddr = 1;
inline bool DatanodeIDProto::has_ipaddr() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DatanodeIDProto::set_has_ipaddr() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DatanodeIDProto::clear_has_ipaddr() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DatanodeIDProto::clear_ipaddr() {
  ipaddr_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_ipaddr();
}
inline const ::std::string& DatanodeIDProto::ipaddr() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeIDProto.ipAddr)
  return ipaddr_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeIDProto::set_ipaddr(const ::std::string& value) {
  set_has_ipaddr();
  ipaddr_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeIDProto.ipAddr)
}
inline void DatanodeIDProto::set_ipaddr(const char* value) {
  set_has_ipaddr();
  ipaddr_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DatanodeIDProto.ipAddr)
}
inline void DatanodeIDProto::set_ipaddr(const char* value, size_t size) {
  set_has_ipaddr();
  ipaddr_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DatanodeIDProto.ipAddr)
}
inline ::std::string* DatanodeIDProto::mutable_ipaddr() {
  set_has_ipaddr();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeIDProto.ipAddr)
  return ipaddr_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DatanodeIDProto::release_ipaddr() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DatanodeIDProto.ipAddr)
  clear_has_ipaddr();
  return ipaddr_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeIDProto::set_allocated_ipaddr(::std::string* ipaddr) {
  if (ipaddr != NULL) {
    set_has_ipaddr();
  } else {
    clear_has_ipaddr();
  }
  ipaddr_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ipaddr);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DatanodeIDProto.ipAddr)
}

// required string hostName = 2;
inline bool DatanodeIDProto::has_hostname() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DatanodeIDProto::set_has_hostname() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DatanodeIDProto::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DatanodeIDProto::clear_hostname() {
  hostname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_hostname();
}
inline const ::std::string& DatanodeIDProto::hostname() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeIDProto.hostName)
  return hostname_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeIDProto::set_hostname(const ::std::string& value) {
  set_has_hostname();
  hostname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeIDProto.hostName)
}
inline void DatanodeIDProto::set_hostname(const char* value) {
  set_has_hostname();
  hostname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DatanodeIDProto.hostName)
}
inline void DatanodeIDProto::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  hostname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DatanodeIDProto.hostName)
}
inline ::std::string* DatanodeIDProto::mutable_hostname() {
  set_has_hostname();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeIDProto.hostName)
  return hostname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DatanodeIDProto::release_hostname() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DatanodeIDProto.hostName)
  clear_has_hostname();
  return hostname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeIDProto::set_allocated_hostname(::std::string* hostname) {
  if (hostname != NULL) {
    set_has_hostname();
  } else {
    clear_has_hostname();
  }
  hostname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), hostname);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DatanodeIDProto.hostName)
}

// required string datanodeUuid = 3;
inline bool DatanodeIDProto::has_datanodeuuid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DatanodeIDProto::set_has_datanodeuuid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DatanodeIDProto::clear_has_datanodeuuid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DatanodeIDProto::clear_datanodeuuid() {
  datanodeuuid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_datanodeuuid();
}
inline const ::std::string& DatanodeIDProto::datanodeuuid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeIDProto.datanodeUuid)
  return datanodeuuid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeIDProto::set_datanodeuuid(const ::std::string& value) {
  set_has_datanodeuuid();
  datanodeuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeIDProto.datanodeUuid)
}
inline void DatanodeIDProto::set_datanodeuuid(const char* value) {
  set_has_datanodeuuid();
  datanodeuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DatanodeIDProto.datanodeUuid)
}
inline void DatanodeIDProto::set_datanodeuuid(const char* value, size_t size) {
  set_has_datanodeuuid();
  datanodeuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DatanodeIDProto.datanodeUuid)
}
inline ::std::string* DatanodeIDProto::mutable_datanodeuuid() {
  set_has_datanodeuuid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeIDProto.datanodeUuid)
  return datanodeuuid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DatanodeIDProto::release_datanodeuuid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DatanodeIDProto.datanodeUuid)
  clear_has_datanodeuuid();
  return datanodeuuid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeIDProto::set_allocated_datanodeuuid(::std::string* datanodeuuid) {
  if (datanodeuuid != NULL) {
    set_has_datanodeuuid();
  } else {
    clear_has_datanodeuuid();
  }
  datanodeuuid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), datanodeuuid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DatanodeIDProto.datanodeUuid)
}

// required uint32 xferPort = 4;
inline bool DatanodeIDProto::has_xferport() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DatanodeIDProto::set_has_xferport() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DatanodeIDProto::clear_has_xferport() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DatanodeIDProto::clear_xferport() {
  xferport_ = 0u;
  clear_has_xferport();
}
inline ::google::protobuf::uint32 DatanodeIDProto::xferport() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeIDProto.xferPort)
  return xferport_;
}
inline void DatanodeIDProto::set_xferport(::google::protobuf::uint32 value) {
  set_has_xferport();
  xferport_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeIDProto.xferPort)
}

// required uint32 infoPort = 5;
inline bool DatanodeIDProto::has_infoport() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DatanodeIDProto::set_has_infoport() {
  _has_bits_[0] |= 0x00000010u;
}
inline void DatanodeIDProto::clear_has_infoport() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void DatanodeIDProto::clear_infoport() {
  infoport_ = 0u;
  clear_has_infoport();
}
inline ::google::protobuf::uint32 DatanodeIDProto::infoport() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeIDProto.infoPort)
  return infoport_;
}
inline void DatanodeIDProto::set_infoport(::google::protobuf::uint32 value) {
  set_has_infoport();
  infoport_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeIDProto.infoPort)
}

// required uint32 ipcPort = 6;
inline bool DatanodeIDProto::has_ipcport() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void DatanodeIDProto::set_has_ipcport() {
  _has_bits_[0] |= 0x00000020u;
}
inline void DatanodeIDProto::clear_has_ipcport() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void DatanodeIDProto::clear_ipcport() {
  ipcport_ = 0u;
  clear_has_ipcport();
}
inline ::google::protobuf::uint32 DatanodeIDProto::ipcport() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeIDProto.ipcPort)
  return ipcport_;
}
inline void DatanodeIDProto::set_ipcport(::google::protobuf::uint32 value) {
  set_has_ipcport();
  ipcport_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeIDProto.ipcPort)
}

// optional uint32 infoSecurePort = 7 [default = 0];
inline bool DatanodeIDProto::has_infosecureport() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void DatanodeIDProto::set_has_infosecureport() {
  _has_bits_[0] |= 0x00000040u;
}
inline void DatanodeIDProto::clear_has_infosecureport() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void DatanodeIDProto::clear_infosecureport() {
  infosecureport_ = 0u;
  clear_has_infosecureport();
}
inline ::google::protobuf::uint32 DatanodeIDProto::infosecureport() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeIDProto.infoSecurePort)
  return infosecureport_;
}
inline void DatanodeIDProto::set_infosecureport(::google::protobuf::uint32 value) {
  set_has_infosecureport();
  infosecureport_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeIDProto.infoSecurePort)
}

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

// DatanodeLocalInfoProto

// required string softwareVersion = 1;
inline bool DatanodeLocalInfoProto::has_softwareversion() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DatanodeLocalInfoProto::set_has_softwareversion() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DatanodeLocalInfoProto::clear_has_softwareversion() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DatanodeLocalInfoProto::clear_softwareversion() {
  softwareversion_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_softwareversion();
}
inline const ::std::string& DatanodeLocalInfoProto::softwareversion() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeLocalInfoProto.softwareVersion)
  return softwareversion_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeLocalInfoProto::set_softwareversion(const ::std::string& value) {
  set_has_softwareversion();
  softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeLocalInfoProto.softwareVersion)
}
inline void DatanodeLocalInfoProto::set_softwareversion(const char* value) {
  set_has_softwareversion();
  softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DatanodeLocalInfoProto.softwareVersion)
}
inline void DatanodeLocalInfoProto::set_softwareversion(const char* value, size_t size) {
  set_has_softwareversion();
  softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DatanodeLocalInfoProto.softwareVersion)
}
inline ::std::string* DatanodeLocalInfoProto::mutable_softwareversion() {
  set_has_softwareversion();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeLocalInfoProto.softwareVersion)
  return softwareversion_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DatanodeLocalInfoProto::release_softwareversion() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DatanodeLocalInfoProto.softwareVersion)
  clear_has_softwareversion();
  return softwareversion_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeLocalInfoProto::set_allocated_softwareversion(::std::string* softwareversion) {
  if (softwareversion != NULL) {
    set_has_softwareversion();
  } else {
    clear_has_softwareversion();
  }
  softwareversion_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), softwareversion);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DatanodeLocalInfoProto.softwareVersion)
}

// required string configVersion = 2;
inline bool DatanodeLocalInfoProto::has_configversion() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DatanodeLocalInfoProto::set_has_configversion() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DatanodeLocalInfoProto::clear_has_configversion() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DatanodeLocalInfoProto::clear_configversion() {
  configversion_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_configversion();
}
inline const ::std::string& DatanodeLocalInfoProto::configversion() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeLocalInfoProto.configVersion)
  return configversion_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeLocalInfoProto::set_configversion(const ::std::string& value) {
  set_has_configversion();
  configversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeLocalInfoProto.configVersion)
}
inline void DatanodeLocalInfoProto::set_configversion(const char* value) {
  set_has_configversion();
  configversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DatanodeLocalInfoProto.configVersion)
}
inline void DatanodeLocalInfoProto::set_configversion(const char* value, size_t size) {
  set_has_configversion();
  configversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DatanodeLocalInfoProto.configVersion)
}
inline ::std::string* DatanodeLocalInfoProto::mutable_configversion() {
  set_has_configversion();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeLocalInfoProto.configVersion)
  return configversion_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DatanodeLocalInfoProto::release_configversion() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DatanodeLocalInfoProto.configVersion)
  clear_has_configversion();
  return configversion_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeLocalInfoProto::set_allocated_configversion(::std::string* configversion) {
  if (configversion != NULL) {
    set_has_configversion();
  } else {
    clear_has_configversion();
  }
  configversion_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), configversion);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DatanodeLocalInfoProto.configVersion)
}

// required uint64 uptime = 3;
inline bool DatanodeLocalInfoProto::has_uptime() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DatanodeLocalInfoProto::set_has_uptime() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DatanodeLocalInfoProto::clear_has_uptime() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DatanodeLocalInfoProto::clear_uptime() {
  uptime_ = GOOGLE_ULONGLONG(0);
  clear_has_uptime();
}
inline ::google::protobuf::uint64 DatanodeLocalInfoProto::uptime() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeLocalInfoProto.uptime)
  return uptime_;
}
inline void DatanodeLocalInfoProto::set_uptime(::google::protobuf::uint64 value) {
  set_has_uptime();
  uptime_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeLocalInfoProto.uptime)
}

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

// DatanodeInfosProto

// repeated .hadoop.hdfs.DatanodeInfoProto datanodes = 1;
inline int DatanodeInfosProto::datanodes_size() const {
  return datanodes_.size();
}
inline void DatanodeInfosProto::clear_datanodes() {
  datanodes_.Clear();
}
inline const ::hadoop::hdfs::DatanodeInfoProto& DatanodeInfosProto::datanodes(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfosProto.datanodes)
  return datanodes_.Get(index);
}
inline ::hadoop::hdfs::DatanodeInfoProto* DatanodeInfosProto::mutable_datanodes(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeInfosProto.datanodes)
  return datanodes_.Mutable(index);
}
inline ::hadoop::hdfs::DatanodeInfoProto* DatanodeInfosProto::add_datanodes() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.DatanodeInfosProto.datanodes)
  return datanodes_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto >*
DatanodeInfosProto::mutable_datanodes() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.DatanodeInfosProto.datanodes)
  return &datanodes_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto >&
DatanodeInfosProto::datanodes() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.DatanodeInfosProto.datanodes)
  return datanodes_;
}

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

// DatanodeInfoProto

// required .hadoop.hdfs.DatanodeIDProto id = 1;
inline bool DatanodeInfoProto::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DatanodeInfoProto::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DatanodeInfoProto::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DatanodeInfoProto::clear_id() {
  if (id_ != NULL) id_->::hadoop::hdfs::DatanodeIDProto::Clear();
  clear_has_id();
}
inline const ::hadoop::hdfs::DatanodeIDProto& DatanodeInfoProto::id() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.id)
  return id_ != NULL ? *id_ : *default_instance_->id_;
}
inline ::hadoop::hdfs::DatanodeIDProto* DatanodeInfoProto::mutable_id() {
  set_has_id();
  if (id_ == NULL) {
    id_ = new ::hadoop::hdfs::DatanodeIDProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeInfoProto.id)
  return id_;
}
inline ::hadoop::hdfs::DatanodeIDProto* DatanodeInfoProto::release_id() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DatanodeInfoProto.id)
  clear_has_id();
  ::hadoop::hdfs::DatanodeIDProto* temp = id_;
  id_ = NULL;
  return temp;
}
inline void DatanodeInfoProto::set_allocated_id(::hadoop::hdfs::DatanodeIDProto* id) {
  delete id_;
  id_ = id;
  if (id) {
    set_has_id();
  } else {
    clear_has_id();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DatanodeInfoProto.id)
}

// optional uint64 capacity = 2 [default = 0];
inline bool DatanodeInfoProto::has_capacity() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DatanodeInfoProto::set_has_capacity() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DatanodeInfoProto::clear_has_capacity() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DatanodeInfoProto::clear_capacity() {
  capacity_ = GOOGLE_ULONGLONG(0);
  clear_has_capacity();
}
inline ::google::protobuf::uint64 DatanodeInfoProto::capacity() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.capacity)
  return capacity_;
}
inline void DatanodeInfoProto::set_capacity(::google::protobuf::uint64 value) {
  set_has_capacity();
  capacity_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.capacity)
}

// optional uint64 dfsUsed = 3 [default = 0];
inline bool DatanodeInfoProto::has_dfsused() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DatanodeInfoProto::set_has_dfsused() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DatanodeInfoProto::clear_has_dfsused() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DatanodeInfoProto::clear_dfsused() {
  dfsused_ = GOOGLE_ULONGLONG(0);
  clear_has_dfsused();
}
inline ::google::protobuf::uint64 DatanodeInfoProto::dfsused() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.dfsUsed)
  return dfsused_;
}
inline void DatanodeInfoProto::set_dfsused(::google::protobuf::uint64 value) {
  set_has_dfsused();
  dfsused_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.dfsUsed)
}

// optional uint64 remaining = 4 [default = 0];
inline bool DatanodeInfoProto::has_remaining() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DatanodeInfoProto::set_has_remaining() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DatanodeInfoProto::clear_has_remaining() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DatanodeInfoProto::clear_remaining() {
  remaining_ = GOOGLE_ULONGLONG(0);
  clear_has_remaining();
}
inline ::google::protobuf::uint64 DatanodeInfoProto::remaining() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.remaining)
  return remaining_;
}
inline void DatanodeInfoProto::set_remaining(::google::protobuf::uint64 value) {
  set_has_remaining();
  remaining_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.remaining)
}

// optional uint64 blockPoolUsed = 5 [default = 0];
inline bool DatanodeInfoProto::has_blockpoolused() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DatanodeInfoProto::set_has_blockpoolused() {
  _has_bits_[0] |= 0x00000010u;
}
inline void DatanodeInfoProto::clear_has_blockpoolused() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void DatanodeInfoProto::clear_blockpoolused() {
  blockpoolused_ = GOOGLE_ULONGLONG(0);
  clear_has_blockpoolused();
}
inline ::google::protobuf::uint64 DatanodeInfoProto::blockpoolused() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.blockPoolUsed)
  return blockpoolused_;
}
inline void DatanodeInfoProto::set_blockpoolused(::google::protobuf::uint64 value) {
  set_has_blockpoolused();
  blockpoolused_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.blockPoolUsed)
}

// optional uint64 lastUpdate = 6 [default = 0];
inline bool DatanodeInfoProto::has_lastupdate() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void DatanodeInfoProto::set_has_lastupdate() {
  _has_bits_[0] |= 0x00000020u;
}
inline void DatanodeInfoProto::clear_has_lastupdate() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void DatanodeInfoProto::clear_lastupdate() {
  lastupdate_ = GOOGLE_ULONGLONG(0);
  clear_has_lastupdate();
}
inline ::google::protobuf::uint64 DatanodeInfoProto::lastupdate() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.lastUpdate)
  return lastupdate_;
}
inline void DatanodeInfoProto::set_lastupdate(::google::protobuf::uint64 value) {
  set_has_lastupdate();
  lastupdate_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.lastUpdate)
}

// optional uint32 xceiverCount = 7 [default = 0];
inline bool DatanodeInfoProto::has_xceivercount() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void DatanodeInfoProto::set_has_xceivercount() {
  _has_bits_[0] |= 0x00000040u;
}
inline void DatanodeInfoProto::clear_has_xceivercount() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void DatanodeInfoProto::clear_xceivercount() {
  xceivercount_ = 0u;
  clear_has_xceivercount();
}
inline ::google::protobuf::uint32 DatanodeInfoProto::xceivercount() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.xceiverCount)
  return xceivercount_;
}
inline void DatanodeInfoProto::set_xceivercount(::google::protobuf::uint32 value) {
  set_has_xceivercount();
  xceivercount_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.xceiverCount)
}

// optional string location = 8;
inline bool DatanodeInfoProto::has_location() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void DatanodeInfoProto::set_has_location() {
  _has_bits_[0] |= 0x00000080u;
}
inline void DatanodeInfoProto::clear_has_location() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void DatanodeInfoProto::clear_location() {
  location_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_location();
}
inline const ::std::string& DatanodeInfoProto::location() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.location)
  return location_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeInfoProto::set_location(const ::std::string& value) {
  set_has_location();
  location_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.location)
}
inline void DatanodeInfoProto::set_location(const char* value) {
  set_has_location();
  location_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DatanodeInfoProto.location)
}
inline void DatanodeInfoProto::set_location(const char* value, size_t size) {
  set_has_location();
  location_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DatanodeInfoProto.location)
}
inline ::std::string* DatanodeInfoProto::mutable_location() {
  set_has_location();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeInfoProto.location)
  return location_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DatanodeInfoProto::release_location() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DatanodeInfoProto.location)
  clear_has_location();
  return location_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeInfoProto::set_allocated_location(::std::string* location) {
  if (location != NULL) {
    set_has_location();
  } else {
    clear_has_location();
  }
  location_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), location);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DatanodeInfoProto.location)
}

// optional .hadoop.hdfs.DatanodeInfoProto.AdminState adminState = 10 [default = NORMAL];
inline bool DatanodeInfoProto::has_adminstate() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void DatanodeInfoProto::set_has_adminstate() {
  _has_bits_[0] |= 0x00000100u;
}
inline void DatanodeInfoProto::clear_has_adminstate() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void DatanodeInfoProto::clear_adminstate() {
  adminstate_ = 0;
  clear_has_adminstate();
}
inline ::hadoop::hdfs::DatanodeInfoProto_AdminState DatanodeInfoProto::adminstate() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.adminState)
  return static_cast< ::hadoop::hdfs::DatanodeInfoProto_AdminState >(adminstate_);
}
inline void DatanodeInfoProto::set_adminstate(::hadoop::hdfs::DatanodeInfoProto_AdminState value) {
  assert(::hadoop::hdfs::DatanodeInfoProto_AdminState_IsValid(value));
  set_has_adminstate();
  adminstate_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.adminState)
}

// optional uint64 cacheCapacity = 11 [default = 0];
inline bool DatanodeInfoProto::has_cachecapacity() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void DatanodeInfoProto::set_has_cachecapacity() {
  _has_bits_[0] |= 0x00000200u;
}
inline void DatanodeInfoProto::clear_has_cachecapacity() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void DatanodeInfoProto::clear_cachecapacity() {
  cachecapacity_ = GOOGLE_ULONGLONG(0);
  clear_has_cachecapacity();
}
inline ::google::protobuf::uint64 DatanodeInfoProto::cachecapacity() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.cacheCapacity)
  return cachecapacity_;
}
inline void DatanodeInfoProto::set_cachecapacity(::google::protobuf::uint64 value) {
  set_has_cachecapacity();
  cachecapacity_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.cacheCapacity)
}

// optional uint64 cacheUsed = 12 [default = 0];
inline bool DatanodeInfoProto::has_cacheused() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void DatanodeInfoProto::set_has_cacheused() {
  _has_bits_[0] |= 0x00000400u;
}
inline void DatanodeInfoProto::clear_has_cacheused() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void DatanodeInfoProto::clear_cacheused() {
  cacheused_ = GOOGLE_ULONGLONG(0);
  clear_has_cacheused();
}
inline ::google::protobuf::uint64 DatanodeInfoProto::cacheused() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.cacheUsed)
  return cacheused_;
}
inline void DatanodeInfoProto::set_cacheused(::google::protobuf::uint64 value) {
  set_has_cacheused();
  cacheused_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.cacheUsed)
}

// optional uint64 lastUpdateMonotonic = 13 [default = 0];
inline bool DatanodeInfoProto::has_lastupdatemonotonic() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void DatanodeInfoProto::set_has_lastupdatemonotonic() {
  _has_bits_[0] |= 0x00000800u;
}
inline void DatanodeInfoProto::clear_has_lastupdatemonotonic() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void DatanodeInfoProto::clear_lastupdatemonotonic() {
  lastupdatemonotonic_ = GOOGLE_ULONGLONG(0);
  clear_has_lastupdatemonotonic();
}
inline ::google::protobuf::uint64 DatanodeInfoProto::lastupdatemonotonic() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeInfoProto.lastUpdateMonotonic)
  return lastupdatemonotonic_;
}
inline void DatanodeInfoProto::set_lastupdatemonotonic(::google::protobuf::uint64 value) {
  set_has_lastupdatemonotonic();
  lastupdatemonotonic_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeInfoProto.lastUpdateMonotonic)
}

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

// DatanodeStorageProto

// required string storageUuid = 1;
inline bool DatanodeStorageProto::has_storageuuid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DatanodeStorageProto::set_has_storageuuid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DatanodeStorageProto::clear_has_storageuuid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DatanodeStorageProto::clear_storageuuid() {
  storageuuid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_storageuuid();
}
inline const ::std::string& DatanodeStorageProto::storageuuid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeStorageProto.storageUuid)
  return storageuuid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeStorageProto::set_storageuuid(const ::std::string& value) {
  set_has_storageuuid();
  storageuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeStorageProto.storageUuid)
}
inline void DatanodeStorageProto::set_storageuuid(const char* value) {
  set_has_storageuuid();
  storageuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DatanodeStorageProto.storageUuid)
}
inline void DatanodeStorageProto::set_storageuuid(const char* value, size_t size) {
  set_has_storageuuid();
  storageuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DatanodeStorageProto.storageUuid)
}
inline ::std::string* DatanodeStorageProto::mutable_storageuuid() {
  set_has_storageuuid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DatanodeStorageProto.storageUuid)
  return storageuuid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DatanodeStorageProto::release_storageuuid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DatanodeStorageProto.storageUuid)
  clear_has_storageuuid();
  return storageuuid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DatanodeStorageProto::set_allocated_storageuuid(::std::string* storageuuid) {
  if (storageuuid != NULL) {
    set_has_storageuuid();
  } else {
    clear_has_storageuuid();
  }
  storageuuid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), storageuuid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DatanodeStorageProto.storageUuid)
}

// optional .hadoop.hdfs.DatanodeStorageProto.StorageState state = 2 [default = NORMAL];
inline bool DatanodeStorageProto::has_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DatanodeStorageProto::set_has_state() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DatanodeStorageProto::clear_has_state() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DatanodeStorageProto::clear_state() {
  state_ = 0;
  clear_has_state();
}
inline ::hadoop::hdfs::DatanodeStorageProto_StorageState DatanodeStorageProto::state() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeStorageProto.state)
  return static_cast< ::hadoop::hdfs::DatanodeStorageProto_StorageState >(state_);
}
inline void DatanodeStorageProto::set_state(::hadoop::hdfs::DatanodeStorageProto_StorageState value) {
  assert(::hadoop::hdfs::DatanodeStorageProto_StorageState_IsValid(value));
  set_has_state();
  state_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeStorageProto.state)
}

// optional .hadoop.hdfs.StorageTypeProto storageType = 3 [default = DISK];
inline bool DatanodeStorageProto::has_storagetype() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DatanodeStorageProto::set_has_storagetype() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DatanodeStorageProto::clear_has_storagetype() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DatanodeStorageProto::clear_storagetype() {
  storagetype_ = 1;
  clear_has_storagetype();
}
inline ::hadoop::hdfs::StorageTypeProto DatanodeStorageProto::storagetype() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DatanodeStorageProto.storageType)
  return static_cast< ::hadoop::hdfs::StorageTypeProto >(storagetype_);
}
inline void DatanodeStorageProto::set_storagetype(::hadoop::hdfs::StorageTypeProto value) {
  assert(::hadoop::hdfs::StorageTypeProto_IsValid(value));
  set_has_storagetype();
  storagetype_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DatanodeStorageProto.storageType)
}

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

// StorageReportProto

// required string storageUuid = 1 [deprecated = true];
inline bool StorageReportProto::has_storageuuid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StorageReportProto::set_has_storageuuid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StorageReportProto::clear_has_storageuuid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StorageReportProto::clear_storageuuid() {
  storageuuid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_storageuuid();
}
inline const ::std::string& StorageReportProto::storageuuid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageReportProto.storageUuid)
  return storageuuid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StorageReportProto::set_storageuuid(const ::std::string& value) {
  set_has_storageuuid();
  storageuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageReportProto.storageUuid)
}
inline void StorageReportProto::set_storageuuid(const char* value) {
  set_has_storageuuid();
  storageuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.StorageReportProto.storageUuid)
}
inline void StorageReportProto::set_storageuuid(const char* value, size_t size) {
  set_has_storageuuid();
  storageuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.StorageReportProto.storageUuid)
}
inline ::std::string* StorageReportProto::mutable_storageuuid() {
  set_has_storageuuid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.StorageReportProto.storageUuid)
  return storageuuid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StorageReportProto::release_storageuuid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.StorageReportProto.storageUuid)
  clear_has_storageuuid();
  return storageuuid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StorageReportProto::set_allocated_storageuuid(::std::string* storageuuid) {
  if (storageuuid != NULL) {
    set_has_storageuuid();
  } else {
    clear_has_storageuuid();
  }
  storageuuid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), storageuuid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.StorageReportProto.storageUuid)
}

// optional bool failed = 2 [default = false];
inline bool StorageReportProto::has_failed() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StorageReportProto::set_has_failed() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StorageReportProto::clear_has_failed() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StorageReportProto::clear_failed() {
  failed_ = false;
  clear_has_failed();
}
inline bool StorageReportProto::failed() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageReportProto.failed)
  return failed_;
}
inline void StorageReportProto::set_failed(bool value) {
  set_has_failed();
  failed_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageReportProto.failed)
}

// optional uint64 capacity = 3 [default = 0];
inline bool StorageReportProto::has_capacity() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void StorageReportProto::set_has_capacity() {
  _has_bits_[0] |= 0x00000004u;
}
inline void StorageReportProto::clear_has_capacity() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void StorageReportProto::clear_capacity() {
  capacity_ = GOOGLE_ULONGLONG(0);
  clear_has_capacity();
}
inline ::google::protobuf::uint64 StorageReportProto::capacity() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageReportProto.capacity)
  return capacity_;
}
inline void StorageReportProto::set_capacity(::google::protobuf::uint64 value) {
  set_has_capacity();
  capacity_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageReportProto.capacity)
}

// optional uint64 dfsUsed = 4 [default = 0];
inline bool StorageReportProto::has_dfsused() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void StorageReportProto::set_has_dfsused() {
  _has_bits_[0] |= 0x00000008u;
}
inline void StorageReportProto::clear_has_dfsused() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void StorageReportProto::clear_dfsused() {
  dfsused_ = GOOGLE_ULONGLONG(0);
  clear_has_dfsused();
}
inline ::google::protobuf::uint64 StorageReportProto::dfsused() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageReportProto.dfsUsed)
  return dfsused_;
}
inline void StorageReportProto::set_dfsused(::google::protobuf::uint64 value) {
  set_has_dfsused();
  dfsused_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageReportProto.dfsUsed)
}

// optional uint64 remaining = 5 [default = 0];
inline bool StorageReportProto::has_remaining() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void StorageReportProto::set_has_remaining() {
  _has_bits_[0] |= 0x00000010u;
}
inline void StorageReportProto::clear_has_remaining() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void StorageReportProto::clear_remaining() {
  remaining_ = GOOGLE_ULONGLONG(0);
  clear_has_remaining();
}
inline ::google::protobuf::uint64 StorageReportProto::remaining() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageReportProto.remaining)
  return remaining_;
}
inline void StorageReportProto::set_remaining(::google::protobuf::uint64 value) {
  set_has_remaining();
  remaining_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageReportProto.remaining)
}

// optional uint64 blockPoolUsed = 6 [default = 0];
inline bool StorageReportProto::has_blockpoolused() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void StorageReportProto::set_has_blockpoolused() {
  _has_bits_[0] |= 0x00000020u;
}
inline void StorageReportProto::clear_has_blockpoolused() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void StorageReportProto::clear_blockpoolused() {
  blockpoolused_ = GOOGLE_ULONGLONG(0);
  clear_has_blockpoolused();
}
inline ::google::protobuf::uint64 StorageReportProto::blockpoolused() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageReportProto.blockPoolUsed)
  return blockpoolused_;
}
inline void StorageReportProto::set_blockpoolused(::google::protobuf::uint64 value) {
  set_has_blockpoolused();
  blockpoolused_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageReportProto.blockPoolUsed)
}

// optional .hadoop.hdfs.DatanodeStorageProto storage = 7;
inline bool StorageReportProto::has_storage() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void StorageReportProto::set_has_storage() {
  _has_bits_[0] |= 0x00000040u;
}
inline void StorageReportProto::clear_has_storage() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void StorageReportProto::clear_storage() {
  if (storage_ != NULL) storage_->::hadoop::hdfs::DatanodeStorageProto::Clear();
  clear_has_storage();
}
inline const ::hadoop::hdfs::DatanodeStorageProto& StorageReportProto::storage() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageReportProto.storage)
  return storage_ != NULL ? *storage_ : *default_instance_->storage_;
}
inline ::hadoop::hdfs::DatanodeStorageProto* StorageReportProto::mutable_storage() {
  set_has_storage();
  if (storage_ == NULL) {
    storage_ = new ::hadoop::hdfs::DatanodeStorageProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.StorageReportProto.storage)
  return storage_;
}
inline ::hadoop::hdfs::DatanodeStorageProto* StorageReportProto::release_storage() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.StorageReportProto.storage)
  clear_has_storage();
  ::hadoop::hdfs::DatanodeStorageProto* temp = storage_;
  storage_ = NULL;
  return temp;
}
inline void StorageReportProto::set_allocated_storage(::hadoop::hdfs::DatanodeStorageProto* storage) {
  delete storage_;
  storage_ = storage;
  if (storage) {
    set_has_storage();
  } else {
    clear_has_storage();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.StorageReportProto.storage)
}

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

// ContentSummaryProto

// required uint64 length = 1;
inline bool ContentSummaryProto::has_length() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ContentSummaryProto::set_has_length() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ContentSummaryProto::clear_has_length() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ContentSummaryProto::clear_length() {
  length_ = GOOGLE_ULONGLONG(0);
  clear_has_length();
}
inline ::google::protobuf::uint64 ContentSummaryProto::length() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.length)
  return length_;
}
inline void ContentSummaryProto::set_length(::google::protobuf::uint64 value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.length)
}

// required uint64 fileCount = 2;
inline bool ContentSummaryProto::has_filecount() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ContentSummaryProto::set_has_filecount() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ContentSummaryProto::clear_has_filecount() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ContentSummaryProto::clear_filecount() {
  filecount_ = GOOGLE_ULONGLONG(0);
  clear_has_filecount();
}
inline ::google::protobuf::uint64 ContentSummaryProto::filecount() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.fileCount)
  return filecount_;
}
inline void ContentSummaryProto::set_filecount(::google::protobuf::uint64 value) {
  set_has_filecount();
  filecount_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.fileCount)
}

// required uint64 directoryCount = 3;
inline bool ContentSummaryProto::has_directorycount() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ContentSummaryProto::set_has_directorycount() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ContentSummaryProto::clear_has_directorycount() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ContentSummaryProto::clear_directorycount() {
  directorycount_ = GOOGLE_ULONGLONG(0);
  clear_has_directorycount();
}
inline ::google::protobuf::uint64 ContentSummaryProto::directorycount() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.directoryCount)
  return directorycount_;
}
inline void ContentSummaryProto::set_directorycount(::google::protobuf::uint64 value) {
  set_has_directorycount();
  directorycount_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.directoryCount)
}

// required uint64 quota = 4;
inline bool ContentSummaryProto::has_quota() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ContentSummaryProto::set_has_quota() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ContentSummaryProto::clear_has_quota() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ContentSummaryProto::clear_quota() {
  quota_ = GOOGLE_ULONGLONG(0);
  clear_has_quota();
}
inline ::google::protobuf::uint64 ContentSummaryProto::quota() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.quota)
  return quota_;
}
inline void ContentSummaryProto::set_quota(::google::protobuf::uint64 value) {
  set_has_quota();
  quota_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.quota)
}

// required uint64 spaceConsumed = 5;
inline bool ContentSummaryProto::has_spaceconsumed() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ContentSummaryProto::set_has_spaceconsumed() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ContentSummaryProto::clear_has_spaceconsumed() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ContentSummaryProto::clear_spaceconsumed() {
  spaceconsumed_ = GOOGLE_ULONGLONG(0);
  clear_has_spaceconsumed();
}
inline ::google::protobuf::uint64 ContentSummaryProto::spaceconsumed() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.spaceConsumed)
  return spaceconsumed_;
}
inline void ContentSummaryProto::set_spaceconsumed(::google::protobuf::uint64 value) {
  set_has_spaceconsumed();
  spaceconsumed_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.spaceConsumed)
}

// required uint64 spaceQuota = 6;
inline bool ContentSummaryProto::has_spacequota() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ContentSummaryProto::set_has_spacequota() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ContentSummaryProto::clear_has_spacequota() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ContentSummaryProto::clear_spacequota() {
  spacequota_ = GOOGLE_ULONGLONG(0);
  clear_has_spacequota();
}
inline ::google::protobuf::uint64 ContentSummaryProto::spacequota() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.spaceQuota)
  return spacequota_;
}
inline void ContentSummaryProto::set_spacequota(::google::protobuf::uint64 value) {
  set_has_spacequota();
  spacequota_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.spaceQuota)
}

// optional .hadoop.hdfs.StorageTypeQuotaInfosProto typeQuotaInfos = 7;
inline bool ContentSummaryProto::has_typequotainfos() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ContentSummaryProto::set_has_typequotainfos() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ContentSummaryProto::clear_has_typequotainfos() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ContentSummaryProto::clear_typequotainfos() {
  if (typequotainfos_ != NULL) typequotainfos_->::hadoop::hdfs::StorageTypeQuotaInfosProto::Clear();
  clear_has_typequotainfos();
}
inline const ::hadoop::hdfs::StorageTypeQuotaInfosProto& ContentSummaryProto::typequotainfos() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.typeQuotaInfos)
  return typequotainfos_ != NULL ? *typequotainfos_ : *default_instance_->typequotainfos_;
}
inline ::hadoop::hdfs::StorageTypeQuotaInfosProto* ContentSummaryProto::mutable_typequotainfos() {
  set_has_typequotainfos();
  if (typequotainfos_ == NULL) {
    typequotainfos_ = new ::hadoop::hdfs::StorageTypeQuotaInfosProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ContentSummaryProto.typeQuotaInfos)
  return typequotainfos_;
}
inline ::hadoop::hdfs::StorageTypeQuotaInfosProto* ContentSummaryProto::release_typequotainfos() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ContentSummaryProto.typeQuotaInfos)
  clear_has_typequotainfos();
  ::hadoop::hdfs::StorageTypeQuotaInfosProto* temp = typequotainfos_;
  typequotainfos_ = NULL;
  return temp;
}
inline void ContentSummaryProto::set_allocated_typequotainfos(::hadoop::hdfs::StorageTypeQuotaInfosProto* typequotainfos) {
  delete typequotainfos_;
  typequotainfos_ = typequotainfos;
  if (typequotainfos) {
    set_has_typequotainfos();
  } else {
    clear_has_typequotainfos();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ContentSummaryProto.typeQuotaInfos)
}

// optional uint64 snapshotLength = 8;
inline bool ContentSummaryProto::has_snapshotlength() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ContentSummaryProto::set_has_snapshotlength() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ContentSummaryProto::clear_has_snapshotlength() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ContentSummaryProto::clear_snapshotlength() {
  snapshotlength_ = GOOGLE_ULONGLONG(0);
  clear_has_snapshotlength();
}
inline ::google::protobuf::uint64 ContentSummaryProto::snapshotlength() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.snapshotLength)
  return snapshotlength_;
}
inline void ContentSummaryProto::set_snapshotlength(::google::protobuf::uint64 value) {
  set_has_snapshotlength();
  snapshotlength_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.snapshotLength)
}

// optional uint64 snapshotFileCount = 9;
inline bool ContentSummaryProto::has_snapshotfilecount() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ContentSummaryProto::set_has_snapshotfilecount() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ContentSummaryProto::clear_has_snapshotfilecount() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ContentSummaryProto::clear_snapshotfilecount() {
  snapshotfilecount_ = GOOGLE_ULONGLONG(0);
  clear_has_snapshotfilecount();
}
inline ::google::protobuf::uint64 ContentSummaryProto::snapshotfilecount() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.snapshotFileCount)
  return snapshotfilecount_;
}
inline void ContentSummaryProto::set_snapshotfilecount(::google::protobuf::uint64 value) {
  set_has_snapshotfilecount();
  snapshotfilecount_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.snapshotFileCount)
}

// optional uint64 snapshotDirectoryCount = 10;
inline bool ContentSummaryProto::has_snapshotdirectorycount() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ContentSummaryProto::set_has_snapshotdirectorycount() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ContentSummaryProto::clear_has_snapshotdirectorycount() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ContentSummaryProto::clear_snapshotdirectorycount() {
  snapshotdirectorycount_ = GOOGLE_ULONGLONG(0);
  clear_has_snapshotdirectorycount();
}
inline ::google::protobuf::uint64 ContentSummaryProto::snapshotdirectorycount() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.snapshotDirectoryCount)
  return snapshotdirectorycount_;
}
inline void ContentSummaryProto::set_snapshotdirectorycount(::google::protobuf::uint64 value) {
  set_has_snapshotdirectorycount();
  snapshotdirectorycount_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.snapshotDirectoryCount)
}

// optional uint64 snapshotSpaceConsumed = 11;
inline bool ContentSummaryProto::has_snapshotspaceconsumed() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ContentSummaryProto::set_has_snapshotspaceconsumed() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ContentSummaryProto::clear_has_snapshotspaceconsumed() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ContentSummaryProto::clear_snapshotspaceconsumed() {
  snapshotspaceconsumed_ = GOOGLE_ULONGLONG(0);
  clear_has_snapshotspaceconsumed();
}
inline ::google::protobuf::uint64 ContentSummaryProto::snapshotspaceconsumed() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.snapshotSpaceConsumed)
  return snapshotspaceconsumed_;
}
inline void ContentSummaryProto::set_snapshotspaceconsumed(::google::protobuf::uint64 value) {
  set_has_snapshotspaceconsumed();
  snapshotspaceconsumed_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.snapshotSpaceConsumed)
}

// optional string erasureCodingPolicy = 12;
inline bool ContentSummaryProto::has_erasurecodingpolicy() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ContentSummaryProto::set_has_erasurecodingpolicy() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ContentSummaryProto::clear_has_erasurecodingpolicy() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ContentSummaryProto::clear_erasurecodingpolicy() {
  erasurecodingpolicy_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_erasurecodingpolicy();
}
inline const ::std::string& ContentSummaryProto::erasurecodingpolicy() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ContentSummaryProto.erasureCodingPolicy)
  return erasurecodingpolicy_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ContentSummaryProto::set_erasurecodingpolicy(const ::std::string& value) {
  set_has_erasurecodingpolicy();
  erasurecodingpolicy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ContentSummaryProto.erasureCodingPolicy)
}
inline void ContentSummaryProto::set_erasurecodingpolicy(const char* value) {
  set_has_erasurecodingpolicy();
  erasurecodingpolicy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ContentSummaryProto.erasureCodingPolicy)
}
inline void ContentSummaryProto::set_erasurecodingpolicy(const char* value, size_t size) {
  set_has_erasurecodingpolicy();
  erasurecodingpolicy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ContentSummaryProto.erasureCodingPolicy)
}
inline ::std::string* ContentSummaryProto::mutable_erasurecodingpolicy() {
  set_has_erasurecodingpolicy();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ContentSummaryProto.erasureCodingPolicy)
  return erasurecodingpolicy_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ContentSummaryProto::release_erasurecodingpolicy() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ContentSummaryProto.erasureCodingPolicy)
  clear_has_erasurecodingpolicy();
  return erasurecodingpolicy_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ContentSummaryProto::set_allocated_erasurecodingpolicy(::std::string* erasurecodingpolicy) {
  if (erasurecodingpolicy != NULL) {
    set_has_erasurecodingpolicy();
  } else {
    clear_has_erasurecodingpolicy();
  }
  erasurecodingpolicy_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), erasurecodingpolicy);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ContentSummaryProto.erasureCodingPolicy)
}

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

// StorageTypeQuotaInfosProto

// repeated .hadoop.hdfs.StorageTypeQuotaInfoProto typeQuotaInfo = 1;
inline int StorageTypeQuotaInfosProto::typequotainfo_size() const {
  return typequotainfo_.size();
}
inline void StorageTypeQuotaInfosProto::clear_typequotainfo() {
  typequotainfo_.Clear();
}
inline const ::hadoop::hdfs::StorageTypeQuotaInfoProto& StorageTypeQuotaInfosProto::typequotainfo(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageTypeQuotaInfosProto.typeQuotaInfo)
  return typequotainfo_.Get(index);
}
inline ::hadoop::hdfs::StorageTypeQuotaInfoProto* StorageTypeQuotaInfosProto::mutable_typequotainfo(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.StorageTypeQuotaInfosProto.typeQuotaInfo)
  return typequotainfo_.Mutable(index);
}
inline ::hadoop::hdfs::StorageTypeQuotaInfoProto* StorageTypeQuotaInfosProto::add_typequotainfo() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.StorageTypeQuotaInfosProto.typeQuotaInfo)
  return typequotainfo_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::StorageTypeQuotaInfoProto >*
StorageTypeQuotaInfosProto::mutable_typequotainfo() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.StorageTypeQuotaInfosProto.typeQuotaInfo)
  return &typequotainfo_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::StorageTypeQuotaInfoProto >&
StorageTypeQuotaInfosProto::typequotainfo() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.StorageTypeQuotaInfosProto.typeQuotaInfo)
  return typequotainfo_;
}

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

// StorageTypeQuotaInfoProto

// required .hadoop.hdfs.StorageTypeProto type = 1;
inline bool StorageTypeQuotaInfoProto::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StorageTypeQuotaInfoProto::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StorageTypeQuotaInfoProto::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StorageTypeQuotaInfoProto::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::hadoop::hdfs::StorageTypeProto StorageTypeQuotaInfoProto::type() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageTypeQuotaInfoProto.type)
  return static_cast< ::hadoop::hdfs::StorageTypeProto >(type_);
}
inline void StorageTypeQuotaInfoProto::set_type(::hadoop::hdfs::StorageTypeProto value) {
  assert(::hadoop::hdfs::StorageTypeProto_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageTypeQuotaInfoProto.type)
}

// required uint64 quota = 2;
inline bool StorageTypeQuotaInfoProto::has_quota() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StorageTypeQuotaInfoProto::set_has_quota() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StorageTypeQuotaInfoProto::clear_has_quota() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StorageTypeQuotaInfoProto::clear_quota() {
  quota_ = GOOGLE_ULONGLONG(0);
  clear_has_quota();
}
inline ::google::protobuf::uint64 StorageTypeQuotaInfoProto::quota() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageTypeQuotaInfoProto.quota)
  return quota_;
}
inline void StorageTypeQuotaInfoProto::set_quota(::google::protobuf::uint64 value) {
  set_has_quota();
  quota_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageTypeQuotaInfoProto.quota)
}

// required uint64 consumed = 3;
inline bool StorageTypeQuotaInfoProto::has_consumed() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void StorageTypeQuotaInfoProto::set_has_consumed() {
  _has_bits_[0] |= 0x00000004u;
}
inline void StorageTypeQuotaInfoProto::clear_has_consumed() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void StorageTypeQuotaInfoProto::clear_consumed() {
  consumed_ = GOOGLE_ULONGLONG(0);
  clear_has_consumed();
}
inline ::google::protobuf::uint64 StorageTypeQuotaInfoProto::consumed() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageTypeQuotaInfoProto.consumed)
  return consumed_;
}
inline void StorageTypeQuotaInfoProto::set_consumed(::google::protobuf::uint64 value) {
  set_has_consumed();
  consumed_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageTypeQuotaInfoProto.consumed)
}

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

// CorruptFileBlocksProto

// repeated string files = 1;
inline int CorruptFileBlocksProto::files_size() const {
  return files_.size();
}
inline void CorruptFileBlocksProto::clear_files() {
  files_.Clear();
}
inline const ::std::string& CorruptFileBlocksProto::files(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CorruptFileBlocksProto.files)
  return files_.Get(index);
}
inline ::std::string* CorruptFileBlocksProto::mutable_files(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CorruptFileBlocksProto.files)
  return files_.Mutable(index);
}
inline void CorruptFileBlocksProto::set_files(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CorruptFileBlocksProto.files)
  files_.Mutable(index)->assign(value);
}
inline void CorruptFileBlocksProto::set_files(int index, const char* value) {
  files_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.CorruptFileBlocksProto.files)
}
inline void CorruptFileBlocksProto::set_files(int index, const char* value, size_t size) {
  files_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.CorruptFileBlocksProto.files)
}
inline ::std::string* CorruptFileBlocksProto::add_files() {
  // @@protoc_insertion_point(field_add_mutable:hadoop.hdfs.CorruptFileBlocksProto.files)
  return files_.Add();
}
inline void CorruptFileBlocksProto::add_files(const ::std::string& value) {
  files_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.CorruptFileBlocksProto.files)
}
inline void CorruptFileBlocksProto::add_files(const char* value) {
  files_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:hadoop.hdfs.CorruptFileBlocksProto.files)
}
inline void CorruptFileBlocksProto::add_files(const char* value, size_t size) {
  files_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:hadoop.hdfs.CorruptFileBlocksProto.files)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
CorruptFileBlocksProto::files() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.CorruptFileBlocksProto.files)
  return files_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
CorruptFileBlocksProto::mutable_files() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.CorruptFileBlocksProto.files)
  return &files_;
}

// required string cookie = 2;
inline bool CorruptFileBlocksProto::has_cookie() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CorruptFileBlocksProto::set_has_cookie() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CorruptFileBlocksProto::clear_has_cookie() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CorruptFileBlocksProto::clear_cookie() {
  cookie_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_cookie();
}
inline const ::std::string& CorruptFileBlocksProto::cookie() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CorruptFileBlocksProto.cookie)
  return cookie_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CorruptFileBlocksProto::set_cookie(const ::std::string& value) {
  set_has_cookie();
  cookie_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CorruptFileBlocksProto.cookie)
}
inline void CorruptFileBlocksProto::set_cookie(const char* value) {
  set_has_cookie();
  cookie_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.CorruptFileBlocksProto.cookie)
}
inline void CorruptFileBlocksProto::set_cookie(const char* value, size_t size) {
  set_has_cookie();
  cookie_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.CorruptFileBlocksProto.cookie)
}
inline ::std::string* CorruptFileBlocksProto::mutable_cookie() {
  set_has_cookie();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CorruptFileBlocksProto.cookie)
  return cookie_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CorruptFileBlocksProto::release_cookie() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.CorruptFileBlocksProto.cookie)
  clear_has_cookie();
  return cookie_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CorruptFileBlocksProto::set_allocated_cookie(::std::string* cookie) {
  if (cookie != NULL) {
    set_has_cookie();
  } else {
    clear_has_cookie();
  }
  cookie_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), cookie);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.CorruptFileBlocksProto.cookie)
}

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

// FsPermissionProto

// required uint32 perm = 1;
inline bool FsPermissionProto::has_perm() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FsPermissionProto::set_has_perm() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FsPermissionProto::clear_has_perm() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FsPermissionProto::clear_perm() {
  perm_ = 0u;
  clear_has_perm();
}
inline ::google::protobuf::uint32 FsPermissionProto::perm() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsPermissionProto.perm)
  return perm_;
}
inline void FsPermissionProto::set_perm(::google::protobuf::uint32 value) {
  set_has_perm();
  perm_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsPermissionProto.perm)
}

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

// StorageTypesProto

// repeated .hadoop.hdfs.StorageTypeProto storageTypes = 1;
inline int StorageTypesProto::storagetypes_size() const {
  return storagetypes_.size();
}
inline void StorageTypesProto::clear_storagetypes() {
  storagetypes_.Clear();
}
inline ::hadoop::hdfs::StorageTypeProto StorageTypesProto::storagetypes(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageTypesProto.storageTypes)
  return static_cast< ::hadoop::hdfs::StorageTypeProto >(storagetypes_.Get(index));
}
inline void StorageTypesProto::set_storagetypes(int index, ::hadoop::hdfs::StorageTypeProto value) {
  assert(::hadoop::hdfs::StorageTypeProto_IsValid(value));
  storagetypes_.Set(index, value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageTypesProto.storageTypes)
}
inline void StorageTypesProto::add_storagetypes(::hadoop::hdfs::StorageTypeProto value) {
  assert(::hadoop::hdfs::StorageTypeProto_IsValid(value));
  storagetypes_.Add(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.StorageTypesProto.storageTypes)
}
inline const ::google::protobuf::RepeatedField<int>&
StorageTypesProto::storagetypes() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.StorageTypesProto.storageTypes)
  return storagetypes_;
}
inline ::google::protobuf::RepeatedField<int>*
StorageTypesProto::mutable_storagetypes() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.StorageTypesProto.storageTypes)
  return &storagetypes_;
}

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

// BlockStoragePolicyProto

// required uint32 policyId = 1;
inline bool BlockStoragePolicyProto::has_policyid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlockStoragePolicyProto::set_has_policyid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BlockStoragePolicyProto::clear_has_policyid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BlockStoragePolicyProto::clear_policyid() {
  policyid_ = 0u;
  clear_has_policyid();
}
inline ::google::protobuf::uint32 BlockStoragePolicyProto::policyid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockStoragePolicyProto.policyId)
  return policyid_;
}
inline void BlockStoragePolicyProto::set_policyid(::google::protobuf::uint32 value) {
  set_has_policyid();
  policyid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockStoragePolicyProto.policyId)
}

// required string name = 2;
inline bool BlockStoragePolicyProto::has_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BlockStoragePolicyProto::set_has_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BlockStoragePolicyProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BlockStoragePolicyProto::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& BlockStoragePolicyProto::name() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockStoragePolicyProto.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BlockStoragePolicyProto::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockStoragePolicyProto.name)
}
inline void BlockStoragePolicyProto::set_name(const char* value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.BlockStoragePolicyProto.name)
}
inline void BlockStoragePolicyProto::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.BlockStoragePolicyProto.name)
}
inline ::std::string* BlockStoragePolicyProto::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlockStoragePolicyProto.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* BlockStoragePolicyProto::release_name() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.BlockStoragePolicyProto.name)
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BlockStoragePolicyProto::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.BlockStoragePolicyProto.name)
}

// required .hadoop.hdfs.StorageTypesProto creationPolicy = 3;
inline bool BlockStoragePolicyProto::has_creationpolicy() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BlockStoragePolicyProto::set_has_creationpolicy() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BlockStoragePolicyProto::clear_has_creationpolicy() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BlockStoragePolicyProto::clear_creationpolicy() {
  if (creationpolicy_ != NULL) creationpolicy_->::hadoop::hdfs::StorageTypesProto::Clear();
  clear_has_creationpolicy();
}
inline const ::hadoop::hdfs::StorageTypesProto& BlockStoragePolicyProto::creationpolicy() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockStoragePolicyProto.creationPolicy)
  return creationpolicy_ != NULL ? *creationpolicy_ : *default_instance_->creationpolicy_;
}
inline ::hadoop::hdfs::StorageTypesProto* BlockStoragePolicyProto::mutable_creationpolicy() {
  set_has_creationpolicy();
  if (creationpolicy_ == NULL) {
    creationpolicy_ = new ::hadoop::hdfs::StorageTypesProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlockStoragePolicyProto.creationPolicy)
  return creationpolicy_;
}
inline ::hadoop::hdfs::StorageTypesProto* BlockStoragePolicyProto::release_creationpolicy() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.BlockStoragePolicyProto.creationPolicy)
  clear_has_creationpolicy();
  ::hadoop::hdfs::StorageTypesProto* temp = creationpolicy_;
  creationpolicy_ = NULL;
  return temp;
}
inline void BlockStoragePolicyProto::set_allocated_creationpolicy(::hadoop::hdfs::StorageTypesProto* creationpolicy) {
  delete creationpolicy_;
  creationpolicy_ = creationpolicy;
  if (creationpolicy) {
    set_has_creationpolicy();
  } else {
    clear_has_creationpolicy();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.BlockStoragePolicyProto.creationPolicy)
}

// optional .hadoop.hdfs.StorageTypesProto creationFallbackPolicy = 4;
inline bool BlockStoragePolicyProto::has_creationfallbackpolicy() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BlockStoragePolicyProto::set_has_creationfallbackpolicy() {
  _has_bits_[0] |= 0x00000008u;
}
inline void BlockStoragePolicyProto::clear_has_creationfallbackpolicy() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void BlockStoragePolicyProto::clear_creationfallbackpolicy() {
  if (creationfallbackpolicy_ != NULL) creationfallbackpolicy_->::hadoop::hdfs::StorageTypesProto::Clear();
  clear_has_creationfallbackpolicy();
}
inline const ::hadoop::hdfs::StorageTypesProto& BlockStoragePolicyProto::creationfallbackpolicy() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockStoragePolicyProto.creationFallbackPolicy)
  return creationfallbackpolicy_ != NULL ? *creationfallbackpolicy_ : *default_instance_->creationfallbackpolicy_;
}
inline ::hadoop::hdfs::StorageTypesProto* BlockStoragePolicyProto::mutable_creationfallbackpolicy() {
  set_has_creationfallbackpolicy();
  if (creationfallbackpolicy_ == NULL) {
    creationfallbackpolicy_ = new ::hadoop::hdfs::StorageTypesProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlockStoragePolicyProto.creationFallbackPolicy)
  return creationfallbackpolicy_;
}
inline ::hadoop::hdfs::StorageTypesProto* BlockStoragePolicyProto::release_creationfallbackpolicy() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.BlockStoragePolicyProto.creationFallbackPolicy)
  clear_has_creationfallbackpolicy();
  ::hadoop::hdfs::StorageTypesProto* temp = creationfallbackpolicy_;
  creationfallbackpolicy_ = NULL;
  return temp;
}
inline void BlockStoragePolicyProto::set_allocated_creationfallbackpolicy(::hadoop::hdfs::StorageTypesProto* creationfallbackpolicy) {
  delete creationfallbackpolicy_;
  creationfallbackpolicy_ = creationfallbackpolicy;
  if (creationfallbackpolicy) {
    set_has_creationfallbackpolicy();
  } else {
    clear_has_creationfallbackpolicy();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.BlockStoragePolicyProto.creationFallbackPolicy)
}

// optional .hadoop.hdfs.StorageTypesProto replicationFallbackPolicy = 5;
inline bool BlockStoragePolicyProto::has_replicationfallbackpolicy() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BlockStoragePolicyProto::set_has_replicationfallbackpolicy() {
  _has_bits_[0] |= 0x00000010u;
}
inline void BlockStoragePolicyProto::clear_has_replicationfallbackpolicy() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void BlockStoragePolicyProto::clear_replicationfallbackpolicy() {
  if (replicationfallbackpolicy_ != NULL) replicationfallbackpolicy_->::hadoop::hdfs::StorageTypesProto::Clear();
  clear_has_replicationfallbackpolicy();
}
inline const ::hadoop::hdfs::StorageTypesProto& BlockStoragePolicyProto::replicationfallbackpolicy() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockStoragePolicyProto.replicationFallbackPolicy)
  return replicationfallbackpolicy_ != NULL ? *replicationfallbackpolicy_ : *default_instance_->replicationfallbackpolicy_;
}
inline ::hadoop::hdfs::StorageTypesProto* BlockStoragePolicyProto::mutable_replicationfallbackpolicy() {
  set_has_replicationfallbackpolicy();
  if (replicationfallbackpolicy_ == NULL) {
    replicationfallbackpolicy_ = new ::hadoop::hdfs::StorageTypesProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlockStoragePolicyProto.replicationFallbackPolicy)
  return replicationfallbackpolicy_;
}
inline ::hadoop::hdfs::StorageTypesProto* BlockStoragePolicyProto::release_replicationfallbackpolicy() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.BlockStoragePolicyProto.replicationFallbackPolicy)
  clear_has_replicationfallbackpolicy();
  ::hadoop::hdfs::StorageTypesProto* temp = replicationfallbackpolicy_;
  replicationfallbackpolicy_ = NULL;
  return temp;
}
inline void BlockStoragePolicyProto::set_allocated_replicationfallbackpolicy(::hadoop::hdfs::StorageTypesProto* replicationfallbackpolicy) {
  delete replicationfallbackpolicy_;
  replicationfallbackpolicy_ = replicationfallbackpolicy;
  if (replicationfallbackpolicy) {
    set_has_replicationfallbackpolicy();
  } else {
    clear_has_replicationfallbackpolicy();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.BlockStoragePolicyProto.replicationFallbackPolicy)
}

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

// StorageUuidsProto

// repeated string storageUuids = 1;
inline int StorageUuidsProto::storageuuids_size() const {
  return storageuuids_.size();
}
inline void StorageUuidsProto::clear_storageuuids() {
  storageuuids_.Clear();
}
inline const ::std::string& StorageUuidsProto::storageuuids(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageUuidsProto.storageUuids)
  return storageuuids_.Get(index);
}
inline ::std::string* StorageUuidsProto::mutable_storageuuids(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.StorageUuidsProto.storageUuids)
  return storageuuids_.Mutable(index);
}
inline void StorageUuidsProto::set_storageuuids(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageUuidsProto.storageUuids)
  storageuuids_.Mutable(index)->assign(value);
}
inline void StorageUuidsProto::set_storageuuids(int index, const char* value) {
  storageuuids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.StorageUuidsProto.storageUuids)
}
inline void StorageUuidsProto::set_storageuuids(int index, const char* value, size_t size) {
  storageuuids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.StorageUuidsProto.storageUuids)
}
inline ::std::string* StorageUuidsProto::add_storageuuids() {
  // @@protoc_insertion_point(field_add_mutable:hadoop.hdfs.StorageUuidsProto.storageUuids)
  return storageuuids_.Add();
}
inline void StorageUuidsProto::add_storageuuids(const ::std::string& value) {
  storageuuids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.StorageUuidsProto.storageUuids)
}
inline void StorageUuidsProto::add_storageuuids(const char* value) {
  storageuuids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:hadoop.hdfs.StorageUuidsProto.storageUuids)
}
inline void StorageUuidsProto::add_storageuuids(const char* value, size_t size) {
  storageuuids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:hadoop.hdfs.StorageUuidsProto.storageUuids)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
StorageUuidsProto::storageuuids() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.StorageUuidsProto.storageUuids)
  return storageuuids_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
StorageUuidsProto::mutable_storageuuids() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.StorageUuidsProto.storageUuids)
  return &storageuuids_;
}

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

// LocatedBlockProto

// required .hadoop.hdfs.ExtendedBlockProto b = 1;
inline bool LocatedBlockProto::has_b() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LocatedBlockProto::set_has_b() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LocatedBlockProto::clear_has_b() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LocatedBlockProto::clear_b() {
  if (b_ != NULL) b_->::hadoop::hdfs::ExtendedBlockProto::Clear();
  clear_has_b();
}
inline const ::hadoop::hdfs::ExtendedBlockProto& LocatedBlockProto::b() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.b)
  return b_ != NULL ? *b_ : *default_instance_->b_;
}
inline ::hadoop::hdfs::ExtendedBlockProto* LocatedBlockProto::mutable_b() {
  set_has_b();
  if (b_ == NULL) {
    b_ = new ::hadoop::hdfs::ExtendedBlockProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlockProto.b)
  return b_;
}
inline ::hadoop::hdfs::ExtendedBlockProto* LocatedBlockProto::release_b() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.LocatedBlockProto.b)
  clear_has_b();
  ::hadoop::hdfs::ExtendedBlockProto* temp = b_;
  b_ = NULL;
  return temp;
}
inline void LocatedBlockProto::set_allocated_b(::hadoop::hdfs::ExtendedBlockProto* b) {
  delete b_;
  b_ = b;
  if (b) {
    set_has_b();
  } else {
    clear_has_b();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.LocatedBlockProto.b)
}

// required uint64 offset = 2;
inline bool LocatedBlockProto::has_offset() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LocatedBlockProto::set_has_offset() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LocatedBlockProto::clear_has_offset() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LocatedBlockProto::clear_offset() {
  offset_ = GOOGLE_ULONGLONG(0);
  clear_has_offset();
}
inline ::google::protobuf::uint64 LocatedBlockProto::offset() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.offset)
  return offset_;
}
inline void LocatedBlockProto::set_offset(::google::protobuf::uint64 value) {
  set_has_offset();
  offset_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlockProto.offset)
}

// repeated .hadoop.hdfs.DatanodeInfoProto locs = 3;
inline int LocatedBlockProto::locs_size() const {
  return locs_.size();
}
inline void LocatedBlockProto::clear_locs() {
  locs_.Clear();
}
inline const ::hadoop::hdfs::DatanodeInfoProto& LocatedBlockProto::locs(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.locs)
  return locs_.Get(index);
}
inline ::hadoop::hdfs::DatanodeInfoProto* LocatedBlockProto::mutable_locs(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlockProto.locs)
  return locs_.Mutable(index);
}
inline ::hadoop::hdfs::DatanodeInfoProto* LocatedBlockProto::add_locs() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.LocatedBlockProto.locs)
  return locs_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto >*
LocatedBlockProto::mutable_locs() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.LocatedBlockProto.locs)
  return &locs_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::DatanodeInfoProto >&
LocatedBlockProto::locs() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.LocatedBlockProto.locs)
  return locs_;
}

// required bool corrupt = 4;
inline bool LocatedBlockProto::has_corrupt() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LocatedBlockProto::set_has_corrupt() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LocatedBlockProto::clear_has_corrupt() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LocatedBlockProto::clear_corrupt() {
  corrupt_ = false;
  clear_has_corrupt();
}
inline bool LocatedBlockProto::corrupt() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.corrupt)
  return corrupt_;
}
inline void LocatedBlockProto::set_corrupt(bool value) {
  set_has_corrupt();
  corrupt_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlockProto.corrupt)
}

// required .hadoop.common.TokenProto blockToken = 5;
inline bool LocatedBlockProto::has_blocktoken() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LocatedBlockProto::set_has_blocktoken() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LocatedBlockProto::clear_has_blocktoken() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LocatedBlockProto::clear_blocktoken() {
  if (blocktoken_ != NULL) blocktoken_->::hadoop::common::TokenProto::Clear();
  clear_has_blocktoken();
}
inline const ::hadoop::common::TokenProto& LocatedBlockProto::blocktoken() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.blockToken)
  return blocktoken_ != NULL ? *blocktoken_ : *default_instance_->blocktoken_;
}
inline ::hadoop::common::TokenProto* LocatedBlockProto::mutable_blocktoken() {
  set_has_blocktoken();
  if (blocktoken_ == NULL) {
    blocktoken_ = new ::hadoop::common::TokenProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlockProto.blockToken)
  return blocktoken_;
}
inline ::hadoop::common::TokenProto* LocatedBlockProto::release_blocktoken() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.LocatedBlockProto.blockToken)
  clear_has_blocktoken();
  ::hadoop::common::TokenProto* temp = blocktoken_;
  blocktoken_ = NULL;
  return temp;
}
inline void LocatedBlockProto::set_allocated_blocktoken(::hadoop::common::TokenProto* blocktoken) {
  delete blocktoken_;
  blocktoken_ = blocktoken;
  if (blocktoken) {
    set_has_blocktoken();
  } else {
    clear_has_blocktoken();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.LocatedBlockProto.blockToken)
}

// repeated bool isCached = 6 [packed = true];
inline int LocatedBlockProto::iscached_size() const {
  return iscached_.size();
}
inline void LocatedBlockProto::clear_iscached() {
  iscached_.Clear();
}
inline bool LocatedBlockProto::iscached(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.isCached)
  return iscached_.Get(index);
}
inline void LocatedBlockProto::set_iscached(int index, bool value) {
  iscached_.Set(index, value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlockProto.isCached)
}
inline void LocatedBlockProto::add_iscached(bool value) {
  iscached_.Add(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.LocatedBlockProto.isCached)
}
inline const ::google::protobuf::RepeatedField< bool >&
LocatedBlockProto::iscached() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.LocatedBlockProto.isCached)
  return iscached_;
}
inline ::google::protobuf::RepeatedField< bool >*
LocatedBlockProto::mutable_iscached() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.LocatedBlockProto.isCached)
  return &iscached_;
}

// repeated .hadoop.hdfs.StorageTypeProto storageTypes = 7;
inline int LocatedBlockProto::storagetypes_size() const {
  return storagetypes_.size();
}
inline void LocatedBlockProto::clear_storagetypes() {
  storagetypes_.Clear();
}
inline ::hadoop::hdfs::StorageTypeProto LocatedBlockProto::storagetypes(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.storageTypes)
  return static_cast< ::hadoop::hdfs::StorageTypeProto >(storagetypes_.Get(index));
}
inline void LocatedBlockProto::set_storagetypes(int index, ::hadoop::hdfs::StorageTypeProto value) {
  assert(::hadoop::hdfs::StorageTypeProto_IsValid(value));
  storagetypes_.Set(index, value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlockProto.storageTypes)
}
inline void LocatedBlockProto::add_storagetypes(::hadoop::hdfs::StorageTypeProto value) {
  assert(::hadoop::hdfs::StorageTypeProto_IsValid(value));
  storagetypes_.Add(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.LocatedBlockProto.storageTypes)
}
inline const ::google::protobuf::RepeatedField<int>&
LocatedBlockProto::storagetypes() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.LocatedBlockProto.storageTypes)
  return storagetypes_;
}
inline ::google::protobuf::RepeatedField<int>*
LocatedBlockProto::mutable_storagetypes() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.LocatedBlockProto.storageTypes)
  return &storagetypes_;
}

// repeated string storageIDs = 8;
inline int LocatedBlockProto::storageids_size() const {
  return storageids_.size();
}
inline void LocatedBlockProto::clear_storageids() {
  storageids_.Clear();
}
inline const ::std::string& LocatedBlockProto::storageids(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.storageIDs)
  return storageids_.Get(index);
}
inline ::std::string* LocatedBlockProto::mutable_storageids(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlockProto.storageIDs)
  return storageids_.Mutable(index);
}
inline void LocatedBlockProto::set_storageids(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlockProto.storageIDs)
  storageids_.Mutable(index)->assign(value);
}
inline void LocatedBlockProto::set_storageids(int index, const char* value) {
  storageids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.LocatedBlockProto.storageIDs)
}
inline void LocatedBlockProto::set_storageids(int index, const char* value, size_t size) {
  storageids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.LocatedBlockProto.storageIDs)
}
inline ::std::string* LocatedBlockProto::add_storageids() {
  // @@protoc_insertion_point(field_add_mutable:hadoop.hdfs.LocatedBlockProto.storageIDs)
  return storageids_.Add();
}
inline void LocatedBlockProto::add_storageids(const ::std::string& value) {
  storageids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.LocatedBlockProto.storageIDs)
}
inline void LocatedBlockProto::add_storageids(const char* value) {
  storageids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:hadoop.hdfs.LocatedBlockProto.storageIDs)
}
inline void LocatedBlockProto::add_storageids(const char* value, size_t size) {
  storageids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:hadoop.hdfs.LocatedBlockProto.storageIDs)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LocatedBlockProto::storageids() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.LocatedBlockProto.storageIDs)
  return storageids_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LocatedBlockProto::mutable_storageids() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.LocatedBlockProto.storageIDs)
  return &storageids_;
}

// optional bytes blockIndices = 9;
inline bool LocatedBlockProto::has_blockindices() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void LocatedBlockProto::set_has_blockindices() {
  _has_bits_[0] |= 0x00000100u;
}
inline void LocatedBlockProto::clear_has_blockindices() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void LocatedBlockProto::clear_blockindices() {
  blockindices_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_blockindices();
}
inline const ::std::string& LocatedBlockProto::blockindices() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.blockIndices)
  return blockindices_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LocatedBlockProto::set_blockindices(const ::std::string& value) {
  set_has_blockindices();
  blockindices_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlockProto.blockIndices)
}
inline void LocatedBlockProto::set_blockindices(const char* value) {
  set_has_blockindices();
  blockindices_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.LocatedBlockProto.blockIndices)
}
inline void LocatedBlockProto::set_blockindices(const void* value, size_t size) {
  set_has_blockindices();
  blockindices_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.LocatedBlockProto.blockIndices)
}
inline ::std::string* LocatedBlockProto::mutable_blockindices() {
  set_has_blockindices();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlockProto.blockIndices)
  return blockindices_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LocatedBlockProto::release_blockindices() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.LocatedBlockProto.blockIndices)
  clear_has_blockindices();
  return blockindices_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LocatedBlockProto::set_allocated_blockindices(::std::string* blockindices) {
  if (blockindices != NULL) {
    set_has_blockindices();
  } else {
    clear_has_blockindices();
  }
  blockindices_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockindices);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.LocatedBlockProto.blockIndices)
}

// repeated .hadoop.common.TokenProto blockTokens = 10;
inline int LocatedBlockProto::blocktokens_size() const {
  return blocktokens_.size();
}
inline void LocatedBlockProto::clear_blocktokens() {
  blocktokens_.Clear();
}
inline const ::hadoop::common::TokenProto& LocatedBlockProto::blocktokens(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlockProto.blockTokens)
  return blocktokens_.Get(index);
}
inline ::hadoop::common::TokenProto* LocatedBlockProto::mutable_blocktokens(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlockProto.blockTokens)
  return blocktokens_.Mutable(index);
}
inline ::hadoop::common::TokenProto* LocatedBlockProto::add_blocktokens() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.LocatedBlockProto.blockTokens)
  return blocktokens_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::common::TokenProto >*
LocatedBlockProto::mutable_blocktokens() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.LocatedBlockProto.blockTokens)
  return &blocktokens_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::common::TokenProto >&
LocatedBlockProto::blocktokens() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.LocatedBlockProto.blockTokens)
  return blocktokens_;
}

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

// DataEncryptionKeyProto

// required uint32 keyId = 1;
inline bool DataEncryptionKeyProto::has_keyid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DataEncryptionKeyProto::set_has_keyid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DataEncryptionKeyProto::clear_has_keyid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DataEncryptionKeyProto::clear_keyid() {
  keyid_ = 0u;
  clear_has_keyid();
}
inline ::google::protobuf::uint32 DataEncryptionKeyProto::keyid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DataEncryptionKeyProto.keyId)
  return keyid_;
}
inline void DataEncryptionKeyProto::set_keyid(::google::protobuf::uint32 value) {
  set_has_keyid();
  keyid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DataEncryptionKeyProto.keyId)
}

// required string blockPoolId = 2;
inline bool DataEncryptionKeyProto::has_blockpoolid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DataEncryptionKeyProto::set_has_blockpoolid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DataEncryptionKeyProto::clear_has_blockpoolid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DataEncryptionKeyProto::clear_blockpoolid() {
  blockpoolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_blockpoolid();
}
inline const ::std::string& DataEncryptionKeyProto::blockpoolid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DataEncryptionKeyProto.blockPoolId)
  return blockpoolid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataEncryptionKeyProto::set_blockpoolid(const ::std::string& value) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DataEncryptionKeyProto.blockPoolId)
}
inline void DataEncryptionKeyProto::set_blockpoolid(const char* value) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DataEncryptionKeyProto.blockPoolId)
}
inline void DataEncryptionKeyProto::set_blockpoolid(const char* value, size_t size) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DataEncryptionKeyProto.blockPoolId)
}
inline ::std::string* DataEncryptionKeyProto::mutable_blockpoolid() {
  set_has_blockpoolid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DataEncryptionKeyProto.blockPoolId)
  return blockpoolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataEncryptionKeyProto::release_blockpoolid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DataEncryptionKeyProto.blockPoolId)
  clear_has_blockpoolid();
  return blockpoolid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataEncryptionKeyProto::set_allocated_blockpoolid(::std::string* blockpoolid) {
  if (blockpoolid != NULL) {
    set_has_blockpoolid();
  } else {
    clear_has_blockpoolid();
  }
  blockpoolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockpoolid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DataEncryptionKeyProto.blockPoolId)
}

// required bytes nonce = 3;
inline bool DataEncryptionKeyProto::has_nonce() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DataEncryptionKeyProto::set_has_nonce() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DataEncryptionKeyProto::clear_has_nonce() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DataEncryptionKeyProto::clear_nonce() {
  nonce_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_nonce();
}
inline const ::std::string& DataEncryptionKeyProto::nonce() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DataEncryptionKeyProto.nonce)
  return nonce_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataEncryptionKeyProto::set_nonce(const ::std::string& value) {
  set_has_nonce();
  nonce_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DataEncryptionKeyProto.nonce)
}
inline void DataEncryptionKeyProto::set_nonce(const char* value) {
  set_has_nonce();
  nonce_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DataEncryptionKeyProto.nonce)
}
inline void DataEncryptionKeyProto::set_nonce(const void* value, size_t size) {
  set_has_nonce();
  nonce_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DataEncryptionKeyProto.nonce)
}
inline ::std::string* DataEncryptionKeyProto::mutable_nonce() {
  set_has_nonce();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DataEncryptionKeyProto.nonce)
  return nonce_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataEncryptionKeyProto::release_nonce() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DataEncryptionKeyProto.nonce)
  clear_has_nonce();
  return nonce_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataEncryptionKeyProto::set_allocated_nonce(::std::string* nonce) {
  if (nonce != NULL) {
    set_has_nonce();
  } else {
    clear_has_nonce();
  }
  nonce_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), nonce);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DataEncryptionKeyProto.nonce)
}

// required bytes encryptionKey = 4;
inline bool DataEncryptionKeyProto::has_encryptionkey() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DataEncryptionKeyProto::set_has_encryptionkey() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DataEncryptionKeyProto::clear_has_encryptionkey() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DataEncryptionKeyProto::clear_encryptionkey() {
  encryptionkey_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_encryptionkey();
}
inline const ::std::string& DataEncryptionKeyProto::encryptionkey() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DataEncryptionKeyProto.encryptionKey)
  return encryptionkey_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataEncryptionKeyProto::set_encryptionkey(const ::std::string& value) {
  set_has_encryptionkey();
  encryptionkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DataEncryptionKeyProto.encryptionKey)
}
inline void DataEncryptionKeyProto::set_encryptionkey(const char* value) {
  set_has_encryptionkey();
  encryptionkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DataEncryptionKeyProto.encryptionKey)
}
inline void DataEncryptionKeyProto::set_encryptionkey(const void* value, size_t size) {
  set_has_encryptionkey();
  encryptionkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DataEncryptionKeyProto.encryptionKey)
}
inline ::std::string* DataEncryptionKeyProto::mutable_encryptionkey() {
  set_has_encryptionkey();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DataEncryptionKeyProto.encryptionKey)
  return encryptionkey_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataEncryptionKeyProto::release_encryptionkey() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DataEncryptionKeyProto.encryptionKey)
  clear_has_encryptionkey();
  return encryptionkey_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataEncryptionKeyProto::set_allocated_encryptionkey(::std::string* encryptionkey) {
  if (encryptionkey != NULL) {
    set_has_encryptionkey();
  } else {
    clear_has_encryptionkey();
  }
  encryptionkey_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), encryptionkey);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DataEncryptionKeyProto.encryptionKey)
}

// required uint64 expiryDate = 5;
inline bool DataEncryptionKeyProto::has_expirydate() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DataEncryptionKeyProto::set_has_expirydate() {
  _has_bits_[0] |= 0x00000010u;
}
inline void DataEncryptionKeyProto::clear_has_expirydate() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void DataEncryptionKeyProto::clear_expirydate() {
  expirydate_ = GOOGLE_ULONGLONG(0);
  clear_has_expirydate();
}
inline ::google::protobuf::uint64 DataEncryptionKeyProto::expirydate() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DataEncryptionKeyProto.expiryDate)
  return expirydate_;
}
inline void DataEncryptionKeyProto::set_expirydate(::google::protobuf::uint64 value) {
  set_has_expirydate();
  expirydate_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DataEncryptionKeyProto.expiryDate)
}

// optional string encryptionAlgorithm = 6;
inline bool DataEncryptionKeyProto::has_encryptionalgorithm() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void DataEncryptionKeyProto::set_has_encryptionalgorithm() {
  _has_bits_[0] |= 0x00000020u;
}
inline void DataEncryptionKeyProto::clear_has_encryptionalgorithm() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void DataEncryptionKeyProto::clear_encryptionalgorithm() {
  encryptionalgorithm_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_encryptionalgorithm();
}
inline const ::std::string& DataEncryptionKeyProto::encryptionalgorithm() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DataEncryptionKeyProto.encryptionAlgorithm)
  return encryptionalgorithm_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataEncryptionKeyProto::set_encryptionalgorithm(const ::std::string& value) {
  set_has_encryptionalgorithm();
  encryptionalgorithm_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DataEncryptionKeyProto.encryptionAlgorithm)
}
inline void DataEncryptionKeyProto::set_encryptionalgorithm(const char* value) {
  set_has_encryptionalgorithm();
  encryptionalgorithm_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.DataEncryptionKeyProto.encryptionAlgorithm)
}
inline void DataEncryptionKeyProto::set_encryptionalgorithm(const char* value, size_t size) {
  set_has_encryptionalgorithm();
  encryptionalgorithm_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.DataEncryptionKeyProto.encryptionAlgorithm)
}
inline ::std::string* DataEncryptionKeyProto::mutable_encryptionalgorithm() {
  set_has_encryptionalgorithm();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DataEncryptionKeyProto.encryptionAlgorithm)
  return encryptionalgorithm_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DataEncryptionKeyProto::release_encryptionalgorithm() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.DataEncryptionKeyProto.encryptionAlgorithm)
  clear_has_encryptionalgorithm();
  return encryptionalgorithm_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DataEncryptionKeyProto::set_allocated_encryptionalgorithm(::std::string* encryptionalgorithm) {
  if (encryptionalgorithm != NULL) {
    set_has_encryptionalgorithm();
  } else {
    clear_has_encryptionalgorithm();
  }
  encryptionalgorithm_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), encryptionalgorithm);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.DataEncryptionKeyProto.encryptionAlgorithm)
}

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

// FileEncryptionInfoProto

// required .hadoop.hdfs.CipherSuiteProto suite = 1;
inline bool FileEncryptionInfoProto::has_suite() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FileEncryptionInfoProto::set_has_suite() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FileEncryptionInfoProto::clear_has_suite() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FileEncryptionInfoProto::clear_suite() {
  suite_ = 1;
  clear_has_suite();
}
inline ::hadoop::hdfs::CipherSuiteProto FileEncryptionInfoProto::suite() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FileEncryptionInfoProto.suite)
  return static_cast< ::hadoop::hdfs::CipherSuiteProto >(suite_);
}
inline void FileEncryptionInfoProto::set_suite(::hadoop::hdfs::CipherSuiteProto value) {
  assert(::hadoop::hdfs::CipherSuiteProto_IsValid(value));
  set_has_suite();
  suite_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FileEncryptionInfoProto.suite)
}

// required .hadoop.hdfs.CryptoProtocolVersionProto cryptoProtocolVersion = 2;
inline bool FileEncryptionInfoProto::has_cryptoprotocolversion() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FileEncryptionInfoProto::set_has_cryptoprotocolversion() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FileEncryptionInfoProto::clear_has_cryptoprotocolversion() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FileEncryptionInfoProto::clear_cryptoprotocolversion() {
  cryptoprotocolversion_ = 1;
  clear_has_cryptoprotocolversion();
}
inline ::hadoop::hdfs::CryptoProtocolVersionProto FileEncryptionInfoProto::cryptoprotocolversion() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FileEncryptionInfoProto.cryptoProtocolVersion)
  return static_cast< ::hadoop::hdfs::CryptoProtocolVersionProto >(cryptoprotocolversion_);
}
inline void FileEncryptionInfoProto::set_cryptoprotocolversion(::hadoop::hdfs::CryptoProtocolVersionProto value) {
  assert(::hadoop::hdfs::CryptoProtocolVersionProto_IsValid(value));
  set_has_cryptoprotocolversion();
  cryptoprotocolversion_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FileEncryptionInfoProto.cryptoProtocolVersion)
}

// required bytes key = 3;
inline bool FileEncryptionInfoProto::has_key() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FileEncryptionInfoProto::set_has_key() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FileEncryptionInfoProto::clear_has_key() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FileEncryptionInfoProto::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
inline const ::std::string& FileEncryptionInfoProto::key() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FileEncryptionInfoProto.key)
  return key_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileEncryptionInfoProto::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FileEncryptionInfoProto.key)
}
inline void FileEncryptionInfoProto::set_key(const char* value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.FileEncryptionInfoProto.key)
}
inline void FileEncryptionInfoProto::set_key(const void* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.FileEncryptionInfoProto.key)
}
inline ::std::string* FileEncryptionInfoProto::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.FileEncryptionInfoProto.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* FileEncryptionInfoProto::release_key() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.FileEncryptionInfoProto.key)
  clear_has_key();
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileEncryptionInfoProto::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.FileEncryptionInfoProto.key)
}

// required bytes iv = 4;
inline bool FileEncryptionInfoProto::has_iv() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FileEncryptionInfoProto::set_has_iv() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FileEncryptionInfoProto::clear_has_iv() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FileEncryptionInfoProto::clear_iv() {
  iv_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_iv();
}
inline const ::std::string& FileEncryptionInfoProto::iv() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FileEncryptionInfoProto.iv)
  return iv_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileEncryptionInfoProto::set_iv(const ::std::string& value) {
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FileEncryptionInfoProto.iv)
}
inline void FileEncryptionInfoProto::set_iv(const char* value) {
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.FileEncryptionInfoProto.iv)
}
inline void FileEncryptionInfoProto::set_iv(const void* value, size_t size) {
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.FileEncryptionInfoProto.iv)
}
inline ::std::string* FileEncryptionInfoProto::mutable_iv() {
  set_has_iv();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.FileEncryptionInfoProto.iv)
  return iv_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* FileEncryptionInfoProto::release_iv() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.FileEncryptionInfoProto.iv)
  clear_has_iv();
  return iv_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileEncryptionInfoProto::set_allocated_iv(::std::string* iv) {
  if (iv != NULL) {
    set_has_iv();
  } else {
    clear_has_iv();
  }
  iv_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), iv);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.FileEncryptionInfoProto.iv)
}

// required string keyName = 5;
inline bool FileEncryptionInfoProto::has_keyname() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void FileEncryptionInfoProto::set_has_keyname() {
  _has_bits_[0] |= 0x00000010u;
}
inline void FileEncryptionInfoProto::clear_has_keyname() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void FileEncryptionInfoProto::clear_keyname() {
  keyname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_keyname();
}
inline const ::std::string& FileEncryptionInfoProto::keyname() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FileEncryptionInfoProto.keyName)
  return keyname_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileEncryptionInfoProto::set_keyname(const ::std::string& value) {
  set_has_keyname();
  keyname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FileEncryptionInfoProto.keyName)
}
inline void FileEncryptionInfoProto::set_keyname(const char* value) {
  set_has_keyname();
  keyname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.FileEncryptionInfoProto.keyName)
}
inline void FileEncryptionInfoProto::set_keyname(const char* value, size_t size) {
  set_has_keyname();
  keyname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.FileEncryptionInfoProto.keyName)
}
inline ::std::string* FileEncryptionInfoProto::mutable_keyname() {
  set_has_keyname();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.FileEncryptionInfoProto.keyName)
  return keyname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* FileEncryptionInfoProto::release_keyname() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.FileEncryptionInfoProto.keyName)
  clear_has_keyname();
  return keyname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileEncryptionInfoProto::set_allocated_keyname(::std::string* keyname) {
  if (keyname != NULL) {
    set_has_keyname();
  } else {
    clear_has_keyname();
  }
  keyname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), keyname);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.FileEncryptionInfoProto.keyName)
}

// required string ezKeyVersionName = 6;
inline bool FileEncryptionInfoProto::has_ezkeyversionname() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void FileEncryptionInfoProto::set_has_ezkeyversionname() {
  _has_bits_[0] |= 0x00000020u;
}
inline void FileEncryptionInfoProto::clear_has_ezkeyversionname() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void FileEncryptionInfoProto::clear_ezkeyversionname() {
  ezkeyversionname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_ezkeyversionname();
}
inline const ::std::string& FileEncryptionInfoProto::ezkeyversionname() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FileEncryptionInfoProto.ezKeyVersionName)
  return ezkeyversionname_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileEncryptionInfoProto::set_ezkeyversionname(const ::std::string& value) {
  set_has_ezkeyversionname();
  ezkeyversionname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FileEncryptionInfoProto.ezKeyVersionName)
}
inline void FileEncryptionInfoProto::set_ezkeyversionname(const char* value) {
  set_has_ezkeyversionname();
  ezkeyversionname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.FileEncryptionInfoProto.ezKeyVersionName)
}
inline void FileEncryptionInfoProto::set_ezkeyversionname(const char* value, size_t size) {
  set_has_ezkeyversionname();
  ezkeyversionname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.FileEncryptionInfoProto.ezKeyVersionName)
}
inline ::std::string* FileEncryptionInfoProto::mutable_ezkeyversionname() {
  set_has_ezkeyversionname();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.FileEncryptionInfoProto.ezKeyVersionName)
  return ezkeyversionname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* FileEncryptionInfoProto::release_ezkeyversionname() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.FileEncryptionInfoProto.ezKeyVersionName)
  clear_has_ezkeyversionname();
  return ezkeyversionname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileEncryptionInfoProto::set_allocated_ezkeyversionname(::std::string* ezkeyversionname) {
  if (ezkeyversionname != NULL) {
    set_has_ezkeyversionname();
  } else {
    clear_has_ezkeyversionname();
  }
  ezkeyversionname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ezkeyversionname);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.FileEncryptionInfoProto.ezKeyVersionName)
}

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

// PerFileEncryptionInfoProto

// required bytes key = 1;
inline bool PerFileEncryptionInfoProto::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PerFileEncryptionInfoProto::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PerFileEncryptionInfoProto::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PerFileEncryptionInfoProto::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
inline const ::std::string& PerFileEncryptionInfoProto::key() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.PerFileEncryptionInfoProto.key)
  return key_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PerFileEncryptionInfoProto::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.PerFileEncryptionInfoProto.key)
}
inline void PerFileEncryptionInfoProto::set_key(const char* value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.PerFileEncryptionInfoProto.key)
}
inline void PerFileEncryptionInfoProto::set_key(const void* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.PerFileEncryptionInfoProto.key)
}
inline ::std::string* PerFileEncryptionInfoProto::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.PerFileEncryptionInfoProto.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PerFileEncryptionInfoProto::release_key() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.PerFileEncryptionInfoProto.key)
  clear_has_key();
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PerFileEncryptionInfoProto::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.PerFileEncryptionInfoProto.key)
}

// required bytes iv = 2;
inline bool PerFileEncryptionInfoProto::has_iv() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PerFileEncryptionInfoProto::set_has_iv() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PerFileEncryptionInfoProto::clear_has_iv() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PerFileEncryptionInfoProto::clear_iv() {
  iv_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_iv();
}
inline const ::std::string& PerFileEncryptionInfoProto::iv() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.PerFileEncryptionInfoProto.iv)
  return iv_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PerFileEncryptionInfoProto::set_iv(const ::std::string& value) {
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.PerFileEncryptionInfoProto.iv)
}
inline void PerFileEncryptionInfoProto::set_iv(const char* value) {
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.PerFileEncryptionInfoProto.iv)
}
inline void PerFileEncryptionInfoProto::set_iv(const void* value, size_t size) {
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.PerFileEncryptionInfoProto.iv)
}
inline ::std::string* PerFileEncryptionInfoProto::mutable_iv() {
  set_has_iv();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.PerFileEncryptionInfoProto.iv)
  return iv_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PerFileEncryptionInfoProto::release_iv() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.PerFileEncryptionInfoProto.iv)
  clear_has_iv();
  return iv_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PerFileEncryptionInfoProto::set_allocated_iv(::std::string* iv) {
  if (iv != NULL) {
    set_has_iv();
  } else {
    clear_has_iv();
  }
  iv_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), iv);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.PerFileEncryptionInfoProto.iv)
}

// required string ezKeyVersionName = 3;
inline bool PerFileEncryptionInfoProto::has_ezkeyversionname() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PerFileEncryptionInfoProto::set_has_ezkeyversionname() {
  _has_bits_[0] |= 0x00000004u;
}
inline void PerFileEncryptionInfoProto::clear_has_ezkeyversionname() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void PerFileEncryptionInfoProto::clear_ezkeyversionname() {
  ezkeyversionname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_ezkeyversionname();
}
inline const ::std::string& PerFileEncryptionInfoProto::ezkeyversionname() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.PerFileEncryptionInfoProto.ezKeyVersionName)
  return ezkeyversionname_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PerFileEncryptionInfoProto::set_ezkeyversionname(const ::std::string& value) {
  set_has_ezkeyversionname();
  ezkeyversionname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.PerFileEncryptionInfoProto.ezKeyVersionName)
}
inline void PerFileEncryptionInfoProto::set_ezkeyversionname(const char* value) {
  set_has_ezkeyversionname();
  ezkeyversionname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.PerFileEncryptionInfoProto.ezKeyVersionName)
}
inline void PerFileEncryptionInfoProto::set_ezkeyversionname(const char* value, size_t size) {
  set_has_ezkeyversionname();
  ezkeyversionname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.PerFileEncryptionInfoProto.ezKeyVersionName)
}
inline ::std::string* PerFileEncryptionInfoProto::mutable_ezkeyversionname() {
  set_has_ezkeyversionname();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.PerFileEncryptionInfoProto.ezKeyVersionName)
  return ezkeyversionname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PerFileEncryptionInfoProto::release_ezkeyversionname() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.PerFileEncryptionInfoProto.ezKeyVersionName)
  clear_has_ezkeyversionname();
  return ezkeyversionname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PerFileEncryptionInfoProto::set_allocated_ezkeyversionname(::std::string* ezkeyversionname) {
  if (ezkeyversionname != NULL) {
    set_has_ezkeyversionname();
  } else {
    clear_has_ezkeyversionname();
  }
  ezkeyversionname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ezkeyversionname);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.PerFileEncryptionInfoProto.ezKeyVersionName)
}

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

// ZoneEncryptionInfoProto

// required .hadoop.hdfs.CipherSuiteProto suite = 1;
inline bool ZoneEncryptionInfoProto::has_suite() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ZoneEncryptionInfoProto::set_has_suite() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ZoneEncryptionInfoProto::clear_has_suite() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ZoneEncryptionInfoProto::clear_suite() {
  suite_ = 1;
  clear_has_suite();
}
inline ::hadoop::hdfs::CipherSuiteProto ZoneEncryptionInfoProto::suite() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ZoneEncryptionInfoProto.suite)
  return static_cast< ::hadoop::hdfs::CipherSuiteProto >(suite_);
}
inline void ZoneEncryptionInfoProto::set_suite(::hadoop::hdfs::CipherSuiteProto value) {
  assert(::hadoop::hdfs::CipherSuiteProto_IsValid(value));
  set_has_suite();
  suite_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ZoneEncryptionInfoProto.suite)
}

// required .hadoop.hdfs.CryptoProtocolVersionProto cryptoProtocolVersion = 2;
inline bool ZoneEncryptionInfoProto::has_cryptoprotocolversion() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ZoneEncryptionInfoProto::set_has_cryptoprotocolversion() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ZoneEncryptionInfoProto::clear_has_cryptoprotocolversion() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ZoneEncryptionInfoProto::clear_cryptoprotocolversion() {
  cryptoprotocolversion_ = 1;
  clear_has_cryptoprotocolversion();
}
inline ::hadoop::hdfs::CryptoProtocolVersionProto ZoneEncryptionInfoProto::cryptoprotocolversion() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ZoneEncryptionInfoProto.cryptoProtocolVersion)
  return static_cast< ::hadoop::hdfs::CryptoProtocolVersionProto >(cryptoprotocolversion_);
}
inline void ZoneEncryptionInfoProto::set_cryptoprotocolversion(::hadoop::hdfs::CryptoProtocolVersionProto value) {
  assert(::hadoop::hdfs::CryptoProtocolVersionProto_IsValid(value));
  set_has_cryptoprotocolversion();
  cryptoprotocolversion_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ZoneEncryptionInfoProto.cryptoProtocolVersion)
}

// required string keyName = 3;
inline bool ZoneEncryptionInfoProto::has_keyname() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ZoneEncryptionInfoProto::set_has_keyname() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ZoneEncryptionInfoProto::clear_has_keyname() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ZoneEncryptionInfoProto::clear_keyname() {
  keyname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_keyname();
}
inline const ::std::string& ZoneEncryptionInfoProto::keyname() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ZoneEncryptionInfoProto.keyName)
  return keyname_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ZoneEncryptionInfoProto::set_keyname(const ::std::string& value) {
  set_has_keyname();
  keyname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ZoneEncryptionInfoProto.keyName)
}
inline void ZoneEncryptionInfoProto::set_keyname(const char* value) {
  set_has_keyname();
  keyname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ZoneEncryptionInfoProto.keyName)
}
inline void ZoneEncryptionInfoProto::set_keyname(const char* value, size_t size) {
  set_has_keyname();
  keyname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ZoneEncryptionInfoProto.keyName)
}
inline ::std::string* ZoneEncryptionInfoProto::mutable_keyname() {
  set_has_keyname();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ZoneEncryptionInfoProto.keyName)
  return keyname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ZoneEncryptionInfoProto::release_keyname() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ZoneEncryptionInfoProto.keyName)
  clear_has_keyname();
  return keyname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ZoneEncryptionInfoProto::set_allocated_keyname(::std::string* keyname) {
  if (keyname != NULL) {
    set_has_keyname();
  } else {
    clear_has_keyname();
  }
  keyname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), keyname);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ZoneEncryptionInfoProto.keyName)
}

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

// CipherOptionProto

// required .hadoop.hdfs.CipherSuiteProto suite = 1;
inline bool CipherOptionProto::has_suite() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CipherOptionProto::set_has_suite() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CipherOptionProto::clear_has_suite() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CipherOptionProto::clear_suite() {
  suite_ = 1;
  clear_has_suite();
}
inline ::hadoop::hdfs::CipherSuiteProto CipherOptionProto::suite() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CipherOptionProto.suite)
  return static_cast< ::hadoop::hdfs::CipherSuiteProto >(suite_);
}
inline void CipherOptionProto::set_suite(::hadoop::hdfs::CipherSuiteProto value) {
  assert(::hadoop::hdfs::CipherSuiteProto_IsValid(value));
  set_has_suite();
  suite_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CipherOptionProto.suite)
}

// optional bytes inKey = 2;
inline bool CipherOptionProto::has_inkey() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CipherOptionProto::set_has_inkey() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CipherOptionProto::clear_has_inkey() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CipherOptionProto::clear_inkey() {
  inkey_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_inkey();
}
inline const ::std::string& CipherOptionProto::inkey() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CipherOptionProto.inKey)
  return inkey_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CipherOptionProto::set_inkey(const ::std::string& value) {
  set_has_inkey();
  inkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CipherOptionProto.inKey)
}
inline void CipherOptionProto::set_inkey(const char* value) {
  set_has_inkey();
  inkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.CipherOptionProto.inKey)
}
inline void CipherOptionProto::set_inkey(const void* value, size_t size) {
  set_has_inkey();
  inkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.CipherOptionProto.inKey)
}
inline ::std::string* CipherOptionProto::mutable_inkey() {
  set_has_inkey();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CipherOptionProto.inKey)
  return inkey_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CipherOptionProto::release_inkey() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.CipherOptionProto.inKey)
  clear_has_inkey();
  return inkey_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CipherOptionProto::set_allocated_inkey(::std::string* inkey) {
  if (inkey != NULL) {
    set_has_inkey();
  } else {
    clear_has_inkey();
  }
  inkey_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), inkey);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.CipherOptionProto.inKey)
}

// optional bytes inIv = 3;
inline bool CipherOptionProto::has_iniv() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CipherOptionProto::set_has_iniv() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CipherOptionProto::clear_has_iniv() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CipherOptionProto::clear_iniv() {
  iniv_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_iniv();
}
inline const ::std::string& CipherOptionProto::iniv() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CipherOptionProto.inIv)
  return iniv_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CipherOptionProto::set_iniv(const ::std::string& value) {
  set_has_iniv();
  iniv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CipherOptionProto.inIv)
}
inline void CipherOptionProto::set_iniv(const char* value) {
  set_has_iniv();
  iniv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.CipherOptionProto.inIv)
}
inline void CipherOptionProto::set_iniv(const void* value, size_t size) {
  set_has_iniv();
  iniv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.CipherOptionProto.inIv)
}
inline ::std::string* CipherOptionProto::mutable_iniv() {
  set_has_iniv();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CipherOptionProto.inIv)
  return iniv_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CipherOptionProto::release_iniv() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.CipherOptionProto.inIv)
  clear_has_iniv();
  return iniv_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CipherOptionProto::set_allocated_iniv(::std::string* iniv) {
  if (iniv != NULL) {
    set_has_iniv();
  } else {
    clear_has_iniv();
  }
  iniv_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), iniv);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.CipherOptionProto.inIv)
}

// optional bytes outKey = 4;
inline bool CipherOptionProto::has_outkey() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CipherOptionProto::set_has_outkey() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CipherOptionProto::clear_has_outkey() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CipherOptionProto::clear_outkey() {
  outkey_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_outkey();
}
inline const ::std::string& CipherOptionProto::outkey() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CipherOptionProto.outKey)
  return outkey_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CipherOptionProto::set_outkey(const ::std::string& value) {
  set_has_outkey();
  outkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CipherOptionProto.outKey)
}
inline void CipherOptionProto::set_outkey(const char* value) {
  set_has_outkey();
  outkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.CipherOptionProto.outKey)
}
inline void CipherOptionProto::set_outkey(const void* value, size_t size) {
  set_has_outkey();
  outkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.CipherOptionProto.outKey)
}
inline ::std::string* CipherOptionProto::mutable_outkey() {
  set_has_outkey();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CipherOptionProto.outKey)
  return outkey_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CipherOptionProto::release_outkey() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.CipherOptionProto.outKey)
  clear_has_outkey();
  return outkey_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CipherOptionProto::set_allocated_outkey(::std::string* outkey) {
  if (outkey != NULL) {
    set_has_outkey();
  } else {
    clear_has_outkey();
  }
  outkey_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), outkey);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.CipherOptionProto.outKey)
}

// optional bytes outIv = 5;
inline bool CipherOptionProto::has_outiv() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CipherOptionProto::set_has_outiv() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CipherOptionProto::clear_has_outiv() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CipherOptionProto::clear_outiv() {
  outiv_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_outiv();
}
inline const ::std::string& CipherOptionProto::outiv() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CipherOptionProto.outIv)
  return outiv_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CipherOptionProto::set_outiv(const ::std::string& value) {
  set_has_outiv();
  outiv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CipherOptionProto.outIv)
}
inline void CipherOptionProto::set_outiv(const char* value) {
  set_has_outiv();
  outiv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.CipherOptionProto.outIv)
}
inline void CipherOptionProto::set_outiv(const void* value, size_t size) {
  set_has_outiv();
  outiv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.CipherOptionProto.outIv)
}
inline ::std::string* CipherOptionProto::mutable_outiv() {
  set_has_outiv();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CipherOptionProto.outIv)
  return outiv_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CipherOptionProto::release_outiv() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.CipherOptionProto.outIv)
  clear_has_outiv();
  return outiv_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CipherOptionProto::set_allocated_outiv(::std::string* outiv) {
  if (outiv != NULL) {
    set_has_outiv();
  } else {
    clear_has_outiv();
  }
  outiv_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), outiv);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.CipherOptionProto.outIv)
}

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

// LocatedBlocksProto

// required uint64 fileLength = 1;
inline bool LocatedBlocksProto::has_filelength() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LocatedBlocksProto::set_has_filelength() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LocatedBlocksProto::clear_has_filelength() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LocatedBlocksProto::clear_filelength() {
  filelength_ = GOOGLE_ULONGLONG(0);
  clear_has_filelength();
}
inline ::google::protobuf::uint64 LocatedBlocksProto::filelength() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlocksProto.fileLength)
  return filelength_;
}
inline void LocatedBlocksProto::set_filelength(::google::protobuf::uint64 value) {
  set_has_filelength();
  filelength_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlocksProto.fileLength)
}

// repeated .hadoop.hdfs.LocatedBlockProto blocks = 2;
inline int LocatedBlocksProto::blocks_size() const {
  return blocks_.size();
}
inline void LocatedBlocksProto::clear_blocks() {
  blocks_.Clear();
}
inline const ::hadoop::hdfs::LocatedBlockProto& LocatedBlocksProto::blocks(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlocksProto.blocks)
  return blocks_.Get(index);
}
inline ::hadoop::hdfs::LocatedBlockProto* LocatedBlocksProto::mutable_blocks(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlocksProto.blocks)
  return blocks_.Mutable(index);
}
inline ::hadoop::hdfs::LocatedBlockProto* LocatedBlocksProto::add_blocks() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.LocatedBlocksProto.blocks)
  return blocks_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::LocatedBlockProto >*
LocatedBlocksProto::mutable_blocks() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.LocatedBlocksProto.blocks)
  return &blocks_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::LocatedBlockProto >&
LocatedBlocksProto::blocks() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.LocatedBlocksProto.blocks)
  return blocks_;
}

// required bool underConstruction = 3;
inline bool LocatedBlocksProto::has_underconstruction() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LocatedBlocksProto::set_has_underconstruction() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LocatedBlocksProto::clear_has_underconstruction() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LocatedBlocksProto::clear_underconstruction() {
  underconstruction_ = false;
  clear_has_underconstruction();
}
inline bool LocatedBlocksProto::underconstruction() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlocksProto.underConstruction)
  return underconstruction_;
}
inline void LocatedBlocksProto::set_underconstruction(bool value) {
  set_has_underconstruction();
  underconstruction_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlocksProto.underConstruction)
}

// optional .hadoop.hdfs.LocatedBlockProto lastBlock = 4;
inline bool LocatedBlocksProto::has_lastblock() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LocatedBlocksProto::set_has_lastblock() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LocatedBlocksProto::clear_has_lastblock() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LocatedBlocksProto::clear_lastblock() {
  if (lastblock_ != NULL) lastblock_->::hadoop::hdfs::LocatedBlockProto::Clear();
  clear_has_lastblock();
}
inline const ::hadoop::hdfs::LocatedBlockProto& LocatedBlocksProto::lastblock() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlocksProto.lastBlock)
  return lastblock_ != NULL ? *lastblock_ : *default_instance_->lastblock_;
}
inline ::hadoop::hdfs::LocatedBlockProto* LocatedBlocksProto::mutable_lastblock() {
  set_has_lastblock();
  if (lastblock_ == NULL) {
    lastblock_ = new ::hadoop::hdfs::LocatedBlockProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlocksProto.lastBlock)
  return lastblock_;
}
inline ::hadoop::hdfs::LocatedBlockProto* LocatedBlocksProto::release_lastblock() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.LocatedBlocksProto.lastBlock)
  clear_has_lastblock();
  ::hadoop::hdfs::LocatedBlockProto* temp = lastblock_;
  lastblock_ = NULL;
  return temp;
}
inline void LocatedBlocksProto::set_allocated_lastblock(::hadoop::hdfs::LocatedBlockProto* lastblock) {
  delete lastblock_;
  lastblock_ = lastblock;
  if (lastblock) {
    set_has_lastblock();
  } else {
    clear_has_lastblock();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.LocatedBlocksProto.lastBlock)
}

// required bool isLastBlockComplete = 5;
inline bool LocatedBlocksProto::has_islastblockcomplete() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LocatedBlocksProto::set_has_islastblockcomplete() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LocatedBlocksProto::clear_has_islastblockcomplete() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LocatedBlocksProto::clear_islastblockcomplete() {
  islastblockcomplete_ = false;
  clear_has_islastblockcomplete();
}
inline bool LocatedBlocksProto::islastblockcomplete() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlocksProto.isLastBlockComplete)
  return islastblockcomplete_;
}
inline void LocatedBlocksProto::set_islastblockcomplete(bool value) {
  set_has_islastblockcomplete();
  islastblockcomplete_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.LocatedBlocksProto.isLastBlockComplete)
}

// optional .hadoop.hdfs.FileEncryptionInfoProto fileEncryptionInfo = 6;
inline bool LocatedBlocksProto::has_fileencryptioninfo() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void LocatedBlocksProto::set_has_fileencryptioninfo() {
  _has_bits_[0] |= 0x00000020u;
}
inline void LocatedBlocksProto::clear_has_fileencryptioninfo() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void LocatedBlocksProto::clear_fileencryptioninfo() {
  if (fileencryptioninfo_ != NULL) fileencryptioninfo_->::hadoop::hdfs::FileEncryptionInfoProto::Clear();
  clear_has_fileencryptioninfo();
}
inline const ::hadoop::hdfs::FileEncryptionInfoProto& LocatedBlocksProto::fileencryptioninfo() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlocksProto.fileEncryptionInfo)
  return fileencryptioninfo_ != NULL ? *fileencryptioninfo_ : *default_instance_->fileencryptioninfo_;
}
inline ::hadoop::hdfs::FileEncryptionInfoProto* LocatedBlocksProto::mutable_fileencryptioninfo() {
  set_has_fileencryptioninfo();
  if (fileencryptioninfo_ == NULL) {
    fileencryptioninfo_ = new ::hadoop::hdfs::FileEncryptionInfoProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlocksProto.fileEncryptionInfo)
  return fileencryptioninfo_;
}
inline ::hadoop::hdfs::FileEncryptionInfoProto* LocatedBlocksProto::release_fileencryptioninfo() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.LocatedBlocksProto.fileEncryptionInfo)
  clear_has_fileencryptioninfo();
  ::hadoop::hdfs::FileEncryptionInfoProto* temp = fileencryptioninfo_;
  fileencryptioninfo_ = NULL;
  return temp;
}
inline void LocatedBlocksProto::set_allocated_fileencryptioninfo(::hadoop::hdfs::FileEncryptionInfoProto* fileencryptioninfo) {
  delete fileencryptioninfo_;
  fileencryptioninfo_ = fileencryptioninfo;
  if (fileencryptioninfo) {
    set_has_fileencryptioninfo();
  } else {
    clear_has_fileencryptioninfo();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.LocatedBlocksProto.fileEncryptionInfo)
}

// optional .hadoop.hdfs.ErasureCodingPolicyProto ecPolicy = 7;
inline bool LocatedBlocksProto::has_ecpolicy() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void LocatedBlocksProto::set_has_ecpolicy() {
  _has_bits_[0] |= 0x00000040u;
}
inline void LocatedBlocksProto::clear_has_ecpolicy() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void LocatedBlocksProto::clear_ecpolicy() {
  if (ecpolicy_ != NULL) ecpolicy_->::hadoop::hdfs::ErasureCodingPolicyProto::Clear();
  clear_has_ecpolicy();
}
inline const ::hadoop::hdfs::ErasureCodingPolicyProto& LocatedBlocksProto::ecpolicy() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.LocatedBlocksProto.ecPolicy)
  return ecpolicy_ != NULL ? *ecpolicy_ : *default_instance_->ecpolicy_;
}
inline ::hadoop::hdfs::ErasureCodingPolicyProto* LocatedBlocksProto::mutable_ecpolicy() {
  set_has_ecpolicy();
  if (ecpolicy_ == NULL) {
    ecpolicy_ = new ::hadoop::hdfs::ErasureCodingPolicyProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.LocatedBlocksProto.ecPolicy)
  return ecpolicy_;
}
inline ::hadoop::hdfs::ErasureCodingPolicyProto* LocatedBlocksProto::release_ecpolicy() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.LocatedBlocksProto.ecPolicy)
  clear_has_ecpolicy();
  ::hadoop::hdfs::ErasureCodingPolicyProto* temp = ecpolicy_;
  ecpolicy_ = NULL;
  return temp;
}
inline void LocatedBlocksProto::set_allocated_ecpolicy(::hadoop::hdfs::ErasureCodingPolicyProto* ecpolicy) {
  delete ecpolicy_;
  ecpolicy_ = ecpolicy;
  if (ecpolicy) {
    set_has_ecpolicy();
  } else {
    clear_has_ecpolicy();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.LocatedBlocksProto.ecPolicy)
}

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

// ECSchemaOptionEntryProto

// required string key = 1;
inline bool ECSchemaOptionEntryProto::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ECSchemaOptionEntryProto::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ECSchemaOptionEntryProto::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ECSchemaOptionEntryProto::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
inline const ::std::string& ECSchemaOptionEntryProto::key() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ECSchemaOptionEntryProto.key)
  return key_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ECSchemaOptionEntryProto::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ECSchemaOptionEntryProto.key)
}
inline void ECSchemaOptionEntryProto::set_key(const char* value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ECSchemaOptionEntryProto.key)
}
inline void ECSchemaOptionEntryProto::set_key(const char* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ECSchemaOptionEntryProto.key)
}
inline ::std::string* ECSchemaOptionEntryProto::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ECSchemaOptionEntryProto.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ECSchemaOptionEntryProto::release_key() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ECSchemaOptionEntryProto.key)
  clear_has_key();
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ECSchemaOptionEntryProto::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ECSchemaOptionEntryProto.key)
}

// required string value = 2;
inline bool ECSchemaOptionEntryProto::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ECSchemaOptionEntryProto::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ECSchemaOptionEntryProto::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ECSchemaOptionEntryProto::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_value();
}
inline const ::std::string& ECSchemaOptionEntryProto::value() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ECSchemaOptionEntryProto.value)
  return value_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ECSchemaOptionEntryProto::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ECSchemaOptionEntryProto.value)
}
inline void ECSchemaOptionEntryProto::set_value(const char* value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ECSchemaOptionEntryProto.value)
}
inline void ECSchemaOptionEntryProto::set_value(const char* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ECSchemaOptionEntryProto.value)
}
inline ::std::string* ECSchemaOptionEntryProto::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ECSchemaOptionEntryProto.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ECSchemaOptionEntryProto::release_value() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ECSchemaOptionEntryProto.value)
  clear_has_value();
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ECSchemaOptionEntryProto::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ECSchemaOptionEntryProto.value)
}

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

// ECSchemaProto

// required string codecName = 1;
inline bool ECSchemaProto::has_codecname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ECSchemaProto::set_has_codecname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ECSchemaProto::clear_has_codecname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ECSchemaProto::clear_codecname() {
  codecname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_codecname();
}
inline const ::std::string& ECSchemaProto::codecname() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ECSchemaProto.codecName)
  return codecname_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ECSchemaProto::set_codecname(const ::std::string& value) {
  set_has_codecname();
  codecname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ECSchemaProto.codecName)
}
inline void ECSchemaProto::set_codecname(const char* value) {
  set_has_codecname();
  codecname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ECSchemaProto.codecName)
}
inline void ECSchemaProto::set_codecname(const char* value, size_t size) {
  set_has_codecname();
  codecname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ECSchemaProto.codecName)
}
inline ::std::string* ECSchemaProto::mutable_codecname() {
  set_has_codecname();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ECSchemaProto.codecName)
  return codecname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ECSchemaProto::release_codecname() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ECSchemaProto.codecName)
  clear_has_codecname();
  return codecname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ECSchemaProto::set_allocated_codecname(::std::string* codecname) {
  if (codecname != NULL) {
    set_has_codecname();
  } else {
    clear_has_codecname();
  }
  codecname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), codecname);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ECSchemaProto.codecName)
}

// required uint32 dataUnits = 2;
inline bool ECSchemaProto::has_dataunits() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ECSchemaProto::set_has_dataunits() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ECSchemaProto::clear_has_dataunits() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ECSchemaProto::clear_dataunits() {
  dataunits_ = 0u;
  clear_has_dataunits();
}
inline ::google::protobuf::uint32 ECSchemaProto::dataunits() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ECSchemaProto.dataUnits)
  return dataunits_;
}
inline void ECSchemaProto::set_dataunits(::google::protobuf::uint32 value) {
  set_has_dataunits();
  dataunits_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ECSchemaProto.dataUnits)
}

// required uint32 parityUnits = 3;
inline bool ECSchemaProto::has_parityunits() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ECSchemaProto::set_has_parityunits() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ECSchemaProto::clear_has_parityunits() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ECSchemaProto::clear_parityunits() {
  parityunits_ = 0u;
  clear_has_parityunits();
}
inline ::google::protobuf::uint32 ECSchemaProto::parityunits() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ECSchemaProto.parityUnits)
  return parityunits_;
}
inline void ECSchemaProto::set_parityunits(::google::protobuf::uint32 value) {
  set_has_parityunits();
  parityunits_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ECSchemaProto.parityUnits)
}

// repeated .hadoop.hdfs.ECSchemaOptionEntryProto options = 4;
inline int ECSchemaProto::options_size() const {
  return options_.size();
}
inline void ECSchemaProto::clear_options() {
  options_.Clear();
}
inline const ::hadoop::hdfs::ECSchemaOptionEntryProto& ECSchemaProto::options(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ECSchemaProto.options)
  return options_.Get(index);
}
inline ::hadoop::hdfs::ECSchemaOptionEntryProto* ECSchemaProto::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ECSchemaProto.options)
  return options_.Mutable(index);
}
inline ::hadoop::hdfs::ECSchemaOptionEntryProto* ECSchemaProto::add_options() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.ECSchemaProto.options)
  return options_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::ECSchemaOptionEntryProto >*
ECSchemaProto::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.ECSchemaProto.options)
  return &options_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::ECSchemaOptionEntryProto >&
ECSchemaProto::options() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.ECSchemaProto.options)
  return options_;
}

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

// ErasureCodingPolicyProto

// optional string name = 1;
inline bool ErasureCodingPolicyProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ErasureCodingPolicyProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ErasureCodingPolicyProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ErasureCodingPolicyProto::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& ErasureCodingPolicyProto::name() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ErasureCodingPolicyProto.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ErasureCodingPolicyProto::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ErasureCodingPolicyProto.name)
}
inline void ErasureCodingPolicyProto::set_name(const char* value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ErasureCodingPolicyProto.name)
}
inline void ErasureCodingPolicyProto::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ErasureCodingPolicyProto.name)
}
inline ::std::string* ErasureCodingPolicyProto::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ErasureCodingPolicyProto.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ErasureCodingPolicyProto::release_name() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ErasureCodingPolicyProto.name)
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ErasureCodingPolicyProto::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ErasureCodingPolicyProto.name)
}

// optional .hadoop.hdfs.ECSchemaProto schema = 2;
inline bool ErasureCodingPolicyProto::has_schema() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ErasureCodingPolicyProto::set_has_schema() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ErasureCodingPolicyProto::clear_has_schema() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ErasureCodingPolicyProto::clear_schema() {
  if (schema_ != NULL) schema_->::hadoop::hdfs::ECSchemaProto::Clear();
  clear_has_schema();
}
inline const ::hadoop::hdfs::ECSchemaProto& ErasureCodingPolicyProto::schema() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ErasureCodingPolicyProto.schema)
  return schema_ != NULL ? *schema_ : *default_instance_->schema_;
}
inline ::hadoop::hdfs::ECSchemaProto* ErasureCodingPolicyProto::mutable_schema() {
  set_has_schema();
  if (schema_ == NULL) {
    schema_ = new ::hadoop::hdfs::ECSchemaProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ErasureCodingPolicyProto.schema)
  return schema_;
}
inline ::hadoop::hdfs::ECSchemaProto* ErasureCodingPolicyProto::release_schema() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ErasureCodingPolicyProto.schema)
  clear_has_schema();
  ::hadoop::hdfs::ECSchemaProto* temp = schema_;
  schema_ = NULL;
  return temp;
}
inline void ErasureCodingPolicyProto::set_allocated_schema(::hadoop::hdfs::ECSchemaProto* schema) {
  delete schema_;
  schema_ = schema;
  if (schema) {
    set_has_schema();
  } else {
    clear_has_schema();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ErasureCodingPolicyProto.schema)
}

// optional uint32 cellSize = 3;
inline bool ErasureCodingPolicyProto::has_cellsize() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ErasureCodingPolicyProto::set_has_cellsize() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ErasureCodingPolicyProto::clear_has_cellsize() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ErasureCodingPolicyProto::clear_cellsize() {
  cellsize_ = 0u;
  clear_has_cellsize();
}
inline ::google::protobuf::uint32 ErasureCodingPolicyProto::cellsize() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ErasureCodingPolicyProto.cellSize)
  return cellsize_;
}
inline void ErasureCodingPolicyProto::set_cellsize(::google::protobuf::uint32 value) {
  set_has_cellsize();
  cellsize_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ErasureCodingPolicyProto.cellSize)
}

// required uint32 id = 4;
inline bool ErasureCodingPolicyProto::has_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ErasureCodingPolicyProto::set_has_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ErasureCodingPolicyProto::clear_has_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ErasureCodingPolicyProto::clear_id() {
  id_ = 0u;
  clear_has_id();
}
inline ::google::protobuf::uint32 ErasureCodingPolicyProto::id() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ErasureCodingPolicyProto.id)
  return id_;
}
inline void ErasureCodingPolicyProto::set_id(::google::protobuf::uint32 value) {
  set_has_id();
  id_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ErasureCodingPolicyProto.id)
}

// optional .hadoop.hdfs.ErasureCodingPolicyState state = 5 [default = ENABLED];
inline bool ErasureCodingPolicyProto::has_state() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ErasureCodingPolicyProto::set_has_state() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ErasureCodingPolicyProto::clear_has_state() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ErasureCodingPolicyProto::clear_state() {
  state_ = 2;
  clear_has_state();
}
inline ::hadoop::hdfs::ErasureCodingPolicyState ErasureCodingPolicyProto::state() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ErasureCodingPolicyProto.state)
  return static_cast< ::hadoop::hdfs::ErasureCodingPolicyState >(state_);
}
inline void ErasureCodingPolicyProto::set_state(::hadoop::hdfs::ErasureCodingPolicyState value) {
  assert(::hadoop::hdfs::ErasureCodingPolicyState_IsValid(value));
  set_has_state();
  state_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ErasureCodingPolicyProto.state)
}

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

// HdfsFileStatusProto

// required .hadoop.hdfs.HdfsFileStatusProto.FileType fileType = 1;
inline bool HdfsFileStatusProto::has_filetype() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HdfsFileStatusProto::set_has_filetype() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HdfsFileStatusProto::clear_has_filetype() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HdfsFileStatusProto::clear_filetype() {
  filetype_ = 1;
  clear_has_filetype();
}
inline ::hadoop::hdfs::HdfsFileStatusProto_FileType HdfsFileStatusProto::filetype() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.fileType)
  return static_cast< ::hadoop::hdfs::HdfsFileStatusProto_FileType >(filetype_);
}
inline void HdfsFileStatusProto::set_filetype(::hadoop::hdfs::HdfsFileStatusProto_FileType value) {
  assert(::hadoop::hdfs::HdfsFileStatusProto_FileType_IsValid(value));
  set_has_filetype();
  filetype_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.fileType)
}

// required bytes path = 2;
inline bool HdfsFileStatusProto::has_path() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HdfsFileStatusProto::set_has_path() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HdfsFileStatusProto::clear_has_path() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HdfsFileStatusProto::clear_path() {
  path_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_path();
}
inline const ::std::string& HdfsFileStatusProto::path() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.path)
  return path_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HdfsFileStatusProto::set_path(const ::std::string& value) {
  set_has_path();
  path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.path)
}
inline void HdfsFileStatusProto::set_path(const char* value) {
  set_has_path();
  path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.HdfsFileStatusProto.path)
}
inline void HdfsFileStatusProto::set_path(const void* value, size_t size) {
  set_has_path();
  path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.HdfsFileStatusProto.path)
}
inline ::std::string* HdfsFileStatusProto::mutable_path() {
  set_has_path();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.HdfsFileStatusProto.path)
  return path_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HdfsFileStatusProto::release_path() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.HdfsFileStatusProto.path)
  clear_has_path();
  return path_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HdfsFileStatusProto::set_allocated_path(::std::string* path) {
  if (path != NULL) {
    set_has_path();
  } else {
    clear_has_path();
  }
  path_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), path);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.HdfsFileStatusProto.path)
}

// required uint64 length = 3;
inline bool HdfsFileStatusProto::has_length() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void HdfsFileStatusProto::set_has_length() {
  _has_bits_[0] |= 0x00000004u;
}
inline void HdfsFileStatusProto::clear_has_length() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void HdfsFileStatusProto::clear_length() {
  length_ = GOOGLE_ULONGLONG(0);
  clear_has_length();
}
inline ::google::protobuf::uint64 HdfsFileStatusProto::length() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.length)
  return length_;
}
inline void HdfsFileStatusProto::set_length(::google::protobuf::uint64 value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.length)
}

// required .hadoop.hdfs.FsPermissionProto permission = 4;
inline bool HdfsFileStatusProto::has_permission() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void HdfsFileStatusProto::set_has_permission() {
  _has_bits_[0] |= 0x00000008u;
}
inline void HdfsFileStatusProto::clear_has_permission() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void HdfsFileStatusProto::clear_permission() {
  if (permission_ != NULL) permission_->::hadoop::hdfs::FsPermissionProto::Clear();
  clear_has_permission();
}
inline const ::hadoop::hdfs::FsPermissionProto& HdfsFileStatusProto::permission() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.permission)
  return permission_ != NULL ? *permission_ : *default_instance_->permission_;
}
inline ::hadoop::hdfs::FsPermissionProto* HdfsFileStatusProto::mutable_permission() {
  set_has_permission();
  if (permission_ == NULL) {
    permission_ = new ::hadoop::hdfs::FsPermissionProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.HdfsFileStatusProto.permission)
  return permission_;
}
inline ::hadoop::hdfs::FsPermissionProto* HdfsFileStatusProto::release_permission() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.HdfsFileStatusProto.permission)
  clear_has_permission();
  ::hadoop::hdfs::FsPermissionProto* temp = permission_;
  permission_ = NULL;
  return temp;
}
inline void HdfsFileStatusProto::set_allocated_permission(::hadoop::hdfs::FsPermissionProto* permission) {
  delete permission_;
  permission_ = permission;
  if (permission) {
    set_has_permission();
  } else {
    clear_has_permission();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.HdfsFileStatusProto.permission)
}

// required string owner = 5;
inline bool HdfsFileStatusProto::has_owner() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void HdfsFileStatusProto::set_has_owner() {
  _has_bits_[0] |= 0x00000010u;
}
inline void HdfsFileStatusProto::clear_has_owner() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void HdfsFileStatusProto::clear_owner() {
  owner_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_owner();
}
inline const ::std::string& HdfsFileStatusProto::owner() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.owner)
  return owner_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HdfsFileStatusProto::set_owner(const ::std::string& value) {
  set_has_owner();
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.owner)
}
inline void HdfsFileStatusProto::set_owner(const char* value) {
  set_has_owner();
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.HdfsFileStatusProto.owner)
}
inline void HdfsFileStatusProto::set_owner(const char* value, size_t size) {
  set_has_owner();
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.HdfsFileStatusProto.owner)
}
inline ::std::string* HdfsFileStatusProto::mutable_owner() {
  set_has_owner();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.HdfsFileStatusProto.owner)
  return owner_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HdfsFileStatusProto::release_owner() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.HdfsFileStatusProto.owner)
  clear_has_owner();
  return owner_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HdfsFileStatusProto::set_allocated_owner(::std::string* owner) {
  if (owner != NULL) {
    set_has_owner();
  } else {
    clear_has_owner();
  }
  owner_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), owner);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.HdfsFileStatusProto.owner)
}

// required string group = 6;
inline bool HdfsFileStatusProto::has_group() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void HdfsFileStatusProto::set_has_group() {
  _has_bits_[0] |= 0x00000020u;
}
inline void HdfsFileStatusProto::clear_has_group() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void HdfsFileStatusProto::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_group();
}
inline const ::std::string& HdfsFileStatusProto::group() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.group)
  return group_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HdfsFileStatusProto::set_group(const ::std::string& value) {
  set_has_group();
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.group)
}
inline void HdfsFileStatusProto::set_group(const char* value) {
  set_has_group();
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.HdfsFileStatusProto.group)
}
inline void HdfsFileStatusProto::set_group(const char* value, size_t size) {
  set_has_group();
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.HdfsFileStatusProto.group)
}
inline ::std::string* HdfsFileStatusProto::mutable_group() {
  set_has_group();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.HdfsFileStatusProto.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HdfsFileStatusProto::release_group() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.HdfsFileStatusProto.group)
  clear_has_group();
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HdfsFileStatusProto::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    set_has_group();
  } else {
    clear_has_group();
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.HdfsFileStatusProto.group)
}

// required uint64 modification_time = 7;
inline bool HdfsFileStatusProto::has_modification_time() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void HdfsFileStatusProto::set_has_modification_time() {
  _has_bits_[0] |= 0x00000040u;
}
inline void HdfsFileStatusProto::clear_has_modification_time() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void HdfsFileStatusProto::clear_modification_time() {
  modification_time_ = GOOGLE_ULONGLONG(0);
  clear_has_modification_time();
}
inline ::google::protobuf::uint64 HdfsFileStatusProto::modification_time() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.modification_time)
  return modification_time_;
}
inline void HdfsFileStatusProto::set_modification_time(::google::protobuf::uint64 value) {
  set_has_modification_time();
  modification_time_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.modification_time)
}

// required uint64 access_time = 8;
inline bool HdfsFileStatusProto::has_access_time() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void HdfsFileStatusProto::set_has_access_time() {
  _has_bits_[0] |= 0x00000080u;
}
inline void HdfsFileStatusProto::clear_has_access_time() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void HdfsFileStatusProto::clear_access_time() {
  access_time_ = GOOGLE_ULONGLONG(0);
  clear_has_access_time();
}
inline ::google::protobuf::uint64 HdfsFileStatusProto::access_time() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.access_time)
  return access_time_;
}
inline void HdfsFileStatusProto::set_access_time(::google::protobuf::uint64 value) {
  set_has_access_time();
  access_time_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.access_time)
}

// optional bytes symlink = 9;
inline bool HdfsFileStatusProto::has_symlink() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void HdfsFileStatusProto::set_has_symlink() {
  _has_bits_[0] |= 0x00000100u;
}
inline void HdfsFileStatusProto::clear_has_symlink() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void HdfsFileStatusProto::clear_symlink() {
  symlink_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_symlink();
}
inline const ::std::string& HdfsFileStatusProto::symlink() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.symlink)
  return symlink_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HdfsFileStatusProto::set_symlink(const ::std::string& value) {
  set_has_symlink();
  symlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.symlink)
}
inline void HdfsFileStatusProto::set_symlink(const char* value) {
  set_has_symlink();
  symlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.HdfsFileStatusProto.symlink)
}
inline void HdfsFileStatusProto::set_symlink(const void* value, size_t size) {
  set_has_symlink();
  symlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.HdfsFileStatusProto.symlink)
}
inline ::std::string* HdfsFileStatusProto::mutable_symlink() {
  set_has_symlink();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.HdfsFileStatusProto.symlink)
  return symlink_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HdfsFileStatusProto::release_symlink() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.HdfsFileStatusProto.symlink)
  clear_has_symlink();
  return symlink_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HdfsFileStatusProto::set_allocated_symlink(::std::string* symlink) {
  if (symlink != NULL) {
    set_has_symlink();
  } else {
    clear_has_symlink();
  }
  symlink_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), symlink);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.HdfsFileStatusProto.symlink)
}

// optional uint32 block_replication = 10 [default = 0];
inline bool HdfsFileStatusProto::has_block_replication() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void HdfsFileStatusProto::set_has_block_replication() {
  _has_bits_[0] |= 0x00000200u;
}
inline void HdfsFileStatusProto::clear_has_block_replication() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void HdfsFileStatusProto::clear_block_replication() {
  block_replication_ = 0u;
  clear_has_block_replication();
}
inline ::google::protobuf::uint32 HdfsFileStatusProto::block_replication() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.block_replication)
  return block_replication_;
}
inline void HdfsFileStatusProto::set_block_replication(::google::protobuf::uint32 value) {
  set_has_block_replication();
  block_replication_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.block_replication)
}

// optional uint64 blocksize = 11 [default = 0];
inline bool HdfsFileStatusProto::has_blocksize() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void HdfsFileStatusProto::set_has_blocksize() {
  _has_bits_[0] |= 0x00000400u;
}
inline void HdfsFileStatusProto::clear_has_blocksize() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void HdfsFileStatusProto::clear_blocksize() {
  blocksize_ = GOOGLE_ULONGLONG(0);
  clear_has_blocksize();
}
inline ::google::protobuf::uint64 HdfsFileStatusProto::blocksize() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.blocksize)
  return blocksize_;
}
inline void HdfsFileStatusProto::set_blocksize(::google::protobuf::uint64 value) {
  set_has_blocksize();
  blocksize_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.blocksize)
}

// optional .hadoop.hdfs.LocatedBlocksProto locations = 12;
inline bool HdfsFileStatusProto::has_locations() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void HdfsFileStatusProto::set_has_locations() {
  _has_bits_[0] |= 0x00000800u;
}
inline void HdfsFileStatusProto::clear_has_locations() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void HdfsFileStatusProto::clear_locations() {
  if (locations_ != NULL) locations_->::hadoop::hdfs::LocatedBlocksProto::Clear();
  clear_has_locations();
}
inline const ::hadoop::hdfs::LocatedBlocksProto& HdfsFileStatusProto::locations() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.locations)
  return locations_ != NULL ? *locations_ : *default_instance_->locations_;
}
inline ::hadoop::hdfs::LocatedBlocksProto* HdfsFileStatusProto::mutable_locations() {
  set_has_locations();
  if (locations_ == NULL) {
    locations_ = new ::hadoop::hdfs::LocatedBlocksProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.HdfsFileStatusProto.locations)
  return locations_;
}
inline ::hadoop::hdfs::LocatedBlocksProto* HdfsFileStatusProto::release_locations() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.HdfsFileStatusProto.locations)
  clear_has_locations();
  ::hadoop::hdfs::LocatedBlocksProto* temp = locations_;
  locations_ = NULL;
  return temp;
}
inline void HdfsFileStatusProto::set_allocated_locations(::hadoop::hdfs::LocatedBlocksProto* locations) {
  delete locations_;
  locations_ = locations;
  if (locations) {
    set_has_locations();
  } else {
    clear_has_locations();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.HdfsFileStatusProto.locations)
}

// optional uint64 fileId = 13 [default = 0];
inline bool HdfsFileStatusProto::has_fileid() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void HdfsFileStatusProto::set_has_fileid() {
  _has_bits_[0] |= 0x00001000u;
}
inline void HdfsFileStatusProto::clear_has_fileid() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void HdfsFileStatusProto::clear_fileid() {
  fileid_ = GOOGLE_ULONGLONG(0);
  clear_has_fileid();
}
inline ::google::protobuf::uint64 HdfsFileStatusProto::fileid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.fileId)
  return fileid_;
}
inline void HdfsFileStatusProto::set_fileid(::google::protobuf::uint64 value) {
  set_has_fileid();
  fileid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.fileId)
}

// optional int32 childrenNum = 14 [default = -1];
inline bool HdfsFileStatusProto::has_childrennum() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void HdfsFileStatusProto::set_has_childrennum() {
  _has_bits_[0] |= 0x00002000u;
}
inline void HdfsFileStatusProto::clear_has_childrennum() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void HdfsFileStatusProto::clear_childrennum() {
  childrennum_ = -1;
  clear_has_childrennum();
}
inline ::google::protobuf::int32 HdfsFileStatusProto::childrennum() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.childrenNum)
  return childrennum_;
}
inline void HdfsFileStatusProto::set_childrennum(::google::protobuf::int32 value) {
  set_has_childrennum();
  childrennum_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.childrenNum)
}

// optional .hadoop.hdfs.FileEncryptionInfoProto fileEncryptionInfo = 15;
inline bool HdfsFileStatusProto::has_fileencryptioninfo() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void HdfsFileStatusProto::set_has_fileencryptioninfo() {
  _has_bits_[0] |= 0x00004000u;
}
inline void HdfsFileStatusProto::clear_has_fileencryptioninfo() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void HdfsFileStatusProto::clear_fileencryptioninfo() {
  if (fileencryptioninfo_ != NULL) fileencryptioninfo_->::hadoop::hdfs::FileEncryptionInfoProto::Clear();
  clear_has_fileencryptioninfo();
}
inline const ::hadoop::hdfs::FileEncryptionInfoProto& HdfsFileStatusProto::fileencryptioninfo() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.fileEncryptionInfo)
  return fileencryptioninfo_ != NULL ? *fileencryptioninfo_ : *default_instance_->fileencryptioninfo_;
}
inline ::hadoop::hdfs::FileEncryptionInfoProto* HdfsFileStatusProto::mutable_fileencryptioninfo() {
  set_has_fileencryptioninfo();
  if (fileencryptioninfo_ == NULL) {
    fileencryptioninfo_ = new ::hadoop::hdfs::FileEncryptionInfoProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.HdfsFileStatusProto.fileEncryptionInfo)
  return fileencryptioninfo_;
}
inline ::hadoop::hdfs::FileEncryptionInfoProto* HdfsFileStatusProto::release_fileencryptioninfo() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.HdfsFileStatusProto.fileEncryptionInfo)
  clear_has_fileencryptioninfo();
  ::hadoop::hdfs::FileEncryptionInfoProto* temp = fileencryptioninfo_;
  fileencryptioninfo_ = NULL;
  return temp;
}
inline void HdfsFileStatusProto::set_allocated_fileencryptioninfo(::hadoop::hdfs::FileEncryptionInfoProto* fileencryptioninfo) {
  delete fileencryptioninfo_;
  fileencryptioninfo_ = fileencryptioninfo;
  if (fileencryptioninfo) {
    set_has_fileencryptioninfo();
  } else {
    clear_has_fileencryptioninfo();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.HdfsFileStatusProto.fileEncryptionInfo)
}

// optional uint32 storagePolicy = 16 [default = 0];
inline bool HdfsFileStatusProto::has_storagepolicy() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void HdfsFileStatusProto::set_has_storagepolicy() {
  _has_bits_[0] |= 0x00008000u;
}
inline void HdfsFileStatusProto::clear_has_storagepolicy() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void HdfsFileStatusProto::clear_storagepolicy() {
  storagepolicy_ = 0u;
  clear_has_storagepolicy();
}
inline ::google::protobuf::uint32 HdfsFileStatusProto::storagepolicy() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.storagePolicy)
  return storagepolicy_;
}
inline void HdfsFileStatusProto::set_storagepolicy(::google::protobuf::uint32 value) {
  set_has_storagepolicy();
  storagepolicy_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.storagePolicy)
}

// optional .hadoop.hdfs.ErasureCodingPolicyProto ecPolicy = 17;
inline bool HdfsFileStatusProto::has_ecpolicy() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void HdfsFileStatusProto::set_has_ecpolicy() {
  _has_bits_[0] |= 0x00010000u;
}
inline void HdfsFileStatusProto::clear_has_ecpolicy() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void HdfsFileStatusProto::clear_ecpolicy() {
  if (ecpolicy_ != NULL) ecpolicy_->::hadoop::hdfs::ErasureCodingPolicyProto::Clear();
  clear_has_ecpolicy();
}
inline const ::hadoop::hdfs::ErasureCodingPolicyProto& HdfsFileStatusProto::ecpolicy() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.ecPolicy)
  return ecpolicy_ != NULL ? *ecpolicy_ : *default_instance_->ecpolicy_;
}
inline ::hadoop::hdfs::ErasureCodingPolicyProto* HdfsFileStatusProto::mutable_ecpolicy() {
  set_has_ecpolicy();
  if (ecpolicy_ == NULL) {
    ecpolicy_ = new ::hadoop::hdfs::ErasureCodingPolicyProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.HdfsFileStatusProto.ecPolicy)
  return ecpolicy_;
}
inline ::hadoop::hdfs::ErasureCodingPolicyProto* HdfsFileStatusProto::release_ecpolicy() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.HdfsFileStatusProto.ecPolicy)
  clear_has_ecpolicy();
  ::hadoop::hdfs::ErasureCodingPolicyProto* temp = ecpolicy_;
  ecpolicy_ = NULL;
  return temp;
}
inline void HdfsFileStatusProto::set_allocated_ecpolicy(::hadoop::hdfs::ErasureCodingPolicyProto* ecpolicy) {
  delete ecpolicy_;
  ecpolicy_ = ecpolicy;
  if (ecpolicy) {
    set_has_ecpolicy();
  } else {
    clear_has_ecpolicy();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.HdfsFileStatusProto.ecPolicy)
}

// optional uint32 flags = 18 [default = 0];
inline bool HdfsFileStatusProto::has_flags() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void HdfsFileStatusProto::set_has_flags() {
  _has_bits_[0] |= 0x00020000u;
}
inline void HdfsFileStatusProto::clear_has_flags() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void HdfsFileStatusProto::clear_flags() {
  flags_ = 0u;
  clear_has_flags();
}
inline ::google::protobuf::uint32 HdfsFileStatusProto::flags() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.HdfsFileStatusProto.flags)
  return flags_;
}
inline void HdfsFileStatusProto::set_flags(::google::protobuf::uint32 value) {
  set_has_flags();
  flags_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.HdfsFileStatusProto.flags)
}

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

// FsServerDefaultsProto

// required uint64 blockSize = 1;
inline bool FsServerDefaultsProto::has_blocksize() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FsServerDefaultsProto::set_has_blocksize() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FsServerDefaultsProto::clear_has_blocksize() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FsServerDefaultsProto::clear_blocksize() {
  blocksize_ = GOOGLE_ULONGLONG(0);
  clear_has_blocksize();
}
inline ::google::protobuf::uint64 FsServerDefaultsProto::blocksize() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsServerDefaultsProto.blockSize)
  return blocksize_;
}
inline void FsServerDefaultsProto::set_blocksize(::google::protobuf::uint64 value) {
  set_has_blocksize();
  blocksize_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsServerDefaultsProto.blockSize)
}

// required uint32 bytesPerChecksum = 2;
inline bool FsServerDefaultsProto::has_bytesperchecksum() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FsServerDefaultsProto::set_has_bytesperchecksum() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FsServerDefaultsProto::clear_has_bytesperchecksum() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FsServerDefaultsProto::clear_bytesperchecksum() {
  bytesperchecksum_ = 0u;
  clear_has_bytesperchecksum();
}
inline ::google::protobuf::uint32 FsServerDefaultsProto::bytesperchecksum() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsServerDefaultsProto.bytesPerChecksum)
  return bytesperchecksum_;
}
inline void FsServerDefaultsProto::set_bytesperchecksum(::google::protobuf::uint32 value) {
  set_has_bytesperchecksum();
  bytesperchecksum_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsServerDefaultsProto.bytesPerChecksum)
}

// required uint32 writePacketSize = 3;
inline bool FsServerDefaultsProto::has_writepacketsize() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FsServerDefaultsProto::set_has_writepacketsize() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FsServerDefaultsProto::clear_has_writepacketsize() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FsServerDefaultsProto::clear_writepacketsize() {
  writepacketsize_ = 0u;
  clear_has_writepacketsize();
}
inline ::google::protobuf::uint32 FsServerDefaultsProto::writepacketsize() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsServerDefaultsProto.writePacketSize)
  return writepacketsize_;
}
inline void FsServerDefaultsProto::set_writepacketsize(::google::protobuf::uint32 value) {
  set_has_writepacketsize();
  writepacketsize_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsServerDefaultsProto.writePacketSize)
}

// required uint32 replication = 4;
inline bool FsServerDefaultsProto::has_replication() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FsServerDefaultsProto::set_has_replication() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FsServerDefaultsProto::clear_has_replication() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FsServerDefaultsProto::clear_replication() {
  replication_ = 0u;
  clear_has_replication();
}
inline ::google::protobuf::uint32 FsServerDefaultsProto::replication() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsServerDefaultsProto.replication)
  return replication_;
}
inline void FsServerDefaultsProto::set_replication(::google::protobuf::uint32 value) {
  set_has_replication();
  replication_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsServerDefaultsProto.replication)
}

// required uint32 fileBufferSize = 5;
inline bool FsServerDefaultsProto::has_filebuffersize() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void FsServerDefaultsProto::set_has_filebuffersize() {
  _has_bits_[0] |= 0x00000010u;
}
inline void FsServerDefaultsProto::clear_has_filebuffersize() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void FsServerDefaultsProto::clear_filebuffersize() {
  filebuffersize_ = 0u;
  clear_has_filebuffersize();
}
inline ::google::protobuf::uint32 FsServerDefaultsProto::filebuffersize() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsServerDefaultsProto.fileBufferSize)
  return filebuffersize_;
}
inline void FsServerDefaultsProto::set_filebuffersize(::google::protobuf::uint32 value) {
  set_has_filebuffersize();
  filebuffersize_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsServerDefaultsProto.fileBufferSize)
}

// optional bool encryptDataTransfer = 6 [default = false];
inline bool FsServerDefaultsProto::has_encryptdatatransfer() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void FsServerDefaultsProto::set_has_encryptdatatransfer() {
  _has_bits_[0] |= 0x00000020u;
}
inline void FsServerDefaultsProto::clear_has_encryptdatatransfer() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void FsServerDefaultsProto::clear_encryptdatatransfer() {
  encryptdatatransfer_ = false;
  clear_has_encryptdatatransfer();
}
inline bool FsServerDefaultsProto::encryptdatatransfer() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsServerDefaultsProto.encryptDataTransfer)
  return encryptdatatransfer_;
}
inline void FsServerDefaultsProto::set_encryptdatatransfer(bool value) {
  set_has_encryptdatatransfer();
  encryptdatatransfer_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsServerDefaultsProto.encryptDataTransfer)
}

// optional uint64 trashInterval = 7 [default = 0];
inline bool FsServerDefaultsProto::has_trashinterval() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void FsServerDefaultsProto::set_has_trashinterval() {
  _has_bits_[0] |= 0x00000040u;
}
inline void FsServerDefaultsProto::clear_has_trashinterval() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void FsServerDefaultsProto::clear_trashinterval() {
  trashinterval_ = GOOGLE_ULONGLONG(0);
  clear_has_trashinterval();
}
inline ::google::protobuf::uint64 FsServerDefaultsProto::trashinterval() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsServerDefaultsProto.trashInterval)
  return trashinterval_;
}
inline void FsServerDefaultsProto::set_trashinterval(::google::protobuf::uint64 value) {
  set_has_trashinterval();
  trashinterval_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsServerDefaultsProto.trashInterval)
}

// optional .hadoop.hdfs.ChecksumTypeProto checksumType = 8 [default = CHECKSUM_CRC32];
inline bool FsServerDefaultsProto::has_checksumtype() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void FsServerDefaultsProto::set_has_checksumtype() {
  _has_bits_[0] |= 0x00000080u;
}
inline void FsServerDefaultsProto::clear_has_checksumtype() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void FsServerDefaultsProto::clear_checksumtype() {
  checksumtype_ = 1;
  clear_has_checksumtype();
}
inline ::hadoop::hdfs::ChecksumTypeProto FsServerDefaultsProto::checksumtype() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.FsServerDefaultsProto.checksumType)
  return static_cast< ::hadoop::hdfs::ChecksumTypeProto >(checksumtype_);
}
inline void FsServerDefaultsProto::set_checksumtype(::hadoop::hdfs::ChecksumTypeProto value) {
  assert(::hadoop::hdfs::ChecksumTypeProto_IsValid(value));
  set_has_checksumtype();
  checksumtype_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.FsServerDefaultsProto.checksumType)
}

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

// DirectoryListingProto

// repeated .hadoop.hdfs.HdfsFileStatusProto partialListing = 1;
inline int DirectoryListingProto::partiallisting_size() const {
  return partiallisting_.size();
}
inline void DirectoryListingProto::clear_partiallisting() {
  partiallisting_.Clear();
}
inline const ::hadoop::hdfs::HdfsFileStatusProto& DirectoryListingProto::partiallisting(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DirectoryListingProto.partialListing)
  return partiallisting_.Get(index);
}
inline ::hadoop::hdfs::HdfsFileStatusProto* DirectoryListingProto::mutable_partiallisting(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.DirectoryListingProto.partialListing)
  return partiallisting_.Mutable(index);
}
inline ::hadoop::hdfs::HdfsFileStatusProto* DirectoryListingProto::add_partiallisting() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.DirectoryListingProto.partialListing)
  return partiallisting_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::HdfsFileStatusProto >*
DirectoryListingProto::mutable_partiallisting() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.DirectoryListingProto.partialListing)
  return &partiallisting_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::HdfsFileStatusProto >&
DirectoryListingProto::partiallisting() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.DirectoryListingProto.partialListing)
  return partiallisting_;
}

// required uint32 remainingEntries = 2;
inline bool DirectoryListingProto::has_remainingentries() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DirectoryListingProto::set_has_remainingentries() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DirectoryListingProto::clear_has_remainingentries() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DirectoryListingProto::clear_remainingentries() {
  remainingentries_ = 0u;
  clear_has_remainingentries();
}
inline ::google::protobuf::uint32 DirectoryListingProto::remainingentries() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.DirectoryListingProto.remainingEntries)
  return remainingentries_;
}
inline void DirectoryListingProto::set_remainingentries(::google::protobuf::uint32 value) {
  set_has_remainingentries();
  remainingentries_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.DirectoryListingProto.remainingEntries)
}

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

// SnapshottableDirectoryStatusProto

// required .hadoop.hdfs.HdfsFileStatusProto dirStatus = 1;
inline bool SnapshottableDirectoryStatusProto::has_dirstatus() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SnapshottableDirectoryStatusProto::set_has_dirstatus() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SnapshottableDirectoryStatusProto::clear_has_dirstatus() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SnapshottableDirectoryStatusProto::clear_dirstatus() {
  if (dirstatus_ != NULL) dirstatus_->::hadoop::hdfs::HdfsFileStatusProto::Clear();
  clear_has_dirstatus();
}
inline const ::hadoop::hdfs::HdfsFileStatusProto& SnapshottableDirectoryStatusProto::dirstatus() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshottableDirectoryStatusProto.dirStatus)
  return dirstatus_ != NULL ? *dirstatus_ : *default_instance_->dirstatus_;
}
inline ::hadoop::hdfs::HdfsFileStatusProto* SnapshottableDirectoryStatusProto::mutable_dirstatus() {
  set_has_dirstatus();
  if (dirstatus_ == NULL) {
    dirstatus_ = new ::hadoop::hdfs::HdfsFileStatusProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshottableDirectoryStatusProto.dirStatus)
  return dirstatus_;
}
inline ::hadoop::hdfs::HdfsFileStatusProto* SnapshottableDirectoryStatusProto::release_dirstatus() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshottableDirectoryStatusProto.dirStatus)
  clear_has_dirstatus();
  ::hadoop::hdfs::HdfsFileStatusProto* temp = dirstatus_;
  dirstatus_ = NULL;
  return temp;
}
inline void SnapshottableDirectoryStatusProto::set_allocated_dirstatus(::hadoop::hdfs::HdfsFileStatusProto* dirstatus) {
  delete dirstatus_;
  dirstatus_ = dirstatus;
  if (dirstatus) {
    set_has_dirstatus();
  } else {
    clear_has_dirstatus();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshottableDirectoryStatusProto.dirStatus)
}

// required uint32 snapshot_quota = 2;
inline bool SnapshottableDirectoryStatusProto::has_snapshot_quota() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SnapshottableDirectoryStatusProto::set_has_snapshot_quota() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SnapshottableDirectoryStatusProto::clear_has_snapshot_quota() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SnapshottableDirectoryStatusProto::clear_snapshot_quota() {
  snapshot_quota_ = 0u;
  clear_has_snapshot_quota();
}
inline ::google::protobuf::uint32 SnapshottableDirectoryStatusProto::snapshot_quota() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshottableDirectoryStatusProto.snapshot_quota)
  return snapshot_quota_;
}
inline void SnapshottableDirectoryStatusProto::set_snapshot_quota(::google::protobuf::uint32 value) {
  set_has_snapshot_quota();
  snapshot_quota_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshottableDirectoryStatusProto.snapshot_quota)
}

// required uint32 snapshot_number = 3;
inline bool SnapshottableDirectoryStatusProto::has_snapshot_number() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SnapshottableDirectoryStatusProto::set_has_snapshot_number() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SnapshottableDirectoryStatusProto::clear_has_snapshot_number() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SnapshottableDirectoryStatusProto::clear_snapshot_number() {
  snapshot_number_ = 0u;
  clear_has_snapshot_number();
}
inline ::google::protobuf::uint32 SnapshottableDirectoryStatusProto::snapshot_number() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshottableDirectoryStatusProto.snapshot_number)
  return snapshot_number_;
}
inline void SnapshottableDirectoryStatusProto::set_snapshot_number(::google::protobuf::uint32 value) {
  set_has_snapshot_number();
  snapshot_number_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshottableDirectoryStatusProto.snapshot_number)
}

// required bytes parent_fullpath = 4;
inline bool SnapshottableDirectoryStatusProto::has_parent_fullpath() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SnapshottableDirectoryStatusProto::set_has_parent_fullpath() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SnapshottableDirectoryStatusProto::clear_has_parent_fullpath() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SnapshottableDirectoryStatusProto::clear_parent_fullpath() {
  parent_fullpath_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_parent_fullpath();
}
inline const ::std::string& SnapshottableDirectoryStatusProto::parent_fullpath() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshottableDirectoryStatusProto.parent_fullpath)
  return parent_fullpath_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshottableDirectoryStatusProto::set_parent_fullpath(const ::std::string& value) {
  set_has_parent_fullpath();
  parent_fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshottableDirectoryStatusProto.parent_fullpath)
}
inline void SnapshottableDirectoryStatusProto::set_parent_fullpath(const char* value) {
  set_has_parent_fullpath();
  parent_fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshottableDirectoryStatusProto.parent_fullpath)
}
inline void SnapshottableDirectoryStatusProto::set_parent_fullpath(const void* value, size_t size) {
  set_has_parent_fullpath();
  parent_fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshottableDirectoryStatusProto.parent_fullpath)
}
inline ::std::string* SnapshottableDirectoryStatusProto::mutable_parent_fullpath() {
  set_has_parent_fullpath();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshottableDirectoryStatusProto.parent_fullpath)
  return parent_fullpath_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshottableDirectoryStatusProto::release_parent_fullpath() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshottableDirectoryStatusProto.parent_fullpath)
  clear_has_parent_fullpath();
  return parent_fullpath_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshottableDirectoryStatusProto::set_allocated_parent_fullpath(::std::string* parent_fullpath) {
  if (parent_fullpath != NULL) {
    set_has_parent_fullpath();
  } else {
    clear_has_parent_fullpath();
  }
  parent_fullpath_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), parent_fullpath);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshottableDirectoryStatusProto.parent_fullpath)
}

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

// SnapshottableDirectoryListingProto

// repeated .hadoop.hdfs.SnapshottableDirectoryStatusProto snapshottableDirListing = 1;
inline int SnapshottableDirectoryListingProto::snapshottabledirlisting_size() const {
  return snapshottabledirlisting_.size();
}
inline void SnapshottableDirectoryListingProto::clear_snapshottabledirlisting() {
  snapshottabledirlisting_.Clear();
}
inline const ::hadoop::hdfs::SnapshottableDirectoryStatusProto& SnapshottableDirectoryListingProto::snapshottabledirlisting(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshottableDirectoryListingProto.snapshottableDirListing)
  return snapshottabledirlisting_.Get(index);
}
inline ::hadoop::hdfs::SnapshottableDirectoryStatusProto* SnapshottableDirectoryListingProto::mutable_snapshottabledirlisting(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshottableDirectoryListingProto.snapshottableDirListing)
  return snapshottabledirlisting_.Mutable(index);
}
inline ::hadoop::hdfs::SnapshottableDirectoryStatusProto* SnapshottableDirectoryListingProto::add_snapshottabledirlisting() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.SnapshottableDirectoryListingProto.snapshottableDirListing)
  return snapshottabledirlisting_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshottableDirectoryStatusProto >*
SnapshottableDirectoryListingProto::mutable_snapshottabledirlisting() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.SnapshottableDirectoryListingProto.snapshottableDirListing)
  return &snapshottabledirlisting_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshottableDirectoryStatusProto >&
SnapshottableDirectoryListingProto::snapshottabledirlisting() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.SnapshottableDirectoryListingProto.snapshottableDirListing)
  return snapshottabledirlisting_;
}

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

// SnapshotDiffReportEntryProto

// required bytes fullpath = 1;
inline bool SnapshotDiffReportEntryProto::has_fullpath() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SnapshotDiffReportEntryProto::set_has_fullpath() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SnapshotDiffReportEntryProto::clear_has_fullpath() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SnapshotDiffReportEntryProto::clear_fullpath() {
  fullpath_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_fullpath();
}
inline const ::std::string& SnapshotDiffReportEntryProto::fullpath() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotDiffReportEntryProto.fullpath)
  return fullpath_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportEntryProto::set_fullpath(const ::std::string& value) {
  set_has_fullpath();
  fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotDiffReportEntryProto.fullpath)
}
inline void SnapshotDiffReportEntryProto::set_fullpath(const char* value) {
  set_has_fullpath();
  fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotDiffReportEntryProto.fullpath)
}
inline void SnapshotDiffReportEntryProto::set_fullpath(const void* value, size_t size) {
  set_has_fullpath();
  fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotDiffReportEntryProto.fullpath)
}
inline ::std::string* SnapshotDiffReportEntryProto::mutable_fullpath() {
  set_has_fullpath();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotDiffReportEntryProto.fullpath)
  return fullpath_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotDiffReportEntryProto::release_fullpath() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotDiffReportEntryProto.fullpath)
  clear_has_fullpath();
  return fullpath_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportEntryProto::set_allocated_fullpath(::std::string* fullpath) {
  if (fullpath != NULL) {
    set_has_fullpath();
  } else {
    clear_has_fullpath();
  }
  fullpath_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), fullpath);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotDiffReportEntryProto.fullpath)
}

// required string modificationLabel = 2;
inline bool SnapshotDiffReportEntryProto::has_modificationlabel() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SnapshotDiffReportEntryProto::set_has_modificationlabel() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SnapshotDiffReportEntryProto::clear_has_modificationlabel() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SnapshotDiffReportEntryProto::clear_modificationlabel() {
  modificationlabel_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_modificationlabel();
}
inline const ::std::string& SnapshotDiffReportEntryProto::modificationlabel() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotDiffReportEntryProto.modificationLabel)
  return modificationlabel_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportEntryProto::set_modificationlabel(const ::std::string& value) {
  set_has_modificationlabel();
  modificationlabel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotDiffReportEntryProto.modificationLabel)
}
inline void SnapshotDiffReportEntryProto::set_modificationlabel(const char* value) {
  set_has_modificationlabel();
  modificationlabel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotDiffReportEntryProto.modificationLabel)
}
inline void SnapshotDiffReportEntryProto::set_modificationlabel(const char* value, size_t size) {
  set_has_modificationlabel();
  modificationlabel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotDiffReportEntryProto.modificationLabel)
}
inline ::std::string* SnapshotDiffReportEntryProto::mutable_modificationlabel() {
  set_has_modificationlabel();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotDiffReportEntryProto.modificationLabel)
  return modificationlabel_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotDiffReportEntryProto::release_modificationlabel() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotDiffReportEntryProto.modificationLabel)
  clear_has_modificationlabel();
  return modificationlabel_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportEntryProto::set_allocated_modificationlabel(::std::string* modificationlabel) {
  if (modificationlabel != NULL) {
    set_has_modificationlabel();
  } else {
    clear_has_modificationlabel();
  }
  modificationlabel_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), modificationlabel);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotDiffReportEntryProto.modificationLabel)
}

// optional bytes targetPath = 3;
inline bool SnapshotDiffReportEntryProto::has_targetpath() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SnapshotDiffReportEntryProto::set_has_targetpath() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SnapshotDiffReportEntryProto::clear_has_targetpath() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SnapshotDiffReportEntryProto::clear_targetpath() {
  targetpath_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_targetpath();
}
inline const ::std::string& SnapshotDiffReportEntryProto::targetpath() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotDiffReportEntryProto.targetPath)
  return targetpath_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportEntryProto::set_targetpath(const ::std::string& value) {
  set_has_targetpath();
  targetpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotDiffReportEntryProto.targetPath)
}
inline void SnapshotDiffReportEntryProto::set_targetpath(const char* value) {
  set_has_targetpath();
  targetpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotDiffReportEntryProto.targetPath)
}
inline void SnapshotDiffReportEntryProto::set_targetpath(const void* value, size_t size) {
  set_has_targetpath();
  targetpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotDiffReportEntryProto.targetPath)
}
inline ::std::string* SnapshotDiffReportEntryProto::mutable_targetpath() {
  set_has_targetpath();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotDiffReportEntryProto.targetPath)
  return targetpath_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotDiffReportEntryProto::release_targetpath() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotDiffReportEntryProto.targetPath)
  clear_has_targetpath();
  return targetpath_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportEntryProto::set_allocated_targetpath(::std::string* targetpath) {
  if (targetpath != NULL) {
    set_has_targetpath();
  } else {
    clear_has_targetpath();
  }
  targetpath_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), targetpath);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotDiffReportEntryProto.targetPath)
}

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

// SnapshotDiffReportProto

// required string snapshotRoot = 1;
inline bool SnapshotDiffReportProto::has_snapshotroot() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SnapshotDiffReportProto::set_has_snapshotroot() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SnapshotDiffReportProto::clear_has_snapshotroot() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SnapshotDiffReportProto::clear_snapshotroot() {
  snapshotroot_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_snapshotroot();
}
inline const ::std::string& SnapshotDiffReportProto::snapshotroot() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotDiffReportProto.snapshotRoot)
  return snapshotroot_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportProto::set_snapshotroot(const ::std::string& value) {
  set_has_snapshotroot();
  snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotDiffReportProto.snapshotRoot)
}
inline void SnapshotDiffReportProto::set_snapshotroot(const char* value) {
  set_has_snapshotroot();
  snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotDiffReportProto.snapshotRoot)
}
inline void SnapshotDiffReportProto::set_snapshotroot(const char* value, size_t size) {
  set_has_snapshotroot();
  snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotDiffReportProto.snapshotRoot)
}
inline ::std::string* SnapshotDiffReportProto::mutable_snapshotroot() {
  set_has_snapshotroot();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotDiffReportProto.snapshotRoot)
  return snapshotroot_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotDiffReportProto::release_snapshotroot() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotDiffReportProto.snapshotRoot)
  clear_has_snapshotroot();
  return snapshotroot_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportProto::set_allocated_snapshotroot(::std::string* snapshotroot) {
  if (snapshotroot != NULL) {
    set_has_snapshotroot();
  } else {
    clear_has_snapshotroot();
  }
  snapshotroot_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshotroot);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotDiffReportProto.snapshotRoot)
}

// required string fromSnapshot = 2;
inline bool SnapshotDiffReportProto::has_fromsnapshot() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SnapshotDiffReportProto::set_has_fromsnapshot() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SnapshotDiffReportProto::clear_has_fromsnapshot() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SnapshotDiffReportProto::clear_fromsnapshot() {
  fromsnapshot_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_fromsnapshot();
}
inline const ::std::string& SnapshotDiffReportProto::fromsnapshot() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotDiffReportProto.fromSnapshot)
  return fromsnapshot_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportProto::set_fromsnapshot(const ::std::string& value) {
  set_has_fromsnapshot();
  fromsnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotDiffReportProto.fromSnapshot)
}
inline void SnapshotDiffReportProto::set_fromsnapshot(const char* value) {
  set_has_fromsnapshot();
  fromsnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotDiffReportProto.fromSnapshot)
}
inline void SnapshotDiffReportProto::set_fromsnapshot(const char* value, size_t size) {
  set_has_fromsnapshot();
  fromsnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotDiffReportProto.fromSnapshot)
}
inline ::std::string* SnapshotDiffReportProto::mutable_fromsnapshot() {
  set_has_fromsnapshot();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotDiffReportProto.fromSnapshot)
  return fromsnapshot_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotDiffReportProto::release_fromsnapshot() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotDiffReportProto.fromSnapshot)
  clear_has_fromsnapshot();
  return fromsnapshot_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportProto::set_allocated_fromsnapshot(::std::string* fromsnapshot) {
  if (fromsnapshot != NULL) {
    set_has_fromsnapshot();
  } else {
    clear_has_fromsnapshot();
  }
  fromsnapshot_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), fromsnapshot);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotDiffReportProto.fromSnapshot)
}

// required string toSnapshot = 3;
inline bool SnapshotDiffReportProto::has_tosnapshot() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SnapshotDiffReportProto::set_has_tosnapshot() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SnapshotDiffReportProto::clear_has_tosnapshot() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SnapshotDiffReportProto::clear_tosnapshot() {
  tosnapshot_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_tosnapshot();
}
inline const ::std::string& SnapshotDiffReportProto::tosnapshot() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotDiffReportProto.toSnapshot)
  return tosnapshot_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportProto::set_tosnapshot(const ::std::string& value) {
  set_has_tosnapshot();
  tosnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotDiffReportProto.toSnapshot)
}
inline void SnapshotDiffReportProto::set_tosnapshot(const char* value) {
  set_has_tosnapshot();
  tosnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotDiffReportProto.toSnapshot)
}
inline void SnapshotDiffReportProto::set_tosnapshot(const char* value, size_t size) {
  set_has_tosnapshot();
  tosnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotDiffReportProto.toSnapshot)
}
inline ::std::string* SnapshotDiffReportProto::mutable_tosnapshot() {
  set_has_tosnapshot();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotDiffReportProto.toSnapshot)
  return tosnapshot_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotDiffReportProto::release_tosnapshot() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotDiffReportProto.toSnapshot)
  clear_has_tosnapshot();
  return tosnapshot_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotDiffReportProto::set_allocated_tosnapshot(::std::string* tosnapshot) {
  if (tosnapshot != NULL) {
    set_has_tosnapshot();
  } else {
    clear_has_tosnapshot();
  }
  tosnapshot_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), tosnapshot);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotDiffReportProto.toSnapshot)
}

// repeated .hadoop.hdfs.SnapshotDiffReportEntryProto diffReportEntries = 4;
inline int SnapshotDiffReportProto::diffreportentries_size() const {
  return diffreportentries_.size();
}
inline void SnapshotDiffReportProto::clear_diffreportentries() {
  diffreportentries_.Clear();
}
inline const ::hadoop::hdfs::SnapshotDiffReportEntryProto& SnapshotDiffReportProto::diffreportentries(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotDiffReportProto.diffReportEntries)
  return diffreportentries_.Get(index);
}
inline ::hadoop::hdfs::SnapshotDiffReportEntryProto* SnapshotDiffReportProto::mutable_diffreportentries(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotDiffReportProto.diffReportEntries)
  return diffreportentries_.Mutable(index);
}
inline ::hadoop::hdfs::SnapshotDiffReportEntryProto* SnapshotDiffReportProto::add_diffreportentries() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.SnapshotDiffReportProto.diffReportEntries)
  return diffreportentries_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshotDiffReportEntryProto >*
SnapshotDiffReportProto::mutable_diffreportentries() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.SnapshotDiffReportProto.diffReportEntries)
  return &diffreportentries_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::SnapshotDiffReportEntryProto >&
SnapshotDiffReportProto::diffreportentries() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.SnapshotDiffReportProto.diffReportEntries)
  return diffreportentries_;
}

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

// StorageInfoProto

// required uint32 layoutVersion = 1;
inline bool StorageInfoProto::has_layoutversion() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StorageInfoProto::set_has_layoutversion() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StorageInfoProto::clear_has_layoutversion() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StorageInfoProto::clear_layoutversion() {
  layoutversion_ = 0u;
  clear_has_layoutversion();
}
inline ::google::protobuf::uint32 StorageInfoProto::layoutversion() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageInfoProto.layoutVersion)
  return layoutversion_;
}
inline void StorageInfoProto::set_layoutversion(::google::protobuf::uint32 value) {
  set_has_layoutversion();
  layoutversion_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageInfoProto.layoutVersion)
}

// required uint32 namespceID = 2;
inline bool StorageInfoProto::has_namespceid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StorageInfoProto::set_has_namespceid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StorageInfoProto::clear_has_namespceid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StorageInfoProto::clear_namespceid() {
  namespceid_ = 0u;
  clear_has_namespceid();
}
inline ::google::protobuf::uint32 StorageInfoProto::namespceid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageInfoProto.namespceID)
  return namespceid_;
}
inline void StorageInfoProto::set_namespceid(::google::protobuf::uint32 value) {
  set_has_namespceid();
  namespceid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageInfoProto.namespceID)
}

// required string clusterID = 3;
inline bool StorageInfoProto::has_clusterid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void StorageInfoProto::set_has_clusterid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void StorageInfoProto::clear_has_clusterid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void StorageInfoProto::clear_clusterid() {
  clusterid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_clusterid();
}
inline const ::std::string& StorageInfoProto::clusterid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageInfoProto.clusterID)
  return clusterid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StorageInfoProto::set_clusterid(const ::std::string& value) {
  set_has_clusterid();
  clusterid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageInfoProto.clusterID)
}
inline void StorageInfoProto::set_clusterid(const char* value) {
  set_has_clusterid();
  clusterid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.StorageInfoProto.clusterID)
}
inline void StorageInfoProto::set_clusterid(const char* value, size_t size) {
  set_has_clusterid();
  clusterid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.StorageInfoProto.clusterID)
}
inline ::std::string* StorageInfoProto::mutable_clusterid() {
  set_has_clusterid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.StorageInfoProto.clusterID)
  return clusterid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StorageInfoProto::release_clusterid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.StorageInfoProto.clusterID)
  clear_has_clusterid();
  return clusterid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StorageInfoProto::set_allocated_clusterid(::std::string* clusterid) {
  if (clusterid != NULL) {
    set_has_clusterid();
  } else {
    clear_has_clusterid();
  }
  clusterid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), clusterid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.StorageInfoProto.clusterID)
}

// required uint64 cTime = 4;
inline bool StorageInfoProto::has_ctime() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void StorageInfoProto::set_has_ctime() {
  _has_bits_[0] |= 0x00000008u;
}
inline void StorageInfoProto::clear_has_ctime() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void StorageInfoProto::clear_ctime() {
  ctime_ = GOOGLE_ULONGLONG(0);
  clear_has_ctime();
}
inline ::google::protobuf::uint64 StorageInfoProto::ctime() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.StorageInfoProto.cTime)
  return ctime_;
}
inline void StorageInfoProto::set_ctime(::google::protobuf::uint64 value) {
  set_has_ctime();
  ctime_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.StorageInfoProto.cTime)
}

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

// NamenodeRegistrationProto

// required string rpcAddress = 1;
inline bool NamenodeRegistrationProto::has_rpcaddress() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NamenodeRegistrationProto::set_has_rpcaddress() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NamenodeRegistrationProto::clear_has_rpcaddress() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NamenodeRegistrationProto::clear_rpcaddress() {
  rpcaddress_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_rpcaddress();
}
inline const ::std::string& NamenodeRegistrationProto::rpcaddress() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamenodeRegistrationProto.rpcAddress)
  return rpcaddress_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamenodeRegistrationProto::set_rpcaddress(const ::std::string& value) {
  set_has_rpcaddress();
  rpcaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamenodeRegistrationProto.rpcAddress)
}
inline void NamenodeRegistrationProto::set_rpcaddress(const char* value) {
  set_has_rpcaddress();
  rpcaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.NamenodeRegistrationProto.rpcAddress)
}
inline void NamenodeRegistrationProto::set_rpcaddress(const char* value, size_t size) {
  set_has_rpcaddress();
  rpcaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.NamenodeRegistrationProto.rpcAddress)
}
inline ::std::string* NamenodeRegistrationProto::mutable_rpcaddress() {
  set_has_rpcaddress();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.NamenodeRegistrationProto.rpcAddress)
  return rpcaddress_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NamenodeRegistrationProto::release_rpcaddress() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.NamenodeRegistrationProto.rpcAddress)
  clear_has_rpcaddress();
  return rpcaddress_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamenodeRegistrationProto::set_allocated_rpcaddress(::std::string* rpcaddress) {
  if (rpcaddress != NULL) {
    set_has_rpcaddress();
  } else {
    clear_has_rpcaddress();
  }
  rpcaddress_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), rpcaddress);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.NamenodeRegistrationProto.rpcAddress)
}

// required string httpAddress = 2;
inline bool NamenodeRegistrationProto::has_httpaddress() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NamenodeRegistrationProto::set_has_httpaddress() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NamenodeRegistrationProto::clear_has_httpaddress() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NamenodeRegistrationProto::clear_httpaddress() {
  httpaddress_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_httpaddress();
}
inline const ::std::string& NamenodeRegistrationProto::httpaddress() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamenodeRegistrationProto.httpAddress)
  return httpaddress_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamenodeRegistrationProto::set_httpaddress(const ::std::string& value) {
  set_has_httpaddress();
  httpaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamenodeRegistrationProto.httpAddress)
}
inline void NamenodeRegistrationProto::set_httpaddress(const char* value) {
  set_has_httpaddress();
  httpaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.NamenodeRegistrationProto.httpAddress)
}
inline void NamenodeRegistrationProto::set_httpaddress(const char* value, size_t size) {
  set_has_httpaddress();
  httpaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.NamenodeRegistrationProto.httpAddress)
}
inline ::std::string* NamenodeRegistrationProto::mutable_httpaddress() {
  set_has_httpaddress();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.NamenodeRegistrationProto.httpAddress)
  return httpaddress_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NamenodeRegistrationProto::release_httpaddress() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.NamenodeRegistrationProto.httpAddress)
  clear_has_httpaddress();
  return httpaddress_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamenodeRegistrationProto::set_allocated_httpaddress(::std::string* httpaddress) {
  if (httpaddress != NULL) {
    set_has_httpaddress();
  } else {
    clear_has_httpaddress();
  }
  httpaddress_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), httpaddress);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.NamenodeRegistrationProto.httpAddress)
}

// required .hadoop.hdfs.StorageInfoProto storageInfo = 3;
inline bool NamenodeRegistrationProto::has_storageinfo() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NamenodeRegistrationProto::set_has_storageinfo() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NamenodeRegistrationProto::clear_has_storageinfo() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NamenodeRegistrationProto::clear_storageinfo() {
  if (storageinfo_ != NULL) storageinfo_->::hadoop::hdfs::StorageInfoProto::Clear();
  clear_has_storageinfo();
}
inline const ::hadoop::hdfs::StorageInfoProto& NamenodeRegistrationProto::storageinfo() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamenodeRegistrationProto.storageInfo)
  return storageinfo_ != NULL ? *storageinfo_ : *default_instance_->storageinfo_;
}
inline ::hadoop::hdfs::StorageInfoProto* NamenodeRegistrationProto::mutable_storageinfo() {
  set_has_storageinfo();
  if (storageinfo_ == NULL) {
    storageinfo_ = new ::hadoop::hdfs::StorageInfoProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.NamenodeRegistrationProto.storageInfo)
  return storageinfo_;
}
inline ::hadoop::hdfs::StorageInfoProto* NamenodeRegistrationProto::release_storageinfo() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.NamenodeRegistrationProto.storageInfo)
  clear_has_storageinfo();
  ::hadoop::hdfs::StorageInfoProto* temp = storageinfo_;
  storageinfo_ = NULL;
  return temp;
}
inline void NamenodeRegistrationProto::set_allocated_storageinfo(::hadoop::hdfs::StorageInfoProto* storageinfo) {
  delete storageinfo_;
  storageinfo_ = storageinfo;
  if (storageinfo) {
    set_has_storageinfo();
  } else {
    clear_has_storageinfo();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.NamenodeRegistrationProto.storageInfo)
}

// optional .hadoop.hdfs.NamenodeRegistrationProto.NamenodeRoleProto role = 4 [default = NAMENODE];
inline bool NamenodeRegistrationProto::has_role() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NamenodeRegistrationProto::set_has_role() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NamenodeRegistrationProto::clear_has_role() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NamenodeRegistrationProto::clear_role() {
  role_ = 1;
  clear_has_role();
}
inline ::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto NamenodeRegistrationProto::role() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamenodeRegistrationProto.role)
  return static_cast< ::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto >(role_);
}
inline void NamenodeRegistrationProto::set_role(::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto value) {
  assert(::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto_IsValid(value));
  set_has_role();
  role_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamenodeRegistrationProto.role)
}

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

// CheckpointSignatureProto

// required string blockPoolId = 1;
inline bool CheckpointSignatureProto::has_blockpoolid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CheckpointSignatureProto::set_has_blockpoolid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CheckpointSignatureProto::clear_has_blockpoolid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CheckpointSignatureProto::clear_blockpoolid() {
  blockpoolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_blockpoolid();
}
inline const ::std::string& CheckpointSignatureProto::blockpoolid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CheckpointSignatureProto.blockPoolId)
  return blockpoolid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CheckpointSignatureProto::set_blockpoolid(const ::std::string& value) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CheckpointSignatureProto.blockPoolId)
}
inline void CheckpointSignatureProto::set_blockpoolid(const char* value) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.CheckpointSignatureProto.blockPoolId)
}
inline void CheckpointSignatureProto::set_blockpoolid(const char* value, size_t size) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.CheckpointSignatureProto.blockPoolId)
}
inline ::std::string* CheckpointSignatureProto::mutable_blockpoolid() {
  set_has_blockpoolid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CheckpointSignatureProto.blockPoolId)
  return blockpoolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CheckpointSignatureProto::release_blockpoolid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.CheckpointSignatureProto.blockPoolId)
  clear_has_blockpoolid();
  return blockpoolid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CheckpointSignatureProto::set_allocated_blockpoolid(::std::string* blockpoolid) {
  if (blockpoolid != NULL) {
    set_has_blockpoolid();
  } else {
    clear_has_blockpoolid();
  }
  blockpoolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockpoolid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.CheckpointSignatureProto.blockPoolId)
}

// required uint64 mostRecentCheckpointTxId = 2;
inline bool CheckpointSignatureProto::has_mostrecentcheckpointtxid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CheckpointSignatureProto::set_has_mostrecentcheckpointtxid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CheckpointSignatureProto::clear_has_mostrecentcheckpointtxid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CheckpointSignatureProto::clear_mostrecentcheckpointtxid() {
  mostrecentcheckpointtxid_ = GOOGLE_ULONGLONG(0);
  clear_has_mostrecentcheckpointtxid();
}
inline ::google::protobuf::uint64 CheckpointSignatureProto::mostrecentcheckpointtxid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CheckpointSignatureProto.mostRecentCheckpointTxId)
  return mostrecentcheckpointtxid_;
}
inline void CheckpointSignatureProto::set_mostrecentcheckpointtxid(::google::protobuf::uint64 value) {
  set_has_mostrecentcheckpointtxid();
  mostrecentcheckpointtxid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CheckpointSignatureProto.mostRecentCheckpointTxId)
}

// required uint64 curSegmentTxId = 3;
inline bool CheckpointSignatureProto::has_cursegmenttxid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CheckpointSignatureProto::set_has_cursegmenttxid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CheckpointSignatureProto::clear_has_cursegmenttxid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CheckpointSignatureProto::clear_cursegmenttxid() {
  cursegmenttxid_ = GOOGLE_ULONGLONG(0);
  clear_has_cursegmenttxid();
}
inline ::google::protobuf::uint64 CheckpointSignatureProto::cursegmenttxid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CheckpointSignatureProto.curSegmentTxId)
  return cursegmenttxid_;
}
inline void CheckpointSignatureProto::set_cursegmenttxid(::google::protobuf::uint64 value) {
  set_has_cursegmenttxid();
  cursegmenttxid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CheckpointSignatureProto.curSegmentTxId)
}

// required .hadoop.hdfs.StorageInfoProto storageInfo = 4;
inline bool CheckpointSignatureProto::has_storageinfo() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CheckpointSignatureProto::set_has_storageinfo() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CheckpointSignatureProto::clear_has_storageinfo() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CheckpointSignatureProto::clear_storageinfo() {
  if (storageinfo_ != NULL) storageinfo_->::hadoop::hdfs::StorageInfoProto::Clear();
  clear_has_storageinfo();
}
inline const ::hadoop::hdfs::StorageInfoProto& CheckpointSignatureProto::storageinfo() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CheckpointSignatureProto.storageInfo)
  return storageinfo_ != NULL ? *storageinfo_ : *default_instance_->storageinfo_;
}
inline ::hadoop::hdfs::StorageInfoProto* CheckpointSignatureProto::mutable_storageinfo() {
  set_has_storageinfo();
  if (storageinfo_ == NULL) {
    storageinfo_ = new ::hadoop::hdfs::StorageInfoProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CheckpointSignatureProto.storageInfo)
  return storageinfo_;
}
inline ::hadoop::hdfs::StorageInfoProto* CheckpointSignatureProto::release_storageinfo() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.CheckpointSignatureProto.storageInfo)
  clear_has_storageinfo();
  ::hadoop::hdfs::StorageInfoProto* temp = storageinfo_;
  storageinfo_ = NULL;
  return temp;
}
inline void CheckpointSignatureProto::set_allocated_storageinfo(::hadoop::hdfs::StorageInfoProto* storageinfo) {
  delete storageinfo_;
  storageinfo_ = storageinfo;
  if (storageinfo) {
    set_has_storageinfo();
  } else {
    clear_has_storageinfo();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.CheckpointSignatureProto.storageInfo)
}

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

// NamenodeCommandProto

// required uint32 action = 1;
inline bool NamenodeCommandProto::has_action() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NamenodeCommandProto::set_has_action() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NamenodeCommandProto::clear_has_action() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NamenodeCommandProto::clear_action() {
  action_ = 0u;
  clear_has_action();
}
inline ::google::protobuf::uint32 NamenodeCommandProto::action() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamenodeCommandProto.action)
  return action_;
}
inline void NamenodeCommandProto::set_action(::google::protobuf::uint32 value) {
  set_has_action();
  action_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamenodeCommandProto.action)
}

// required .hadoop.hdfs.NamenodeCommandProto.Type type = 2;
inline bool NamenodeCommandProto::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NamenodeCommandProto::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NamenodeCommandProto::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NamenodeCommandProto::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::hadoop::hdfs::NamenodeCommandProto_Type NamenodeCommandProto::type() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamenodeCommandProto.type)
  return static_cast< ::hadoop::hdfs::NamenodeCommandProto_Type >(type_);
}
inline void NamenodeCommandProto::set_type(::hadoop::hdfs::NamenodeCommandProto_Type value) {
  assert(::hadoop::hdfs::NamenodeCommandProto_Type_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamenodeCommandProto.type)
}

// optional .hadoop.hdfs.CheckpointCommandProto checkpointCmd = 3;
inline bool NamenodeCommandProto::has_checkpointcmd() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NamenodeCommandProto::set_has_checkpointcmd() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NamenodeCommandProto::clear_has_checkpointcmd() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NamenodeCommandProto::clear_checkpointcmd() {
  if (checkpointcmd_ != NULL) checkpointcmd_->::hadoop::hdfs::CheckpointCommandProto::Clear();
  clear_has_checkpointcmd();
}
inline const ::hadoop::hdfs::CheckpointCommandProto& NamenodeCommandProto::checkpointcmd() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamenodeCommandProto.checkpointCmd)
  return checkpointcmd_ != NULL ? *checkpointcmd_ : *default_instance_->checkpointcmd_;
}
inline ::hadoop::hdfs::CheckpointCommandProto* NamenodeCommandProto::mutable_checkpointcmd() {
  set_has_checkpointcmd();
  if (checkpointcmd_ == NULL) {
    checkpointcmd_ = new ::hadoop::hdfs::CheckpointCommandProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.NamenodeCommandProto.checkpointCmd)
  return checkpointcmd_;
}
inline ::hadoop::hdfs::CheckpointCommandProto* NamenodeCommandProto::release_checkpointcmd() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.NamenodeCommandProto.checkpointCmd)
  clear_has_checkpointcmd();
  ::hadoop::hdfs::CheckpointCommandProto* temp = checkpointcmd_;
  checkpointcmd_ = NULL;
  return temp;
}
inline void NamenodeCommandProto::set_allocated_checkpointcmd(::hadoop::hdfs::CheckpointCommandProto* checkpointcmd) {
  delete checkpointcmd_;
  checkpointcmd_ = checkpointcmd;
  if (checkpointcmd) {
    set_has_checkpointcmd();
  } else {
    clear_has_checkpointcmd();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.NamenodeCommandProto.checkpointCmd)
}

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

// CheckpointCommandProto

// required .hadoop.hdfs.CheckpointSignatureProto signature = 1;
inline bool CheckpointCommandProto::has_signature() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CheckpointCommandProto::set_has_signature() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CheckpointCommandProto::clear_has_signature() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CheckpointCommandProto::clear_signature() {
  if (signature_ != NULL) signature_->::hadoop::hdfs::CheckpointSignatureProto::Clear();
  clear_has_signature();
}
inline const ::hadoop::hdfs::CheckpointSignatureProto& CheckpointCommandProto::signature() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CheckpointCommandProto.signature)
  return signature_ != NULL ? *signature_ : *default_instance_->signature_;
}
inline ::hadoop::hdfs::CheckpointSignatureProto* CheckpointCommandProto::mutable_signature() {
  set_has_signature();
  if (signature_ == NULL) {
    signature_ = new ::hadoop::hdfs::CheckpointSignatureProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.CheckpointCommandProto.signature)
  return signature_;
}
inline ::hadoop::hdfs::CheckpointSignatureProto* CheckpointCommandProto::release_signature() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.CheckpointCommandProto.signature)
  clear_has_signature();
  ::hadoop::hdfs::CheckpointSignatureProto* temp = signature_;
  signature_ = NULL;
  return temp;
}
inline void CheckpointCommandProto::set_allocated_signature(::hadoop::hdfs::CheckpointSignatureProto* signature) {
  delete signature_;
  signature_ = signature;
  if (signature) {
    set_has_signature();
  } else {
    clear_has_signature();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.CheckpointCommandProto.signature)
}

// required bool needToReturnImage = 2;
inline bool CheckpointCommandProto::has_needtoreturnimage() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CheckpointCommandProto::set_has_needtoreturnimage() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CheckpointCommandProto::clear_has_needtoreturnimage() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CheckpointCommandProto::clear_needtoreturnimage() {
  needtoreturnimage_ = false;
  clear_has_needtoreturnimage();
}
inline bool CheckpointCommandProto::needtoreturnimage() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.CheckpointCommandProto.needToReturnImage)
  return needtoreturnimage_;
}
inline void CheckpointCommandProto::set_needtoreturnimage(bool value) {
  set_has_needtoreturnimage();
  needtoreturnimage_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.CheckpointCommandProto.needToReturnImage)
}

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

// BlockProto

// required uint64 blockId = 1;
inline bool BlockProto::has_blockid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlockProto::set_has_blockid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BlockProto::clear_has_blockid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BlockProto::clear_blockid() {
  blockid_ = GOOGLE_ULONGLONG(0);
  clear_has_blockid();
}
inline ::google::protobuf::uint64 BlockProto::blockid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockProto.blockId)
  return blockid_;
}
inline void BlockProto::set_blockid(::google::protobuf::uint64 value) {
  set_has_blockid();
  blockid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockProto.blockId)
}

// required uint64 genStamp = 2;
inline bool BlockProto::has_genstamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BlockProto::set_has_genstamp() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BlockProto::clear_has_genstamp() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BlockProto::clear_genstamp() {
  genstamp_ = GOOGLE_ULONGLONG(0);
  clear_has_genstamp();
}
inline ::google::protobuf::uint64 BlockProto::genstamp() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockProto.genStamp)
  return genstamp_;
}
inline void BlockProto::set_genstamp(::google::protobuf::uint64 value) {
  set_has_genstamp();
  genstamp_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockProto.genStamp)
}

// optional uint64 numBytes = 3 [default = 0];
inline bool BlockProto::has_numbytes() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BlockProto::set_has_numbytes() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BlockProto::clear_has_numbytes() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BlockProto::clear_numbytes() {
  numbytes_ = GOOGLE_ULONGLONG(0);
  clear_has_numbytes();
}
inline ::google::protobuf::uint64 BlockProto::numbytes() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockProto.numBytes)
  return numbytes_;
}
inline void BlockProto::set_numbytes(::google::protobuf::uint64 value) {
  set_has_numbytes();
  numbytes_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockProto.numBytes)
}

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

// BlockWithLocationsProto

// required .hadoop.hdfs.BlockProto block = 1;
inline bool BlockWithLocationsProto::has_block() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlockWithLocationsProto::set_has_block() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BlockWithLocationsProto::clear_has_block() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BlockWithLocationsProto::clear_block() {
  if (block_ != NULL) block_->::hadoop::hdfs::BlockProto::Clear();
  clear_has_block();
}
inline const ::hadoop::hdfs::BlockProto& BlockWithLocationsProto::block() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockWithLocationsProto.block)
  return block_ != NULL ? *block_ : *default_instance_->block_;
}
inline ::hadoop::hdfs::BlockProto* BlockWithLocationsProto::mutable_block() {
  set_has_block();
  if (block_ == NULL) {
    block_ = new ::hadoop::hdfs::BlockProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlockWithLocationsProto.block)
  return block_;
}
inline ::hadoop::hdfs::BlockProto* BlockWithLocationsProto::release_block() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.BlockWithLocationsProto.block)
  clear_has_block();
  ::hadoop::hdfs::BlockProto* temp = block_;
  block_ = NULL;
  return temp;
}
inline void BlockWithLocationsProto::set_allocated_block(::hadoop::hdfs::BlockProto* block) {
  delete block_;
  block_ = block;
  if (block) {
    set_has_block();
  } else {
    clear_has_block();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.BlockWithLocationsProto.block)
}

// repeated string datanodeUuids = 2;
inline int BlockWithLocationsProto::datanodeuuids_size() const {
  return datanodeuuids_.size();
}
inline void BlockWithLocationsProto::clear_datanodeuuids() {
  datanodeuuids_.Clear();
}
inline const ::std::string& BlockWithLocationsProto::datanodeuuids(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
  return datanodeuuids_.Get(index);
}
inline ::std::string* BlockWithLocationsProto::mutable_datanodeuuids(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
  return datanodeuuids_.Mutable(index);
}
inline void BlockWithLocationsProto::set_datanodeuuids(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
  datanodeuuids_.Mutable(index)->assign(value);
}
inline void BlockWithLocationsProto::set_datanodeuuids(int index, const char* value) {
  datanodeuuids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
}
inline void BlockWithLocationsProto::set_datanodeuuids(int index, const char* value, size_t size) {
  datanodeuuids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
}
inline ::std::string* BlockWithLocationsProto::add_datanodeuuids() {
  // @@protoc_insertion_point(field_add_mutable:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
  return datanodeuuids_.Add();
}
inline void BlockWithLocationsProto::add_datanodeuuids(const ::std::string& value) {
  datanodeuuids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
}
inline void BlockWithLocationsProto::add_datanodeuuids(const char* value) {
  datanodeuuids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
}
inline void BlockWithLocationsProto::add_datanodeuuids(const char* value, size_t size) {
  datanodeuuids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
BlockWithLocationsProto::datanodeuuids() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
  return datanodeuuids_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
BlockWithLocationsProto::mutable_datanodeuuids() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.BlockWithLocationsProto.datanodeUuids)
  return &datanodeuuids_;
}

// repeated string storageUuids = 3;
inline int BlockWithLocationsProto::storageuuids_size() const {
  return storageuuids_.size();
}
inline void BlockWithLocationsProto::clear_storageuuids() {
  storageuuids_.Clear();
}
inline const ::std::string& BlockWithLocationsProto::storageuuids(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
  return storageuuids_.Get(index);
}
inline ::std::string* BlockWithLocationsProto::mutable_storageuuids(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
  return storageuuids_.Mutable(index);
}
inline void BlockWithLocationsProto::set_storageuuids(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
  storageuuids_.Mutable(index)->assign(value);
}
inline void BlockWithLocationsProto::set_storageuuids(int index, const char* value) {
  storageuuids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
}
inline void BlockWithLocationsProto::set_storageuuids(int index, const char* value, size_t size) {
  storageuuids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
}
inline ::std::string* BlockWithLocationsProto::add_storageuuids() {
  // @@protoc_insertion_point(field_add_mutable:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
  return storageuuids_.Add();
}
inline void BlockWithLocationsProto::add_storageuuids(const ::std::string& value) {
  storageuuids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
}
inline void BlockWithLocationsProto::add_storageuuids(const char* value) {
  storageuuids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
}
inline void BlockWithLocationsProto::add_storageuuids(const char* value, size_t size) {
  storageuuids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
BlockWithLocationsProto::storageuuids() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
  return storageuuids_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
BlockWithLocationsProto::mutable_storageuuids() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.BlockWithLocationsProto.storageUuids)
  return &storageuuids_;
}

// repeated .hadoop.hdfs.StorageTypeProto storageTypes = 4;
inline int BlockWithLocationsProto::storagetypes_size() const {
  return storagetypes_.size();
}
inline void BlockWithLocationsProto::clear_storagetypes() {
  storagetypes_.Clear();
}
inline ::hadoop::hdfs::StorageTypeProto BlockWithLocationsProto::storagetypes(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockWithLocationsProto.storageTypes)
  return static_cast< ::hadoop::hdfs::StorageTypeProto >(storagetypes_.Get(index));
}
inline void BlockWithLocationsProto::set_storagetypes(int index, ::hadoop::hdfs::StorageTypeProto value) {
  assert(::hadoop::hdfs::StorageTypeProto_IsValid(value));
  storagetypes_.Set(index, value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockWithLocationsProto.storageTypes)
}
inline void BlockWithLocationsProto::add_storagetypes(::hadoop::hdfs::StorageTypeProto value) {
  assert(::hadoop::hdfs::StorageTypeProto_IsValid(value));
  storagetypes_.Add(value);
  // @@protoc_insertion_point(field_add:hadoop.hdfs.BlockWithLocationsProto.storageTypes)
}
inline const ::google::protobuf::RepeatedField<int>&
BlockWithLocationsProto::storagetypes() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.BlockWithLocationsProto.storageTypes)
  return storagetypes_;
}
inline ::google::protobuf::RepeatedField<int>*
BlockWithLocationsProto::mutable_storagetypes() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.BlockWithLocationsProto.storageTypes)
  return &storagetypes_;
}

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

// BlocksWithLocationsProto

// repeated .hadoop.hdfs.BlockWithLocationsProto blocks = 1;
inline int BlocksWithLocationsProto::blocks_size() const {
  return blocks_.size();
}
inline void BlocksWithLocationsProto::clear_blocks() {
  blocks_.Clear();
}
inline const ::hadoop::hdfs::BlockWithLocationsProto& BlocksWithLocationsProto::blocks(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlocksWithLocationsProto.blocks)
  return blocks_.Get(index);
}
inline ::hadoop::hdfs::BlockWithLocationsProto* BlocksWithLocationsProto::mutable_blocks(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlocksWithLocationsProto.blocks)
  return blocks_.Mutable(index);
}
inline ::hadoop::hdfs::BlockWithLocationsProto* BlocksWithLocationsProto::add_blocks() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.BlocksWithLocationsProto.blocks)
  return blocks_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockWithLocationsProto >*
BlocksWithLocationsProto::mutable_blocks() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.BlocksWithLocationsProto.blocks)
  return &blocks_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockWithLocationsProto >&
BlocksWithLocationsProto::blocks() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.BlocksWithLocationsProto.blocks)
  return blocks_;
}

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

// RemoteEditLogProto

// required uint64 startTxId = 1;
inline bool RemoteEditLogProto::has_starttxid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RemoteEditLogProto::set_has_starttxid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RemoteEditLogProto::clear_has_starttxid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RemoteEditLogProto::clear_starttxid() {
  starttxid_ = GOOGLE_ULONGLONG(0);
  clear_has_starttxid();
}
inline ::google::protobuf::uint64 RemoteEditLogProto::starttxid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoteEditLogProto.startTxId)
  return starttxid_;
}
inline void RemoteEditLogProto::set_starttxid(::google::protobuf::uint64 value) {
  set_has_starttxid();
  starttxid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.RemoteEditLogProto.startTxId)
}

// required uint64 endTxId = 2;
inline bool RemoteEditLogProto::has_endtxid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RemoteEditLogProto::set_has_endtxid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RemoteEditLogProto::clear_has_endtxid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RemoteEditLogProto::clear_endtxid() {
  endtxid_ = GOOGLE_ULONGLONG(0);
  clear_has_endtxid();
}
inline ::google::protobuf::uint64 RemoteEditLogProto::endtxid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoteEditLogProto.endTxId)
  return endtxid_;
}
inline void RemoteEditLogProto::set_endtxid(::google::protobuf::uint64 value) {
  set_has_endtxid();
  endtxid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.RemoteEditLogProto.endTxId)
}

// optional bool isInProgress = 3 [default = false];
inline bool RemoteEditLogProto::has_isinprogress() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RemoteEditLogProto::set_has_isinprogress() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RemoteEditLogProto::clear_has_isinprogress() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RemoteEditLogProto::clear_isinprogress() {
  isinprogress_ = false;
  clear_has_isinprogress();
}
inline bool RemoteEditLogProto::isinprogress() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoteEditLogProto.isInProgress)
  return isinprogress_;
}
inline void RemoteEditLogProto::set_isinprogress(bool value) {
  set_has_isinprogress();
  isinprogress_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.RemoteEditLogProto.isInProgress)
}

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

// RemoteEditLogManifestProto

// repeated .hadoop.hdfs.RemoteEditLogProto logs = 1;
inline int RemoteEditLogManifestProto::logs_size() const {
  return logs_.size();
}
inline void RemoteEditLogManifestProto::clear_logs() {
  logs_.Clear();
}
inline const ::hadoop::hdfs::RemoteEditLogProto& RemoteEditLogManifestProto::logs(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoteEditLogManifestProto.logs)
  return logs_.Get(index);
}
inline ::hadoop::hdfs::RemoteEditLogProto* RemoteEditLogManifestProto::mutable_logs(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RemoteEditLogManifestProto.logs)
  return logs_.Mutable(index);
}
inline ::hadoop::hdfs::RemoteEditLogProto* RemoteEditLogManifestProto::add_logs() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.RemoteEditLogManifestProto.logs)
  return logs_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::RemoteEditLogProto >*
RemoteEditLogManifestProto::mutable_logs() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.RemoteEditLogManifestProto.logs)
  return &logs_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::RemoteEditLogProto >&
RemoteEditLogManifestProto::logs() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.RemoteEditLogManifestProto.logs)
  return logs_;
}

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

// NamespaceInfoProto

// required string buildVersion = 1;
inline bool NamespaceInfoProto::has_buildversion() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NamespaceInfoProto::set_has_buildversion() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NamespaceInfoProto::clear_has_buildversion() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NamespaceInfoProto::clear_buildversion() {
  buildversion_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_buildversion();
}
inline const ::std::string& NamespaceInfoProto::buildversion() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamespaceInfoProto.buildVersion)
  return buildversion_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamespaceInfoProto::set_buildversion(const ::std::string& value) {
  set_has_buildversion();
  buildversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamespaceInfoProto.buildVersion)
}
inline void NamespaceInfoProto::set_buildversion(const char* value) {
  set_has_buildversion();
  buildversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.NamespaceInfoProto.buildVersion)
}
inline void NamespaceInfoProto::set_buildversion(const char* value, size_t size) {
  set_has_buildversion();
  buildversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.NamespaceInfoProto.buildVersion)
}
inline ::std::string* NamespaceInfoProto::mutable_buildversion() {
  set_has_buildversion();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.NamespaceInfoProto.buildVersion)
  return buildversion_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NamespaceInfoProto::release_buildversion() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.NamespaceInfoProto.buildVersion)
  clear_has_buildversion();
  return buildversion_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamespaceInfoProto::set_allocated_buildversion(::std::string* buildversion) {
  if (buildversion != NULL) {
    set_has_buildversion();
  } else {
    clear_has_buildversion();
  }
  buildversion_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), buildversion);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.NamespaceInfoProto.buildVersion)
}

// required uint32 unused = 2;
inline bool NamespaceInfoProto::has_unused() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NamespaceInfoProto::set_has_unused() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NamespaceInfoProto::clear_has_unused() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NamespaceInfoProto::clear_unused() {
  unused_ = 0u;
  clear_has_unused();
}
inline ::google::protobuf::uint32 NamespaceInfoProto::unused() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamespaceInfoProto.unused)
  return unused_;
}
inline void NamespaceInfoProto::set_unused(::google::protobuf::uint32 value) {
  set_has_unused();
  unused_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamespaceInfoProto.unused)
}

// required string blockPoolID = 3;
inline bool NamespaceInfoProto::has_blockpoolid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NamespaceInfoProto::set_has_blockpoolid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NamespaceInfoProto::clear_has_blockpoolid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NamespaceInfoProto::clear_blockpoolid() {
  blockpoolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_blockpoolid();
}
inline const ::std::string& NamespaceInfoProto::blockpoolid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamespaceInfoProto.blockPoolID)
  return blockpoolid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamespaceInfoProto::set_blockpoolid(const ::std::string& value) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamespaceInfoProto.blockPoolID)
}
inline void NamespaceInfoProto::set_blockpoolid(const char* value) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.NamespaceInfoProto.blockPoolID)
}
inline void NamespaceInfoProto::set_blockpoolid(const char* value, size_t size) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.NamespaceInfoProto.blockPoolID)
}
inline ::std::string* NamespaceInfoProto::mutable_blockpoolid() {
  set_has_blockpoolid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.NamespaceInfoProto.blockPoolID)
  return blockpoolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NamespaceInfoProto::release_blockpoolid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.NamespaceInfoProto.blockPoolID)
  clear_has_blockpoolid();
  return blockpoolid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamespaceInfoProto::set_allocated_blockpoolid(::std::string* blockpoolid) {
  if (blockpoolid != NULL) {
    set_has_blockpoolid();
  } else {
    clear_has_blockpoolid();
  }
  blockpoolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockpoolid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.NamespaceInfoProto.blockPoolID)
}

// required .hadoop.hdfs.StorageInfoProto storageInfo = 4;
inline bool NamespaceInfoProto::has_storageinfo() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NamespaceInfoProto::set_has_storageinfo() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NamespaceInfoProto::clear_has_storageinfo() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NamespaceInfoProto::clear_storageinfo() {
  if (storageinfo_ != NULL) storageinfo_->::hadoop::hdfs::StorageInfoProto::Clear();
  clear_has_storageinfo();
}
inline const ::hadoop::hdfs::StorageInfoProto& NamespaceInfoProto::storageinfo() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamespaceInfoProto.storageInfo)
  return storageinfo_ != NULL ? *storageinfo_ : *default_instance_->storageinfo_;
}
inline ::hadoop::hdfs::StorageInfoProto* NamespaceInfoProto::mutable_storageinfo() {
  set_has_storageinfo();
  if (storageinfo_ == NULL) {
    storageinfo_ = new ::hadoop::hdfs::StorageInfoProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.NamespaceInfoProto.storageInfo)
  return storageinfo_;
}
inline ::hadoop::hdfs::StorageInfoProto* NamespaceInfoProto::release_storageinfo() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.NamespaceInfoProto.storageInfo)
  clear_has_storageinfo();
  ::hadoop::hdfs::StorageInfoProto* temp = storageinfo_;
  storageinfo_ = NULL;
  return temp;
}
inline void NamespaceInfoProto::set_allocated_storageinfo(::hadoop::hdfs::StorageInfoProto* storageinfo) {
  delete storageinfo_;
  storageinfo_ = storageinfo;
  if (storageinfo) {
    set_has_storageinfo();
  } else {
    clear_has_storageinfo();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.NamespaceInfoProto.storageInfo)
}

// required string softwareVersion = 5;
inline bool NamespaceInfoProto::has_softwareversion() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void NamespaceInfoProto::set_has_softwareversion() {
  _has_bits_[0] |= 0x00000010u;
}
inline void NamespaceInfoProto::clear_has_softwareversion() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void NamespaceInfoProto::clear_softwareversion() {
  softwareversion_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_softwareversion();
}
inline const ::std::string& NamespaceInfoProto::softwareversion() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamespaceInfoProto.softwareVersion)
  return softwareversion_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamespaceInfoProto::set_softwareversion(const ::std::string& value) {
  set_has_softwareversion();
  softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamespaceInfoProto.softwareVersion)
}
inline void NamespaceInfoProto::set_softwareversion(const char* value) {
  set_has_softwareversion();
  softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.NamespaceInfoProto.softwareVersion)
}
inline void NamespaceInfoProto::set_softwareversion(const char* value, size_t size) {
  set_has_softwareversion();
  softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.NamespaceInfoProto.softwareVersion)
}
inline ::std::string* NamespaceInfoProto::mutable_softwareversion() {
  set_has_softwareversion();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.NamespaceInfoProto.softwareVersion)
  return softwareversion_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NamespaceInfoProto::release_softwareversion() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.NamespaceInfoProto.softwareVersion)
  clear_has_softwareversion();
  return softwareversion_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NamespaceInfoProto::set_allocated_softwareversion(::std::string* softwareversion) {
  if (softwareversion != NULL) {
    set_has_softwareversion();
  } else {
    clear_has_softwareversion();
  }
  softwareversion_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), softwareversion);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.NamespaceInfoProto.softwareVersion)
}

// optional uint64 capabilities = 6 [default = 0];
inline bool NamespaceInfoProto::has_capabilities() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void NamespaceInfoProto::set_has_capabilities() {
  _has_bits_[0] |= 0x00000020u;
}
inline void NamespaceInfoProto::clear_has_capabilities() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void NamespaceInfoProto::clear_capabilities() {
  capabilities_ = GOOGLE_ULONGLONG(0);
  clear_has_capabilities();
}
inline ::google::protobuf::uint64 NamespaceInfoProto::capabilities() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.NamespaceInfoProto.capabilities)
  return capabilities_;
}
inline void NamespaceInfoProto::set_capabilities(::google::protobuf::uint64 value) {
  set_has_capabilities();
  capabilities_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.NamespaceInfoProto.capabilities)
}

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

// BlockKeyProto

// required uint32 keyId = 1;
inline bool BlockKeyProto::has_keyid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlockKeyProto::set_has_keyid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BlockKeyProto::clear_has_keyid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BlockKeyProto::clear_keyid() {
  keyid_ = 0u;
  clear_has_keyid();
}
inline ::google::protobuf::uint32 BlockKeyProto::keyid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockKeyProto.keyId)
  return keyid_;
}
inline void BlockKeyProto::set_keyid(::google::protobuf::uint32 value) {
  set_has_keyid();
  keyid_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockKeyProto.keyId)
}

// required uint64 expiryDate = 2;
inline bool BlockKeyProto::has_expirydate() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BlockKeyProto::set_has_expirydate() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BlockKeyProto::clear_has_expirydate() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BlockKeyProto::clear_expirydate() {
  expirydate_ = GOOGLE_ULONGLONG(0);
  clear_has_expirydate();
}
inline ::google::protobuf::uint64 BlockKeyProto::expirydate() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockKeyProto.expiryDate)
  return expirydate_;
}
inline void BlockKeyProto::set_expirydate(::google::protobuf::uint64 value) {
  set_has_expirydate();
  expirydate_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockKeyProto.expiryDate)
}

// optional bytes keyBytes = 3;
inline bool BlockKeyProto::has_keybytes() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BlockKeyProto::set_has_keybytes() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BlockKeyProto::clear_has_keybytes() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BlockKeyProto::clear_keybytes() {
  keybytes_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_keybytes();
}
inline const ::std::string& BlockKeyProto::keybytes() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.BlockKeyProto.keyBytes)
  return keybytes_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BlockKeyProto::set_keybytes(const ::std::string& value) {
  set_has_keybytes();
  keybytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.BlockKeyProto.keyBytes)
}
inline void BlockKeyProto::set_keybytes(const char* value) {
  set_has_keybytes();
  keybytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.BlockKeyProto.keyBytes)
}
inline void BlockKeyProto::set_keybytes(const void* value, size_t size) {
  set_has_keybytes();
  keybytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.BlockKeyProto.keyBytes)
}
inline ::std::string* BlockKeyProto::mutable_keybytes() {
  set_has_keybytes();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.BlockKeyProto.keyBytes)
  return keybytes_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* BlockKeyProto::release_keybytes() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.BlockKeyProto.keyBytes)
  clear_has_keybytes();
  return keybytes_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BlockKeyProto::set_allocated_keybytes(::std::string* keybytes) {
  if (keybytes != NULL) {
    set_has_keybytes();
  } else {
    clear_has_keybytes();
  }
  keybytes_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), keybytes);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.BlockKeyProto.keyBytes)
}

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

// ExportedBlockKeysProto

// required bool isBlockTokenEnabled = 1;
inline bool ExportedBlockKeysProto::has_isblocktokenenabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ExportedBlockKeysProto::set_has_isblocktokenenabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ExportedBlockKeysProto::clear_has_isblocktokenenabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ExportedBlockKeysProto::clear_isblocktokenenabled() {
  isblocktokenenabled_ = false;
  clear_has_isblocktokenenabled();
}
inline bool ExportedBlockKeysProto::isblocktokenenabled() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExportedBlockKeysProto.isBlockTokenEnabled)
  return isblocktokenenabled_;
}
inline void ExportedBlockKeysProto::set_isblocktokenenabled(bool value) {
  set_has_isblocktokenenabled();
  isblocktokenenabled_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ExportedBlockKeysProto.isBlockTokenEnabled)
}

// required uint64 keyUpdateInterval = 2;
inline bool ExportedBlockKeysProto::has_keyupdateinterval() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ExportedBlockKeysProto::set_has_keyupdateinterval() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ExportedBlockKeysProto::clear_has_keyupdateinterval() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ExportedBlockKeysProto::clear_keyupdateinterval() {
  keyupdateinterval_ = GOOGLE_ULONGLONG(0);
  clear_has_keyupdateinterval();
}
inline ::google::protobuf::uint64 ExportedBlockKeysProto::keyupdateinterval() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExportedBlockKeysProto.keyUpdateInterval)
  return keyupdateinterval_;
}
inline void ExportedBlockKeysProto::set_keyupdateinterval(::google::protobuf::uint64 value) {
  set_has_keyupdateinterval();
  keyupdateinterval_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ExportedBlockKeysProto.keyUpdateInterval)
}

// required uint64 tokenLifeTime = 3;
inline bool ExportedBlockKeysProto::has_tokenlifetime() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ExportedBlockKeysProto::set_has_tokenlifetime() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ExportedBlockKeysProto::clear_has_tokenlifetime() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ExportedBlockKeysProto::clear_tokenlifetime() {
  tokenlifetime_ = GOOGLE_ULONGLONG(0);
  clear_has_tokenlifetime();
}
inline ::google::protobuf::uint64 ExportedBlockKeysProto::tokenlifetime() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExportedBlockKeysProto.tokenLifeTime)
  return tokenlifetime_;
}
inline void ExportedBlockKeysProto::set_tokenlifetime(::google::protobuf::uint64 value) {
  set_has_tokenlifetime();
  tokenlifetime_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.ExportedBlockKeysProto.tokenLifeTime)
}

// required .hadoop.hdfs.BlockKeyProto currentKey = 4;
inline bool ExportedBlockKeysProto::has_currentkey() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ExportedBlockKeysProto::set_has_currentkey() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ExportedBlockKeysProto::clear_has_currentkey() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ExportedBlockKeysProto::clear_currentkey() {
  if (currentkey_ != NULL) currentkey_->::hadoop::hdfs::BlockKeyProto::Clear();
  clear_has_currentkey();
}
inline const ::hadoop::hdfs::BlockKeyProto& ExportedBlockKeysProto::currentkey() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExportedBlockKeysProto.currentKey)
  return currentkey_ != NULL ? *currentkey_ : *default_instance_->currentkey_;
}
inline ::hadoop::hdfs::BlockKeyProto* ExportedBlockKeysProto::mutable_currentkey() {
  set_has_currentkey();
  if (currentkey_ == NULL) {
    currentkey_ = new ::hadoop::hdfs::BlockKeyProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ExportedBlockKeysProto.currentKey)
  return currentkey_;
}
inline ::hadoop::hdfs::BlockKeyProto* ExportedBlockKeysProto::release_currentkey() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.ExportedBlockKeysProto.currentKey)
  clear_has_currentkey();
  ::hadoop::hdfs::BlockKeyProto* temp = currentkey_;
  currentkey_ = NULL;
  return temp;
}
inline void ExportedBlockKeysProto::set_allocated_currentkey(::hadoop::hdfs::BlockKeyProto* currentkey) {
  delete currentkey_;
  currentkey_ = currentkey;
  if (currentkey) {
    set_has_currentkey();
  } else {
    clear_has_currentkey();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ExportedBlockKeysProto.currentKey)
}

// repeated .hadoop.hdfs.BlockKeyProto allKeys = 5;
inline int ExportedBlockKeysProto::allkeys_size() const {
  return allkeys_.size();
}
inline void ExportedBlockKeysProto::clear_allkeys() {
  allkeys_.Clear();
}
inline const ::hadoop::hdfs::BlockKeyProto& ExportedBlockKeysProto::allkeys(int index) const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.ExportedBlockKeysProto.allKeys)
  return allkeys_.Get(index);
}
inline ::hadoop::hdfs::BlockKeyProto* ExportedBlockKeysProto::mutable_allkeys(int index) {
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ExportedBlockKeysProto.allKeys)
  return allkeys_.Mutable(index);
}
inline ::hadoop::hdfs::BlockKeyProto* ExportedBlockKeysProto::add_allkeys() {
  // @@protoc_insertion_point(field_add:hadoop.hdfs.ExportedBlockKeysProto.allKeys)
  return allkeys_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockKeyProto >*
ExportedBlockKeysProto::mutable_allkeys() {
  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.ExportedBlockKeysProto.allKeys)
  return &allkeys_;
}
inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::BlockKeyProto >&
ExportedBlockKeysProto::allkeys() const {
  // @@protoc_insertion_point(field_list:hadoop.hdfs.ExportedBlockKeysProto.allKeys)
  return allkeys_;
}

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

// RecoveringBlockProto

// required uint64 newGenStamp = 1;
inline bool RecoveringBlockProto::has_newgenstamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RecoveringBlockProto::set_has_newgenstamp() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RecoveringBlockProto::clear_has_newgenstamp() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RecoveringBlockProto::clear_newgenstamp() {
  newgenstamp_ = GOOGLE_ULONGLONG(0);
  clear_has_newgenstamp();
}
inline ::google::protobuf::uint64 RecoveringBlockProto::newgenstamp() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RecoveringBlockProto.newGenStamp)
  return newgenstamp_;
}
inline void RecoveringBlockProto::set_newgenstamp(::google::protobuf::uint64 value) {
  set_has_newgenstamp();
  newgenstamp_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.RecoveringBlockProto.newGenStamp)
}

// required .hadoop.hdfs.LocatedBlockProto block = 2;
inline bool RecoveringBlockProto::has_block() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RecoveringBlockProto::set_has_block() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RecoveringBlockProto::clear_has_block() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RecoveringBlockProto::clear_block() {
  if (block_ != NULL) block_->::hadoop::hdfs::LocatedBlockProto::Clear();
  clear_has_block();
}
inline const ::hadoop::hdfs::LocatedBlockProto& RecoveringBlockProto::block() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RecoveringBlockProto.block)
  return block_ != NULL ? *block_ : *default_instance_->block_;
}
inline ::hadoop::hdfs::LocatedBlockProto* RecoveringBlockProto::mutable_block() {
  set_has_block();
  if (block_ == NULL) {
    block_ = new ::hadoop::hdfs::LocatedBlockProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RecoveringBlockProto.block)
  return block_;
}
inline ::hadoop::hdfs::LocatedBlockProto* RecoveringBlockProto::release_block() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.RecoveringBlockProto.block)
  clear_has_block();
  ::hadoop::hdfs::LocatedBlockProto* temp = block_;
  block_ = NULL;
  return temp;
}
inline void RecoveringBlockProto::set_allocated_block(::hadoop::hdfs::LocatedBlockProto* block) {
  delete block_;
  block_ = block;
  if (block) {
    set_has_block();
  } else {
    clear_has_block();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.RecoveringBlockProto.block)
}

// optional .hadoop.hdfs.BlockProto truncateBlock = 3;
inline bool RecoveringBlockProto::has_truncateblock() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RecoveringBlockProto::set_has_truncateblock() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RecoveringBlockProto::clear_has_truncateblock() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RecoveringBlockProto::clear_truncateblock() {
  if (truncateblock_ != NULL) truncateblock_->::hadoop::hdfs::BlockProto::Clear();
  clear_has_truncateblock();
}
inline const ::hadoop::hdfs::BlockProto& RecoveringBlockProto::truncateblock() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RecoveringBlockProto.truncateBlock)
  return truncateblock_ != NULL ? *truncateblock_ : *default_instance_->truncateblock_;
}
inline ::hadoop::hdfs::BlockProto* RecoveringBlockProto::mutable_truncateblock() {
  set_has_truncateblock();
  if (truncateblock_ == NULL) {
    truncateblock_ = new ::hadoop::hdfs::BlockProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RecoveringBlockProto.truncateBlock)
  return truncateblock_;
}
inline ::hadoop::hdfs::BlockProto* RecoveringBlockProto::release_truncateblock() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.RecoveringBlockProto.truncateBlock)
  clear_has_truncateblock();
  ::hadoop::hdfs::BlockProto* temp = truncateblock_;
  truncateblock_ = NULL;
  return temp;
}
inline void RecoveringBlockProto::set_allocated_truncateblock(::hadoop::hdfs::BlockProto* truncateblock) {
  delete truncateblock_;
  truncateblock_ = truncateblock;
  if (truncateblock) {
    set_has_truncateblock();
  } else {
    clear_has_truncateblock();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.RecoveringBlockProto.truncateBlock)
}

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

// VersionRequestProto

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

// VersionResponseProto

// required .hadoop.hdfs.NamespaceInfoProto info = 1;
inline bool VersionResponseProto::has_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VersionResponseProto::set_has_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void VersionResponseProto::clear_has_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void VersionResponseProto::clear_info() {
  if (info_ != NULL) info_->::hadoop::hdfs::NamespaceInfoProto::Clear();
  clear_has_info();
}
inline const ::hadoop::hdfs::NamespaceInfoProto& VersionResponseProto::info() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.VersionResponseProto.info)
  return info_ != NULL ? *info_ : *default_instance_->info_;
}
inline ::hadoop::hdfs::NamespaceInfoProto* VersionResponseProto::mutable_info() {
  set_has_info();
  if (info_ == NULL) {
    info_ = new ::hadoop::hdfs::NamespaceInfoProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.VersionResponseProto.info)
  return info_;
}
inline ::hadoop::hdfs::NamespaceInfoProto* VersionResponseProto::release_info() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.VersionResponseProto.info)
  clear_has_info();
  ::hadoop::hdfs::NamespaceInfoProto* temp = info_;
  info_ = NULL;
  return temp;
}
inline void VersionResponseProto::set_allocated_info(::hadoop::hdfs::NamespaceInfoProto* info) {
  delete info_;
  info_ = info;
  if (info) {
    set_has_info();
  } else {
    clear_has_info();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.VersionResponseProto.info)
}

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

// SnapshotInfoProto

// required string snapshotName = 1;
inline bool SnapshotInfoProto::has_snapshotname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SnapshotInfoProto::set_has_snapshotname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SnapshotInfoProto::clear_has_snapshotname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SnapshotInfoProto::clear_snapshotname() {
  snapshotname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_snapshotname();
}
inline const ::std::string& SnapshotInfoProto::snapshotname() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotInfoProto.snapshotName)
  return snapshotname_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_snapshotname(const ::std::string& value) {
  set_has_snapshotname();
  snapshotname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotInfoProto.snapshotName)
}
inline void SnapshotInfoProto::set_snapshotname(const char* value) {
  set_has_snapshotname();
  snapshotname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotInfoProto.snapshotName)
}
inline void SnapshotInfoProto::set_snapshotname(const char* value, size_t size) {
  set_has_snapshotname();
  snapshotname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotInfoProto.snapshotName)
}
inline ::std::string* SnapshotInfoProto::mutable_snapshotname() {
  set_has_snapshotname();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotInfoProto.snapshotName)
  return snapshotname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotInfoProto::release_snapshotname() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotInfoProto.snapshotName)
  clear_has_snapshotname();
  return snapshotname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_allocated_snapshotname(::std::string* snapshotname) {
  if (snapshotname != NULL) {
    set_has_snapshotname();
  } else {
    clear_has_snapshotname();
  }
  snapshotname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshotname);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotInfoProto.snapshotName)
}

// required string snapshotRoot = 2;
inline bool SnapshotInfoProto::has_snapshotroot() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SnapshotInfoProto::set_has_snapshotroot() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SnapshotInfoProto::clear_has_snapshotroot() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SnapshotInfoProto::clear_snapshotroot() {
  snapshotroot_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_snapshotroot();
}
inline const ::std::string& SnapshotInfoProto::snapshotroot() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotInfoProto.snapshotRoot)
  return snapshotroot_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_snapshotroot(const ::std::string& value) {
  set_has_snapshotroot();
  snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotInfoProto.snapshotRoot)
}
inline void SnapshotInfoProto::set_snapshotroot(const char* value) {
  set_has_snapshotroot();
  snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotInfoProto.snapshotRoot)
}
inline void SnapshotInfoProto::set_snapshotroot(const char* value, size_t size) {
  set_has_snapshotroot();
  snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotInfoProto.snapshotRoot)
}
inline ::std::string* SnapshotInfoProto::mutable_snapshotroot() {
  set_has_snapshotroot();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotInfoProto.snapshotRoot)
  return snapshotroot_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotInfoProto::release_snapshotroot() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotInfoProto.snapshotRoot)
  clear_has_snapshotroot();
  return snapshotroot_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_allocated_snapshotroot(::std::string* snapshotroot) {
  if (snapshotroot != NULL) {
    set_has_snapshotroot();
  } else {
    clear_has_snapshotroot();
  }
  snapshotroot_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshotroot);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotInfoProto.snapshotRoot)
}

// required .hadoop.hdfs.FsPermissionProto permission = 3;
inline bool SnapshotInfoProto::has_permission() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SnapshotInfoProto::set_has_permission() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SnapshotInfoProto::clear_has_permission() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SnapshotInfoProto::clear_permission() {
  if (permission_ != NULL) permission_->::hadoop::hdfs::FsPermissionProto::Clear();
  clear_has_permission();
}
inline const ::hadoop::hdfs::FsPermissionProto& SnapshotInfoProto::permission() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotInfoProto.permission)
  return permission_ != NULL ? *permission_ : *default_instance_->permission_;
}
inline ::hadoop::hdfs::FsPermissionProto* SnapshotInfoProto::mutable_permission() {
  set_has_permission();
  if (permission_ == NULL) {
    permission_ = new ::hadoop::hdfs::FsPermissionProto;
  }
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotInfoProto.permission)
  return permission_;
}
inline ::hadoop::hdfs::FsPermissionProto* SnapshotInfoProto::release_permission() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotInfoProto.permission)
  clear_has_permission();
  ::hadoop::hdfs::FsPermissionProto* temp = permission_;
  permission_ = NULL;
  return temp;
}
inline void SnapshotInfoProto::set_allocated_permission(::hadoop::hdfs::FsPermissionProto* permission) {
  delete permission_;
  permission_ = permission;
  if (permission) {
    set_has_permission();
  } else {
    clear_has_permission();
  }
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotInfoProto.permission)
}

// required string owner = 4;
inline bool SnapshotInfoProto::has_owner() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SnapshotInfoProto::set_has_owner() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SnapshotInfoProto::clear_has_owner() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SnapshotInfoProto::clear_owner() {
  owner_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_owner();
}
inline const ::std::string& SnapshotInfoProto::owner() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotInfoProto.owner)
  return owner_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_owner(const ::std::string& value) {
  set_has_owner();
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotInfoProto.owner)
}
inline void SnapshotInfoProto::set_owner(const char* value) {
  set_has_owner();
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotInfoProto.owner)
}
inline void SnapshotInfoProto::set_owner(const char* value, size_t size) {
  set_has_owner();
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotInfoProto.owner)
}
inline ::std::string* SnapshotInfoProto::mutable_owner() {
  set_has_owner();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotInfoProto.owner)
  return owner_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotInfoProto::release_owner() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotInfoProto.owner)
  clear_has_owner();
  return owner_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_allocated_owner(::std::string* owner) {
  if (owner != NULL) {
    set_has_owner();
  } else {
    clear_has_owner();
  }
  owner_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), owner);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotInfoProto.owner)
}

// required string group = 5;
inline bool SnapshotInfoProto::has_group() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SnapshotInfoProto::set_has_group() {
  _has_bits_[0] |= 0x00000010u;
}
inline void SnapshotInfoProto::clear_has_group() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void SnapshotInfoProto::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_group();
}
inline const ::std::string& SnapshotInfoProto::group() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotInfoProto.group)
  return group_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_group(const ::std::string& value) {
  set_has_group();
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotInfoProto.group)
}
inline void SnapshotInfoProto::set_group(const char* value) {
  set_has_group();
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotInfoProto.group)
}
inline void SnapshotInfoProto::set_group(const char* value, size_t size) {
  set_has_group();
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotInfoProto.group)
}
inline ::std::string* SnapshotInfoProto::mutable_group() {
  set_has_group();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotInfoProto.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotInfoProto::release_group() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotInfoProto.group)
  clear_has_group();
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    set_has_group();
  } else {
    clear_has_group();
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotInfoProto.group)
}

// required string createTime = 6;
inline bool SnapshotInfoProto::has_createtime() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void SnapshotInfoProto::set_has_createtime() {
  _has_bits_[0] |= 0x00000020u;
}
inline void SnapshotInfoProto::clear_has_createtime() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void SnapshotInfoProto::clear_createtime() {
  createtime_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_createtime();
}
inline const ::std::string& SnapshotInfoProto::createtime() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.SnapshotInfoProto.createTime)
  return createtime_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_createtime(const ::std::string& value) {
  set_has_createtime();
  createtime_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.SnapshotInfoProto.createTime)
}
inline void SnapshotInfoProto::set_createtime(const char* value) {
  set_has_createtime();
  createtime_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SnapshotInfoProto.createTime)
}
inline void SnapshotInfoProto::set_createtime(const char* value, size_t size) {
  set_has_createtime();
  createtime_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SnapshotInfoProto.createTime)
}
inline ::std::string* SnapshotInfoProto::mutable_createtime() {
  set_has_createtime();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SnapshotInfoProto.createTime)
  return createtime_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SnapshotInfoProto::release_createtime() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.SnapshotInfoProto.createTime)
  clear_has_createtime();
  return createtime_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SnapshotInfoProto::set_allocated_createtime(::std::string* createtime) {
  if (createtime != NULL) {
    set_has_createtime();
  } else {
    clear_has_createtime();
  }
  createtime_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), createtime);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SnapshotInfoProto.createTime)
}

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

// RollingUpgradeStatusProto

// required string blockPoolId = 1;
inline bool RollingUpgradeStatusProto::has_blockpoolid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RollingUpgradeStatusProto::set_has_blockpoolid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RollingUpgradeStatusProto::clear_has_blockpoolid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RollingUpgradeStatusProto::clear_blockpoolid() {
  blockpoolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_blockpoolid();
}
inline const ::std::string& RollingUpgradeStatusProto::blockpoolid() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RollingUpgradeStatusProto.blockPoolId)
  return blockpoolid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RollingUpgradeStatusProto::set_blockpoolid(const ::std::string& value) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:hadoop.hdfs.RollingUpgradeStatusProto.blockPoolId)
}
inline void RollingUpgradeStatusProto::set_blockpoolid(const char* value) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.RollingUpgradeStatusProto.blockPoolId)
}
inline void RollingUpgradeStatusProto::set_blockpoolid(const char* value, size_t size) {
  set_has_blockpoolid();
  blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.RollingUpgradeStatusProto.blockPoolId)
}
inline ::std::string* RollingUpgradeStatusProto::mutable_blockpoolid() {
  set_has_blockpoolid();
  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RollingUpgradeStatusProto.blockPoolId)
  return blockpoolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RollingUpgradeStatusProto::release_blockpoolid() {
  // @@protoc_insertion_point(field_release:hadoop.hdfs.RollingUpgradeStatusProto.blockPoolId)
  clear_has_blockpoolid();
  return blockpoolid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RollingUpgradeStatusProto::set_allocated_blockpoolid(::std::string* blockpoolid) {
  if (blockpoolid != NULL) {
    set_has_blockpoolid();
  } else {
    clear_has_blockpoolid();
  }
  blockpoolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockpoolid);
  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.RollingUpgradeStatusProto.blockPoolId)
}

// optional bool finalized = 2 [default = false];
inline bool RollingUpgradeStatusProto::has_finalized() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RollingUpgradeStatusProto::set_has_finalized() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RollingUpgradeStatusProto::clear_has_finalized() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RollingUpgradeStatusProto::clear_finalized() {
  finalized_ = false;
  clear_has_finalized();
}
inline bool RollingUpgradeStatusProto::finalized() const {
  // @@protoc_insertion_point(field_get:hadoop.hdfs.RollingUpgradeStatusProto.finalized)
  return finalized_;
}
inline void RollingUpgradeStatusProto::set_finalized(bool value) {
  set_has_finalized();
  finalized_ = value;
  // @@protoc_insertion_point(field_set:hadoop.hdfs.RollingUpgradeStatusProto.finalized)
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace hdfs
}  // namespace hadoop

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::hadoop::hdfs::DatanodeInfoProto_AdminState> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::DatanodeInfoProto_AdminState>() {
  return ::hadoop::hdfs::DatanodeInfoProto_AdminState_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::DatanodeStorageProto_StorageState> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::DatanodeStorageProto_StorageState>() {
  return ::hadoop::hdfs::DatanodeStorageProto_StorageState_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::HdfsFileStatusProto_FileType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::HdfsFileStatusProto_FileType>() {
  return ::hadoop::hdfs::HdfsFileStatusProto_FileType_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto>() {
  return ::hadoop::hdfs::NamenodeRegistrationProto_NamenodeRoleProto_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::NamenodeCommandProto_Type> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::NamenodeCommandProto_Type>() {
  return ::hadoop::hdfs::NamenodeCommandProto_Type_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::StorageTypeProto> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::StorageTypeProto>() {
  return ::hadoop::hdfs::StorageTypeProto_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::CipherSuiteProto> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::CipherSuiteProto>() {
  return ::hadoop::hdfs::CipherSuiteProto_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::CryptoProtocolVersionProto> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::CryptoProtocolVersionProto>() {
  return ::hadoop::hdfs::CryptoProtocolVersionProto_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::ErasureCodingPolicyState> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::ErasureCodingPolicyState>() {
  return ::hadoop::hdfs::ErasureCodingPolicyState_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::ChecksumTypeProto> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::ChecksumTypeProto>() {
  return ::hadoop::hdfs::ChecksumTypeProto_descriptor();
}
template <> struct is_proto_enum< ::hadoop::hdfs::ReplicaStateProto> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::ReplicaStateProto>() {
  return ::hadoop::hdfs::ReplicaStateProto_descriptor();
}

}  // namespace protobuf
}  // namespace google
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_hdfs_2eproto__INCLUDED