1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: hdfs.proto
3
4#ifndef PROTOBUF_INCLUDED_hdfs_2eproto
5#define PROTOBUF_INCLUDED_hdfs_2eproto
6
7#include <string>
8
9#include <google/protobuf/stubs/common.h>
10
11#if GOOGLE_PROTOBUF_VERSION < 3006001
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/io/coded_stream.h>
23#include <google/protobuf/arena.h>
24#include <google/protobuf/arenastring.h>
25#include <google/protobuf/generated_message_table_driven.h>
26#include <google/protobuf/generated_message_util.h>
27#include <google/protobuf/inlined_string_field.h>
28#include <google/protobuf/metadata.h>
29#include <google/protobuf/message.h>
30#include <google/protobuf/repeated_field.h> // IWYU pragma: export
31#include <google/protobuf/extension_set.h> // IWYU pragma: export
32#include <google/protobuf/generated_enum_reflection.h>
33#include <google/protobuf/unknown_field_set.h>
34#include "Security.pb.h"
35// @@protoc_insertion_point(includes)
36#define PROTOBUF_INTERNAL_EXPORT_protobuf_hdfs_2eproto
37
38namespace protobuf_hdfs_2eproto {
39// Internal implementation detail -- do not use these members.
40struct TableStruct {
41 static const ::google::protobuf::internal::ParseTableField entries[];
42 static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
43 static const ::google::protobuf::internal::ParseTable schema[35];
44 static const ::google::protobuf::internal::FieldMetadata field_metadata[];
45 static const ::google::protobuf::internal::SerializationTable serialization_table[];
46 static const ::google::protobuf::uint32 offsets[];
47};
48void AddDescriptors();
49} // namespace protobuf_hdfs_2eproto
50namespace Hdfs {
51namespace Internal {
52class BlockKeyProto;
53class BlockKeyProtoDefaultTypeInternal;
54extern BlockKeyProtoDefaultTypeInternal _BlockKeyProto_default_instance_;
55class BlockProto;
56class BlockProtoDefaultTypeInternal;
57extern BlockProtoDefaultTypeInternal _BlockProto_default_instance_;
58class BlockWithLocationsProto;
59class BlockWithLocationsProtoDefaultTypeInternal;
60extern BlockWithLocationsProtoDefaultTypeInternal _BlockWithLocationsProto_default_instance_;
61class BlocksWithLocationsProto;
62class BlocksWithLocationsProtoDefaultTypeInternal;
63extern BlocksWithLocationsProtoDefaultTypeInternal _BlocksWithLocationsProto_default_instance_;
64class CheckpointCommandProto;
65class CheckpointCommandProtoDefaultTypeInternal;
66extern CheckpointCommandProtoDefaultTypeInternal _CheckpointCommandProto_default_instance_;
67class CheckpointSignatureProto;
68class CheckpointSignatureProtoDefaultTypeInternal;
69extern CheckpointSignatureProtoDefaultTypeInternal _CheckpointSignatureProto_default_instance_;
70class ContentSummaryProto;
71class ContentSummaryProtoDefaultTypeInternal;
72extern ContentSummaryProtoDefaultTypeInternal _ContentSummaryProto_default_instance_;
73class CorruptFileBlocksProto;
74class CorruptFileBlocksProtoDefaultTypeInternal;
75extern CorruptFileBlocksProtoDefaultTypeInternal _CorruptFileBlocksProto_default_instance_;
76class DataEncryptionKeyProto;
77class DataEncryptionKeyProtoDefaultTypeInternal;
78extern DataEncryptionKeyProtoDefaultTypeInternal _DataEncryptionKeyProto_default_instance_;
79class DatanodeIDProto;
80class DatanodeIDProtoDefaultTypeInternal;
81extern DatanodeIDProtoDefaultTypeInternal _DatanodeIDProto_default_instance_;
82class DatanodeInfoProto;
83class DatanodeInfoProtoDefaultTypeInternal;
84extern DatanodeInfoProtoDefaultTypeInternal _DatanodeInfoProto_default_instance_;
85class DatanodeInfosProto;
86class DatanodeInfosProtoDefaultTypeInternal;
87extern DatanodeInfosProtoDefaultTypeInternal _DatanodeInfosProto_default_instance_;
88class DirectoryListingProto;
89class DirectoryListingProtoDefaultTypeInternal;
90extern DirectoryListingProtoDefaultTypeInternal _DirectoryListingProto_default_instance_;
91class ExportedBlockKeysProto;
92class ExportedBlockKeysProtoDefaultTypeInternal;
93extern ExportedBlockKeysProtoDefaultTypeInternal _ExportedBlockKeysProto_default_instance_;
94class ExtendedBlockProto;
95class ExtendedBlockProtoDefaultTypeInternal;
96extern ExtendedBlockProtoDefaultTypeInternal _ExtendedBlockProto_default_instance_;
97class FsPermissionProto;
98class FsPermissionProtoDefaultTypeInternal;
99extern FsPermissionProtoDefaultTypeInternal _FsPermissionProto_default_instance_;
100class FsServerDefaultsProto;
101class FsServerDefaultsProtoDefaultTypeInternal;
102extern FsServerDefaultsProtoDefaultTypeInternal _FsServerDefaultsProto_default_instance_;
103class HdfsFileStatusProto;
104class HdfsFileStatusProtoDefaultTypeInternal;
105extern HdfsFileStatusProtoDefaultTypeInternal _HdfsFileStatusProto_default_instance_;
106class LocatedBlockProto;
107class LocatedBlockProtoDefaultTypeInternal;
108extern LocatedBlockProtoDefaultTypeInternal _LocatedBlockProto_default_instance_;
109class LocatedBlocksProto;
110class LocatedBlocksProtoDefaultTypeInternal;
111extern LocatedBlocksProtoDefaultTypeInternal _LocatedBlocksProto_default_instance_;
112class NamenodeCommandProto;
113class NamenodeCommandProtoDefaultTypeInternal;
114extern NamenodeCommandProtoDefaultTypeInternal _NamenodeCommandProto_default_instance_;
115class NamenodeRegistrationProto;
116class NamenodeRegistrationProtoDefaultTypeInternal;
117extern NamenodeRegistrationProtoDefaultTypeInternal _NamenodeRegistrationProto_default_instance_;
118class NamespaceInfoProto;
119class NamespaceInfoProtoDefaultTypeInternal;
120extern NamespaceInfoProtoDefaultTypeInternal _NamespaceInfoProto_default_instance_;
121class RecoveringBlockProto;
122class RecoveringBlockProtoDefaultTypeInternal;
123extern RecoveringBlockProtoDefaultTypeInternal _RecoveringBlockProto_default_instance_;
124class RemoteEditLogManifestProto;
125class RemoteEditLogManifestProtoDefaultTypeInternal;
126extern RemoteEditLogManifestProtoDefaultTypeInternal _RemoteEditLogManifestProto_default_instance_;
127class RemoteEditLogProto;
128class RemoteEditLogProtoDefaultTypeInternal;
129extern RemoteEditLogProtoDefaultTypeInternal _RemoteEditLogProto_default_instance_;
130class SnapshotDiffReportEntryProto;
131class SnapshotDiffReportEntryProtoDefaultTypeInternal;
132extern SnapshotDiffReportEntryProtoDefaultTypeInternal _SnapshotDiffReportEntryProto_default_instance_;
133class SnapshotDiffReportProto;
134class SnapshotDiffReportProtoDefaultTypeInternal;
135extern SnapshotDiffReportProtoDefaultTypeInternal _SnapshotDiffReportProto_default_instance_;
136class SnapshotInfoProto;
137class SnapshotInfoProtoDefaultTypeInternal;
138extern SnapshotInfoProtoDefaultTypeInternal _SnapshotInfoProto_default_instance_;
139class SnapshottableDirectoryListingProto;
140class SnapshottableDirectoryListingProtoDefaultTypeInternal;
141extern SnapshottableDirectoryListingProtoDefaultTypeInternal _SnapshottableDirectoryListingProto_default_instance_;
142class SnapshottableDirectoryStatusProto;
143class SnapshottableDirectoryStatusProtoDefaultTypeInternal;
144extern SnapshottableDirectoryStatusProtoDefaultTypeInternal _SnapshottableDirectoryStatusProto_default_instance_;
145class StorageInfoProto;
146class StorageInfoProtoDefaultTypeInternal;
147extern StorageInfoProtoDefaultTypeInternal _StorageInfoProto_default_instance_;
148class StorageUuidsProto;
149class StorageUuidsProtoDefaultTypeInternal;
150extern StorageUuidsProtoDefaultTypeInternal _StorageUuidsProto_default_instance_;
151class VersionRequestProto;
152class VersionRequestProtoDefaultTypeInternal;
153extern VersionRequestProtoDefaultTypeInternal _VersionRequestProto_default_instance_;
154class VersionResponseProto;
155class VersionResponseProtoDefaultTypeInternal;
156extern VersionResponseProtoDefaultTypeInternal _VersionResponseProto_default_instance_;
157} // namespace Internal
158} // namespace Hdfs
159namespace google {
160namespace protobuf {
161template<> ::Hdfs::Internal::BlockKeyProto* Arena::CreateMaybeMessage<::Hdfs::Internal::BlockKeyProto>(Arena*);
162template<> ::Hdfs::Internal::BlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::BlockProto>(Arena*);
163template<> ::Hdfs::Internal::BlockWithLocationsProto* Arena::CreateMaybeMessage<::Hdfs::Internal::BlockWithLocationsProto>(Arena*);
164template<> ::Hdfs::Internal::BlocksWithLocationsProto* Arena::CreateMaybeMessage<::Hdfs::Internal::BlocksWithLocationsProto>(Arena*);
165template<> ::Hdfs::Internal::CheckpointCommandProto* Arena::CreateMaybeMessage<::Hdfs::Internal::CheckpointCommandProto>(Arena*);
166template<> ::Hdfs::Internal::CheckpointSignatureProto* Arena::CreateMaybeMessage<::Hdfs::Internal::CheckpointSignatureProto>(Arena*);
167template<> ::Hdfs::Internal::ContentSummaryProto* Arena::CreateMaybeMessage<::Hdfs::Internal::ContentSummaryProto>(Arena*);
168template<> ::Hdfs::Internal::CorruptFileBlocksProto* Arena::CreateMaybeMessage<::Hdfs::Internal::CorruptFileBlocksProto>(Arena*);
169template<> ::Hdfs::Internal::DataEncryptionKeyProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DataEncryptionKeyProto>(Arena*);
170template<> ::Hdfs::Internal::DatanodeIDProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DatanodeIDProto>(Arena*);
171template<> ::Hdfs::Internal::DatanodeInfoProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DatanodeInfoProto>(Arena*);
172template<> ::Hdfs::Internal::DatanodeInfosProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DatanodeInfosProto>(Arena*);
173template<> ::Hdfs::Internal::DirectoryListingProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DirectoryListingProto>(Arena*);
174template<> ::Hdfs::Internal::ExportedBlockKeysProto* Arena::CreateMaybeMessage<::Hdfs::Internal::ExportedBlockKeysProto>(Arena*);
175template<> ::Hdfs::Internal::ExtendedBlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::ExtendedBlockProto>(Arena*);
176template<> ::Hdfs::Internal::FsPermissionProto* Arena::CreateMaybeMessage<::Hdfs::Internal::FsPermissionProto>(Arena*);
177template<> ::Hdfs::Internal::FsServerDefaultsProto* Arena::CreateMaybeMessage<::Hdfs::Internal::FsServerDefaultsProto>(Arena*);
178template<> ::Hdfs::Internal::HdfsFileStatusProto* Arena::CreateMaybeMessage<::Hdfs::Internal::HdfsFileStatusProto>(Arena*);
179template<> ::Hdfs::Internal::LocatedBlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::LocatedBlockProto>(Arena*);
180template<> ::Hdfs::Internal::LocatedBlocksProto* Arena::CreateMaybeMessage<::Hdfs::Internal::LocatedBlocksProto>(Arena*);
181template<> ::Hdfs::Internal::NamenodeCommandProto* Arena::CreateMaybeMessage<::Hdfs::Internal::NamenodeCommandProto>(Arena*);
182template<> ::Hdfs::Internal::NamenodeRegistrationProto* Arena::CreateMaybeMessage<::Hdfs::Internal::NamenodeRegistrationProto>(Arena*);
183template<> ::Hdfs::Internal::NamespaceInfoProto* Arena::CreateMaybeMessage<::Hdfs::Internal::NamespaceInfoProto>(Arena*);
184template<> ::Hdfs::Internal::RecoveringBlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::RecoveringBlockProto>(Arena*);
185template<> ::Hdfs::Internal::RemoteEditLogManifestProto* Arena::CreateMaybeMessage<::Hdfs::Internal::RemoteEditLogManifestProto>(Arena*);
186template<> ::Hdfs::Internal::RemoteEditLogProto* Arena::CreateMaybeMessage<::Hdfs::Internal::RemoteEditLogProto>(Arena*);
187template<> ::Hdfs::Internal::SnapshotDiffReportEntryProto* Arena::CreateMaybeMessage<::Hdfs::Internal::SnapshotDiffReportEntryProto>(Arena*);
188template<> ::Hdfs::Internal::SnapshotDiffReportProto* Arena::CreateMaybeMessage<::Hdfs::Internal::SnapshotDiffReportProto>(Arena*);
189template<> ::Hdfs::Internal::SnapshotInfoProto* Arena::CreateMaybeMessage<::Hdfs::Internal::SnapshotInfoProto>(Arena*);
190template<> ::Hdfs::Internal::SnapshottableDirectoryListingProto* Arena::CreateMaybeMessage<::Hdfs::Internal::SnapshottableDirectoryListingProto>(Arena*);
191template<> ::Hdfs::Internal::SnapshottableDirectoryStatusProto* Arena::CreateMaybeMessage<::Hdfs::Internal::SnapshottableDirectoryStatusProto>(Arena*);
192template<> ::Hdfs::Internal::StorageInfoProto* Arena::CreateMaybeMessage<::Hdfs::Internal::StorageInfoProto>(Arena*);
193template<> ::Hdfs::Internal::StorageUuidsProto* Arena::CreateMaybeMessage<::Hdfs::Internal::StorageUuidsProto>(Arena*);
194template<> ::Hdfs::Internal::VersionRequestProto* Arena::CreateMaybeMessage<::Hdfs::Internal::VersionRequestProto>(Arena*);
195template<> ::Hdfs::Internal::VersionResponseProto* Arena::CreateMaybeMessage<::Hdfs::Internal::VersionResponseProto>(Arena*);
196} // namespace protobuf
197} // namespace google
198namespace Hdfs {
199namespace Internal {
200
201enum DatanodeInfoProto_AdminState {
202 DatanodeInfoProto_AdminState_NORMAL = 0,
203 DatanodeInfoProto_AdminState_DECOMMISSION_INPROGRESS = 1,
204 DatanodeInfoProto_AdminState_DECOMMISSIONED = 2
205};
206bool DatanodeInfoProto_AdminState_IsValid(int value);
207const DatanodeInfoProto_AdminState DatanodeInfoProto_AdminState_AdminState_MIN = DatanodeInfoProto_AdminState_NORMAL;
208const DatanodeInfoProto_AdminState DatanodeInfoProto_AdminState_AdminState_MAX = DatanodeInfoProto_AdminState_DECOMMISSIONED;
209const int DatanodeInfoProto_AdminState_AdminState_ARRAYSIZE = DatanodeInfoProto_AdminState_AdminState_MAX + 1;
210
211const ::google::protobuf::EnumDescriptor* DatanodeInfoProto_AdminState_descriptor();
212inline const ::std::string& DatanodeInfoProto_AdminState_Name(DatanodeInfoProto_AdminState value) {
213 return ::google::protobuf::internal::NameOfEnum(
214 DatanodeInfoProto_AdminState_descriptor(), value);
215}
216inline bool DatanodeInfoProto_AdminState_Parse(
217 const ::std::string& name, DatanodeInfoProto_AdminState* value) {
218 return ::google::protobuf::internal::ParseNamedEnum<DatanodeInfoProto_AdminState>(
219 DatanodeInfoProto_AdminState_descriptor(), name, value);
220}
221enum HdfsFileStatusProto_FileType {
222 HdfsFileStatusProto_FileType_IS_DIR = 1,
223 HdfsFileStatusProto_FileType_IS_FILE = 2,
224 HdfsFileStatusProto_FileType_IS_SYMLINK = 3
225};
226bool HdfsFileStatusProto_FileType_IsValid(int value);
227const HdfsFileStatusProto_FileType HdfsFileStatusProto_FileType_FileType_MIN = HdfsFileStatusProto_FileType_IS_DIR;
228const HdfsFileStatusProto_FileType HdfsFileStatusProto_FileType_FileType_MAX = HdfsFileStatusProto_FileType_IS_SYMLINK;
229const int HdfsFileStatusProto_FileType_FileType_ARRAYSIZE = HdfsFileStatusProto_FileType_FileType_MAX + 1;
230
231const ::google::protobuf::EnumDescriptor* HdfsFileStatusProto_FileType_descriptor();
232inline const ::std::string& HdfsFileStatusProto_FileType_Name(HdfsFileStatusProto_FileType value) {
233 return ::google::protobuf::internal::NameOfEnum(
234 HdfsFileStatusProto_FileType_descriptor(), value);
235}
236inline bool HdfsFileStatusProto_FileType_Parse(
237 const ::std::string& name, HdfsFileStatusProto_FileType* value) {
238 return ::google::protobuf::internal::ParseNamedEnum<HdfsFileStatusProto_FileType>(
239 HdfsFileStatusProto_FileType_descriptor(), name, value);
240}
241enum NamenodeRegistrationProto_NamenodeRoleProto {
242 NamenodeRegistrationProto_NamenodeRoleProto_NAMENODE = 1,
243 NamenodeRegistrationProto_NamenodeRoleProto_BACKUP = 2,
244 NamenodeRegistrationProto_NamenodeRoleProto_CHECKPOINT = 3
245};
246bool NamenodeRegistrationProto_NamenodeRoleProto_IsValid(int value);
247const NamenodeRegistrationProto_NamenodeRoleProto NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MIN = NamenodeRegistrationProto_NamenodeRoleProto_NAMENODE;
248const NamenodeRegistrationProto_NamenodeRoleProto NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MAX = NamenodeRegistrationProto_NamenodeRoleProto_CHECKPOINT;
249const int NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_ARRAYSIZE = NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MAX + 1;
250
251const ::google::protobuf::EnumDescriptor* NamenodeRegistrationProto_NamenodeRoleProto_descriptor();
252inline const ::std::string& NamenodeRegistrationProto_NamenodeRoleProto_Name(NamenodeRegistrationProto_NamenodeRoleProto value) {
253 return ::google::protobuf::internal::NameOfEnum(
254 NamenodeRegistrationProto_NamenodeRoleProto_descriptor(), value);
255}
256inline bool NamenodeRegistrationProto_NamenodeRoleProto_Parse(
257 const ::std::string& name, NamenodeRegistrationProto_NamenodeRoleProto* value) {
258 return ::google::protobuf::internal::ParseNamedEnum<NamenodeRegistrationProto_NamenodeRoleProto>(
259 NamenodeRegistrationProto_NamenodeRoleProto_descriptor(), name, value);
260}
261enum NamenodeCommandProto_Type {
262 NamenodeCommandProto_Type_NamenodeCommand = 0,
263 NamenodeCommandProto_Type_CheckPointCommand = 1
264};
265bool NamenodeCommandProto_Type_IsValid(int value);
266const NamenodeCommandProto_Type NamenodeCommandProto_Type_Type_MIN = NamenodeCommandProto_Type_NamenodeCommand;
267const NamenodeCommandProto_Type NamenodeCommandProto_Type_Type_MAX = NamenodeCommandProto_Type_CheckPointCommand;
268const int NamenodeCommandProto_Type_Type_ARRAYSIZE = NamenodeCommandProto_Type_Type_MAX + 1;
269
270const ::google::protobuf::EnumDescriptor* NamenodeCommandProto_Type_descriptor();
271inline const ::std::string& NamenodeCommandProto_Type_Name(NamenodeCommandProto_Type value) {
272 return ::google::protobuf::internal::NameOfEnum(
273 NamenodeCommandProto_Type_descriptor(), value);
274}
275inline bool NamenodeCommandProto_Type_Parse(
276 const ::std::string& name, NamenodeCommandProto_Type* value) {
277 return ::google::protobuf::internal::ParseNamedEnum<NamenodeCommandProto_Type>(
278 NamenodeCommandProto_Type_descriptor(), name, value);
279}
280enum StorageTypeProto {
281 DISK = 1,
282 SSD = 2
283};
284bool StorageTypeProto_IsValid(int value);
285const StorageTypeProto StorageTypeProto_MIN = DISK;
286const StorageTypeProto StorageTypeProto_MAX = SSD;
287const int StorageTypeProto_ARRAYSIZE = StorageTypeProto_MAX + 1;
288
289const ::google::protobuf::EnumDescriptor* StorageTypeProto_descriptor();
290inline const ::std::string& StorageTypeProto_Name(StorageTypeProto value) {
291 return ::google::protobuf::internal::NameOfEnum(
292 StorageTypeProto_descriptor(), value);
293}
294inline bool StorageTypeProto_Parse(
295 const ::std::string& name, StorageTypeProto* value) {
296 return ::google::protobuf::internal::ParseNamedEnum<StorageTypeProto>(
297 StorageTypeProto_descriptor(), name, value);
298}
299enum ChecksumTypeProto {
300 CHECKSUM_NULL = 0,
301 CHECKSUM_CRC32 = 1,
302 CHECKSUM_CRC32C = 2
303};
304bool ChecksumTypeProto_IsValid(int value);
305const ChecksumTypeProto ChecksumTypeProto_MIN = CHECKSUM_NULL;
306const ChecksumTypeProto ChecksumTypeProto_MAX = CHECKSUM_CRC32C;
307const int ChecksumTypeProto_ARRAYSIZE = ChecksumTypeProto_MAX + 1;
308
309const ::google::protobuf::EnumDescriptor* ChecksumTypeProto_descriptor();
310inline const ::std::string& ChecksumTypeProto_Name(ChecksumTypeProto value) {
311 return ::google::protobuf::internal::NameOfEnum(
312 ChecksumTypeProto_descriptor(), value);
313}
314inline bool ChecksumTypeProto_Parse(
315 const ::std::string& name, ChecksumTypeProto* value) {
316 return ::google::protobuf::internal::ParseNamedEnum<ChecksumTypeProto>(
317 ChecksumTypeProto_descriptor(), name, value);
318}
319enum ReplicaStateProto {
320 FINALIZED = 0,
321 RBW = 1,
322 RWR = 2,
323 RUR = 3,
324 TEMPORARY = 4
325};
326bool ReplicaStateProto_IsValid(int value);
327const ReplicaStateProto ReplicaStateProto_MIN = FINALIZED;
328const ReplicaStateProto ReplicaStateProto_MAX = TEMPORARY;
329const int ReplicaStateProto_ARRAYSIZE = ReplicaStateProto_MAX + 1;
330
331const ::google::protobuf::EnumDescriptor* ReplicaStateProto_descriptor();
332inline const ::std::string& ReplicaStateProto_Name(ReplicaStateProto value) {
333 return ::google::protobuf::internal::NameOfEnum(
334 ReplicaStateProto_descriptor(), value);
335}
336inline bool ReplicaStateProto_Parse(
337 const ::std::string& name, ReplicaStateProto* value) {
338 return ::google::protobuf::internal::ParseNamedEnum<ReplicaStateProto>(
339 ReplicaStateProto_descriptor(), name, value);
340}
341// ===================================================================
342
343class ExtendedBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.ExtendedBlockProto) */ {
344 public:
345 ExtendedBlockProto();
346 virtual ~ExtendedBlockProto();
347
348 ExtendedBlockProto(const ExtendedBlockProto& from);
349
350 inline ExtendedBlockProto& operator=(const ExtendedBlockProto& from) {
351 CopyFrom(from);
352 return *this;
353 }
354 #if LANG_CXX11
355 ExtendedBlockProto(ExtendedBlockProto&& from) noexcept
356 : ExtendedBlockProto() {
357 *this = ::std::move(from);
358 }
359
360 inline ExtendedBlockProto& operator=(ExtendedBlockProto&& from) noexcept {
361 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
362 if (this != &from) InternalSwap(&from);
363 } else {
364 CopyFrom(from);
365 }
366 return *this;
367 }
368 #endif
369 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
370 return _internal_metadata_.unknown_fields();
371 }
372 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
373 return _internal_metadata_.mutable_unknown_fields();
374 }
375
376 static const ::google::protobuf::Descriptor* descriptor();
377 static const ExtendedBlockProto& default_instance();
378
379 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
380 static inline const ExtendedBlockProto* internal_default_instance() {
381 return reinterpret_cast<const ExtendedBlockProto*>(
382 &_ExtendedBlockProto_default_instance_);
383 }
384 static constexpr int kIndexInFileMessages =
385 0;
386
387 void Swap(ExtendedBlockProto* other);
388 friend void swap(ExtendedBlockProto& a, ExtendedBlockProto& b) {
389 a.Swap(&b);
390 }
391
392 // implements Message ----------------------------------------------
393
394 inline ExtendedBlockProto* New() const final {
395 return CreateMaybeMessage<ExtendedBlockProto>(NULL);
396 }
397
398 ExtendedBlockProto* New(::google::protobuf::Arena* arena) const final {
399 return CreateMaybeMessage<ExtendedBlockProto>(arena);
400 }
401 void CopyFrom(const ::google::protobuf::Message& from) final;
402 void MergeFrom(const ::google::protobuf::Message& from) final;
403 void CopyFrom(const ExtendedBlockProto& from);
404 void MergeFrom(const ExtendedBlockProto& from);
405 void Clear() final;
406 bool IsInitialized() const final;
407
408 size_t ByteSizeLong() const final;
409 bool MergePartialFromCodedStream(
410 ::google::protobuf::io::CodedInputStream* input) final;
411 void SerializeWithCachedSizes(
412 ::google::protobuf::io::CodedOutputStream* output) const final;
413 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
414 bool deterministic, ::google::protobuf::uint8* target) const final;
415 int GetCachedSize() const final { return _cached_size_.Get(); }
416
417 private:
418 void SharedCtor();
419 void SharedDtor();
420 void SetCachedSize(int size) const final;
421 void InternalSwap(ExtendedBlockProto* other);
422 private:
423 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
424 return NULL;
425 }
426 inline void* MaybeArenaPtr() const {
427 return NULL;
428 }
429 public:
430
431 ::google::protobuf::Metadata GetMetadata() const final;
432
433 // nested types ----------------------------------------------------
434
435 // accessors -------------------------------------------------------
436
437 // required string poolId = 1;
438 bool has_poolid() const;
439 void clear_poolid();
440 static const int kPoolIdFieldNumber = 1;
441 const ::std::string& poolid() const;
442 void set_poolid(const ::std::string& value);
443 #if LANG_CXX11
444 void set_poolid(::std::string&& value);
445 #endif
446 void set_poolid(const char* value);
447 void set_poolid(const char* value, size_t size);
448 ::std::string* mutable_poolid();
449 ::std::string* release_poolid();
450 void set_allocated_poolid(::std::string* poolid);
451
452 // required uint64 blockId = 2;
453 bool has_blockid() const;
454 void clear_blockid();
455 static const int kBlockIdFieldNumber = 2;
456 ::google::protobuf::uint64 blockid() const;
457 void set_blockid(::google::protobuf::uint64 value);
458
459 // required uint64 generationStamp = 3;
460 bool has_generationstamp() const;
461 void clear_generationstamp();
462 static const int kGenerationStampFieldNumber = 3;
463 ::google::protobuf::uint64 generationstamp() const;
464 void set_generationstamp(::google::protobuf::uint64 value);
465
466 // optional uint64 numBytes = 4 [default = 0];
467 bool has_numbytes() const;
468 void clear_numbytes();
469 static const int kNumBytesFieldNumber = 4;
470 ::google::protobuf::uint64 numbytes() const;
471 void set_numbytes(::google::protobuf::uint64 value);
472
473 // @@protoc_insertion_point(class_scope:Hdfs.Internal.ExtendedBlockProto)
474 private:
475 void set_has_poolid();
476 void clear_has_poolid();
477 void set_has_blockid();
478 void clear_has_blockid();
479 void set_has_generationstamp();
480 void clear_has_generationstamp();
481 void set_has_numbytes();
482 void clear_has_numbytes();
483
484 // helper for ByteSizeLong()
485 size_t RequiredFieldsByteSizeFallback() const;
486
487 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
488 ::google::protobuf::internal::HasBits<1> _has_bits_;
489 mutable ::google::protobuf::internal::CachedSize _cached_size_;
490 ::google::protobuf::internal::ArenaStringPtr poolid_;
491 ::google::protobuf::uint64 blockid_;
492 ::google::protobuf::uint64 generationstamp_;
493 ::google::protobuf::uint64 numbytes_;
494 friend struct ::protobuf_hdfs_2eproto::TableStruct;
495};
496// -------------------------------------------------------------------
497
498class DatanodeIDProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DatanodeIDProto) */ {
499 public:
500 DatanodeIDProto();
501 virtual ~DatanodeIDProto();
502
503 DatanodeIDProto(const DatanodeIDProto& from);
504
505 inline DatanodeIDProto& operator=(const DatanodeIDProto& from) {
506 CopyFrom(from);
507 return *this;
508 }
509 #if LANG_CXX11
510 DatanodeIDProto(DatanodeIDProto&& from) noexcept
511 : DatanodeIDProto() {
512 *this = ::std::move(from);
513 }
514
515 inline DatanodeIDProto& operator=(DatanodeIDProto&& from) noexcept {
516 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
517 if (this != &from) InternalSwap(&from);
518 } else {
519 CopyFrom(from);
520 }
521 return *this;
522 }
523 #endif
524 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
525 return _internal_metadata_.unknown_fields();
526 }
527 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
528 return _internal_metadata_.mutable_unknown_fields();
529 }
530
531 static const ::google::protobuf::Descriptor* descriptor();
532 static const DatanodeIDProto& default_instance();
533
534 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
535 static inline const DatanodeIDProto* internal_default_instance() {
536 return reinterpret_cast<const DatanodeIDProto*>(
537 &_DatanodeIDProto_default_instance_);
538 }
539 static constexpr int kIndexInFileMessages =
540 1;
541
542 void Swap(DatanodeIDProto* other);
543 friend void swap(DatanodeIDProto& a, DatanodeIDProto& b) {
544 a.Swap(&b);
545 }
546
547 // implements Message ----------------------------------------------
548
549 inline DatanodeIDProto* New() const final {
550 return CreateMaybeMessage<DatanodeIDProto>(NULL);
551 }
552
553 DatanodeIDProto* New(::google::protobuf::Arena* arena) const final {
554 return CreateMaybeMessage<DatanodeIDProto>(arena);
555 }
556 void CopyFrom(const ::google::protobuf::Message& from) final;
557 void MergeFrom(const ::google::protobuf::Message& from) final;
558 void CopyFrom(const DatanodeIDProto& from);
559 void MergeFrom(const DatanodeIDProto& from);
560 void Clear() final;
561 bool IsInitialized() const final;
562
563 size_t ByteSizeLong() const final;
564 bool MergePartialFromCodedStream(
565 ::google::protobuf::io::CodedInputStream* input) final;
566 void SerializeWithCachedSizes(
567 ::google::protobuf::io::CodedOutputStream* output) const final;
568 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
569 bool deterministic, ::google::protobuf::uint8* target) const final;
570 int GetCachedSize() const final { return _cached_size_.Get(); }
571
572 private:
573 void SharedCtor();
574 void SharedDtor();
575 void SetCachedSize(int size) const final;
576 void InternalSwap(DatanodeIDProto* other);
577 private:
578 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
579 return NULL;
580 }
581 inline void* MaybeArenaPtr() const {
582 return NULL;
583 }
584 public:
585
586 ::google::protobuf::Metadata GetMetadata() const final;
587
588 // nested types ----------------------------------------------------
589
590 // accessors -------------------------------------------------------
591
592 // required string ipAddr = 1;
593 bool has_ipaddr() const;
594 void clear_ipaddr();
595 static const int kIpAddrFieldNumber = 1;
596 const ::std::string& ipaddr() const;
597 void set_ipaddr(const ::std::string& value);
598 #if LANG_CXX11
599 void set_ipaddr(::std::string&& value);
600 #endif
601 void set_ipaddr(const char* value);
602 void set_ipaddr(const char* value, size_t size);
603 ::std::string* mutable_ipaddr();
604 ::std::string* release_ipaddr();
605 void set_allocated_ipaddr(::std::string* ipaddr);
606
607 // required string hostName = 2;
608 bool has_hostname() const;
609 void clear_hostname();
610 static const int kHostNameFieldNumber = 2;
611 const ::std::string& hostname() const;
612 void set_hostname(const ::std::string& value);
613 #if LANG_CXX11
614 void set_hostname(::std::string&& value);
615 #endif
616 void set_hostname(const char* value);
617 void set_hostname(const char* value, size_t size);
618 ::std::string* mutable_hostname();
619 ::std::string* release_hostname();
620 void set_allocated_hostname(::std::string* hostname);
621
622 // required string datanodeUuid = 3;
623 bool has_datanodeuuid() const;
624 void clear_datanodeuuid();
625 static const int kDatanodeUuidFieldNumber = 3;
626 const ::std::string& datanodeuuid() const;
627 void set_datanodeuuid(const ::std::string& value);
628 #if LANG_CXX11
629 void set_datanodeuuid(::std::string&& value);
630 #endif
631 void set_datanodeuuid(const char* value);
632 void set_datanodeuuid(const char* value, size_t size);
633 ::std::string* mutable_datanodeuuid();
634 ::std::string* release_datanodeuuid();
635 void set_allocated_datanodeuuid(::std::string* datanodeuuid);
636
637 // required uint32 xferPort = 4;
638 bool has_xferport() const;
639 void clear_xferport();
640 static const int kXferPortFieldNumber = 4;
641 ::google::protobuf::uint32 xferport() const;
642 void set_xferport(::google::protobuf::uint32 value);
643
644 // required uint32 infoPort = 5;
645 bool has_infoport() const;
646 void clear_infoport();
647 static const int kInfoPortFieldNumber = 5;
648 ::google::protobuf::uint32 infoport() const;
649 void set_infoport(::google::protobuf::uint32 value);
650
651 // required uint32 ipcPort = 6;
652 bool has_ipcport() const;
653 void clear_ipcport();
654 static const int kIpcPortFieldNumber = 6;
655 ::google::protobuf::uint32 ipcport() const;
656 void set_ipcport(::google::protobuf::uint32 value);
657
658 // optional uint32 infoSecurePort = 7 [default = 0];
659 bool has_infosecureport() const;
660 void clear_infosecureport();
661 static const int kInfoSecurePortFieldNumber = 7;
662 ::google::protobuf::uint32 infosecureport() const;
663 void set_infosecureport(::google::protobuf::uint32 value);
664
665 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DatanodeIDProto)
666 private:
667 void set_has_ipaddr();
668 void clear_has_ipaddr();
669 void set_has_hostname();
670 void clear_has_hostname();
671 void set_has_datanodeuuid();
672 void clear_has_datanodeuuid();
673 void set_has_xferport();
674 void clear_has_xferport();
675 void set_has_infoport();
676 void clear_has_infoport();
677 void set_has_ipcport();
678 void clear_has_ipcport();
679 void set_has_infosecureport();
680 void clear_has_infosecureport();
681
682 // helper for ByteSizeLong()
683 size_t RequiredFieldsByteSizeFallback() const;
684
685 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
686 ::google::protobuf::internal::HasBits<1> _has_bits_;
687 mutable ::google::protobuf::internal::CachedSize _cached_size_;
688 ::google::protobuf::internal::ArenaStringPtr ipaddr_;
689 ::google::protobuf::internal::ArenaStringPtr hostname_;
690 ::google::protobuf::internal::ArenaStringPtr datanodeuuid_;
691 ::google::protobuf::uint32 xferport_;
692 ::google::protobuf::uint32 infoport_;
693 ::google::protobuf::uint32 ipcport_;
694 ::google::protobuf::uint32 infosecureport_;
695 friend struct ::protobuf_hdfs_2eproto::TableStruct;
696};
697// -------------------------------------------------------------------
698
699class DatanodeInfosProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DatanodeInfosProto) */ {
700 public:
701 DatanodeInfosProto();
702 virtual ~DatanodeInfosProto();
703
704 DatanodeInfosProto(const DatanodeInfosProto& from);
705
706 inline DatanodeInfosProto& operator=(const DatanodeInfosProto& from) {
707 CopyFrom(from);
708 return *this;
709 }
710 #if LANG_CXX11
711 DatanodeInfosProto(DatanodeInfosProto&& from) noexcept
712 : DatanodeInfosProto() {
713 *this = ::std::move(from);
714 }
715
716 inline DatanodeInfosProto& operator=(DatanodeInfosProto&& from) noexcept {
717 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
718 if (this != &from) InternalSwap(&from);
719 } else {
720 CopyFrom(from);
721 }
722 return *this;
723 }
724 #endif
725 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
726 return _internal_metadata_.unknown_fields();
727 }
728 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
729 return _internal_metadata_.mutable_unknown_fields();
730 }
731
732 static const ::google::protobuf::Descriptor* descriptor();
733 static const DatanodeInfosProto& default_instance();
734
735 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
736 static inline const DatanodeInfosProto* internal_default_instance() {
737 return reinterpret_cast<const DatanodeInfosProto*>(
738 &_DatanodeInfosProto_default_instance_);
739 }
740 static constexpr int kIndexInFileMessages =
741 2;
742
743 void Swap(DatanodeInfosProto* other);
744 friend void swap(DatanodeInfosProto& a, DatanodeInfosProto& b) {
745 a.Swap(&b);
746 }
747
748 // implements Message ----------------------------------------------
749
750 inline DatanodeInfosProto* New() const final {
751 return CreateMaybeMessage<DatanodeInfosProto>(NULL);
752 }
753
754 DatanodeInfosProto* New(::google::protobuf::Arena* arena) const final {
755 return CreateMaybeMessage<DatanodeInfosProto>(arena);
756 }
757 void CopyFrom(const ::google::protobuf::Message& from) final;
758 void MergeFrom(const ::google::protobuf::Message& from) final;
759 void CopyFrom(const DatanodeInfosProto& from);
760 void MergeFrom(const DatanodeInfosProto& from);
761 void Clear() final;
762 bool IsInitialized() const final;
763
764 size_t ByteSizeLong() const final;
765 bool MergePartialFromCodedStream(
766 ::google::protobuf::io::CodedInputStream* input) final;
767 void SerializeWithCachedSizes(
768 ::google::protobuf::io::CodedOutputStream* output) const final;
769 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
770 bool deterministic, ::google::protobuf::uint8* target) const final;
771 int GetCachedSize() const final { return _cached_size_.Get(); }
772
773 private:
774 void SharedCtor();
775 void SharedDtor();
776 void SetCachedSize(int size) const final;
777 void InternalSwap(DatanodeInfosProto* other);
778 private:
779 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
780 return NULL;
781 }
782 inline void* MaybeArenaPtr() const {
783 return NULL;
784 }
785 public:
786
787 ::google::protobuf::Metadata GetMetadata() const final;
788
789 // nested types ----------------------------------------------------
790
791 // accessors -------------------------------------------------------
792
793 // repeated .Hdfs.Internal.DatanodeInfoProto datanodes = 1;
794 int datanodes_size() const;
795 void clear_datanodes();
796 static const int kDatanodesFieldNumber = 1;
797 ::Hdfs::Internal::DatanodeInfoProto* mutable_datanodes(int index);
798 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >*
799 mutable_datanodes();
800 const ::Hdfs::Internal::DatanodeInfoProto& datanodes(int index) const;
801 ::Hdfs::Internal::DatanodeInfoProto* add_datanodes();
802 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >&
803 datanodes() const;
804
805 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DatanodeInfosProto)
806 private:
807
808 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
809 ::google::protobuf::internal::HasBits<1> _has_bits_;
810 mutable ::google::protobuf::internal::CachedSize _cached_size_;
811 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto > datanodes_;
812 friend struct ::protobuf_hdfs_2eproto::TableStruct;
813};
814// -------------------------------------------------------------------
815
816class DatanodeInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DatanodeInfoProto) */ {
817 public:
818 DatanodeInfoProto();
819 virtual ~DatanodeInfoProto();
820
821 DatanodeInfoProto(const DatanodeInfoProto& from);
822
823 inline DatanodeInfoProto& operator=(const DatanodeInfoProto& from) {
824 CopyFrom(from);
825 return *this;
826 }
827 #if LANG_CXX11
828 DatanodeInfoProto(DatanodeInfoProto&& from) noexcept
829 : DatanodeInfoProto() {
830 *this = ::std::move(from);
831 }
832
833 inline DatanodeInfoProto& operator=(DatanodeInfoProto&& from) noexcept {
834 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
835 if (this != &from) InternalSwap(&from);
836 } else {
837 CopyFrom(from);
838 }
839 return *this;
840 }
841 #endif
842 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
843 return _internal_metadata_.unknown_fields();
844 }
845 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
846 return _internal_metadata_.mutable_unknown_fields();
847 }
848
849 static const ::google::protobuf::Descriptor* descriptor();
850 static const DatanodeInfoProto& default_instance();
851
852 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
853 static inline const DatanodeInfoProto* internal_default_instance() {
854 return reinterpret_cast<const DatanodeInfoProto*>(
855 &_DatanodeInfoProto_default_instance_);
856 }
857 static constexpr int kIndexInFileMessages =
858 3;
859
860 void Swap(DatanodeInfoProto* other);
861 friend void swap(DatanodeInfoProto& a, DatanodeInfoProto& b) {
862 a.Swap(&b);
863 }
864
865 // implements Message ----------------------------------------------
866
867 inline DatanodeInfoProto* New() const final {
868 return CreateMaybeMessage<DatanodeInfoProto>(NULL);
869 }
870
871 DatanodeInfoProto* New(::google::protobuf::Arena* arena) const final {
872 return CreateMaybeMessage<DatanodeInfoProto>(arena);
873 }
874 void CopyFrom(const ::google::protobuf::Message& from) final;
875 void MergeFrom(const ::google::protobuf::Message& from) final;
876 void CopyFrom(const DatanodeInfoProto& from);
877 void MergeFrom(const DatanodeInfoProto& from);
878 void Clear() final;
879 bool IsInitialized() const final;
880
881 size_t ByteSizeLong() const final;
882 bool MergePartialFromCodedStream(
883 ::google::protobuf::io::CodedInputStream* input) final;
884 void SerializeWithCachedSizes(
885 ::google::protobuf::io::CodedOutputStream* output) const final;
886 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
887 bool deterministic, ::google::protobuf::uint8* target) const final;
888 int GetCachedSize() const final { return _cached_size_.Get(); }
889
890 private:
891 void SharedCtor();
892 void SharedDtor();
893 void SetCachedSize(int size) const final;
894 void InternalSwap(DatanodeInfoProto* other);
895 private:
896 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
897 return NULL;
898 }
899 inline void* MaybeArenaPtr() const {
900 return NULL;
901 }
902 public:
903
904 ::google::protobuf::Metadata GetMetadata() const final;
905
906 // nested types ----------------------------------------------------
907
908 typedef DatanodeInfoProto_AdminState AdminState;
909 static const AdminState NORMAL =
910 DatanodeInfoProto_AdminState_NORMAL;
911 static const AdminState DECOMMISSION_INPROGRESS =
912 DatanodeInfoProto_AdminState_DECOMMISSION_INPROGRESS;
913 static const AdminState DECOMMISSIONED =
914 DatanodeInfoProto_AdminState_DECOMMISSIONED;
915 static inline bool AdminState_IsValid(int value) {
916 return DatanodeInfoProto_AdminState_IsValid(value);
917 }
918 static const AdminState AdminState_MIN =
919 DatanodeInfoProto_AdminState_AdminState_MIN;
920 static const AdminState AdminState_MAX =
921 DatanodeInfoProto_AdminState_AdminState_MAX;
922 static const int AdminState_ARRAYSIZE =
923 DatanodeInfoProto_AdminState_AdminState_ARRAYSIZE;
924 static inline const ::google::protobuf::EnumDescriptor*
925 AdminState_descriptor() {
926 return DatanodeInfoProto_AdminState_descriptor();
927 }
928 static inline const ::std::string& AdminState_Name(AdminState value) {
929 return DatanodeInfoProto_AdminState_Name(value);
930 }
931 static inline bool AdminState_Parse(const ::std::string& name,
932 AdminState* value) {
933 return DatanodeInfoProto_AdminState_Parse(name, value);
934 }
935
936 // accessors -------------------------------------------------------
937
938 // optional string location = 8;
939 bool has_location() const;
940 void clear_location();
941 static const int kLocationFieldNumber = 8;
942 const ::std::string& location() const;
943 void set_location(const ::std::string& value);
944 #if LANG_CXX11
945 void set_location(::std::string&& value);
946 #endif
947 void set_location(const char* value);
948 void set_location(const char* value, size_t size);
949 ::std::string* mutable_location();
950 ::std::string* release_location();
951 void set_allocated_location(::std::string* location);
952
953 // required .Hdfs.Internal.DatanodeIDProto id = 1;
954 bool has_id() const;
955 void clear_id();
956 static const int kIdFieldNumber = 1;
957 private:
958 const ::Hdfs::Internal::DatanodeIDProto& _internal_id() const;
959 public:
960 const ::Hdfs::Internal::DatanodeIDProto& id() const;
961 ::Hdfs::Internal::DatanodeIDProto* release_id();
962 ::Hdfs::Internal::DatanodeIDProto* mutable_id();
963 void set_allocated_id(::Hdfs::Internal::DatanodeIDProto* id);
964
965 // optional uint64 capacity = 2 [default = 0];
966 bool has_capacity() const;
967 void clear_capacity();
968 static const int kCapacityFieldNumber = 2;
969 ::google::protobuf::uint64 capacity() const;
970 void set_capacity(::google::protobuf::uint64 value);
971
972 // optional uint64 dfsUsed = 3 [default = 0];
973 bool has_dfsused() const;
974 void clear_dfsused();
975 static const int kDfsUsedFieldNumber = 3;
976 ::google::protobuf::uint64 dfsused() const;
977 void set_dfsused(::google::protobuf::uint64 value);
978
979 // optional uint64 remaining = 4 [default = 0];
980 bool has_remaining() const;
981 void clear_remaining();
982 static const int kRemainingFieldNumber = 4;
983 ::google::protobuf::uint64 remaining() const;
984 void set_remaining(::google::protobuf::uint64 value);
985
986 // optional uint64 blockPoolUsed = 5 [default = 0];
987 bool has_blockpoolused() const;
988 void clear_blockpoolused();
989 static const int kBlockPoolUsedFieldNumber = 5;
990 ::google::protobuf::uint64 blockpoolused() const;
991 void set_blockpoolused(::google::protobuf::uint64 value);
992
993 // optional uint64 lastUpdate = 6 [default = 0];
994 bool has_lastupdate() const;
995 void clear_lastupdate();
996 static const int kLastUpdateFieldNumber = 6;
997 ::google::protobuf::uint64 lastupdate() const;
998 void set_lastupdate(::google::protobuf::uint64 value);
999
1000 // optional uint32 xceiverCount = 7 [default = 0];
1001 bool has_xceivercount() const;
1002 void clear_xceivercount();
1003 static const int kXceiverCountFieldNumber = 7;
1004 ::google::protobuf::uint32 xceivercount() const;
1005 void set_xceivercount(::google::protobuf::uint32 value);
1006
1007 // optional .Hdfs.Internal.DatanodeInfoProto.AdminState adminState = 10 [default = NORMAL];
1008 bool has_adminstate() const;
1009 void clear_adminstate();
1010 static const int kAdminStateFieldNumber = 10;
1011 ::Hdfs::Internal::DatanodeInfoProto_AdminState adminstate() const;
1012 void set_adminstate(::Hdfs::Internal::DatanodeInfoProto_AdminState value);
1013
1014 // optional uint64 cacheCapacity = 11 [default = 0];
1015 bool has_cachecapacity() const;
1016 void clear_cachecapacity();
1017 static const int kCacheCapacityFieldNumber = 11;
1018 ::google::protobuf::uint64 cachecapacity() const;
1019 void set_cachecapacity(::google::protobuf::uint64 value);
1020
1021 // optional uint64 cacheUsed = 12 [default = 0];
1022 bool has_cacheused() const;
1023 void clear_cacheused();
1024 static const int kCacheUsedFieldNumber = 12;
1025 ::google::protobuf::uint64 cacheused() const;
1026 void set_cacheused(::google::protobuf::uint64 value);
1027
1028 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DatanodeInfoProto)
1029 private:
1030 void set_has_id();
1031 void clear_has_id();
1032 void set_has_capacity();
1033 void clear_has_capacity();
1034 void set_has_dfsused();
1035 void clear_has_dfsused();
1036 void set_has_remaining();
1037 void clear_has_remaining();
1038 void set_has_blockpoolused();
1039 void clear_has_blockpoolused();
1040 void set_has_lastupdate();
1041 void clear_has_lastupdate();
1042 void set_has_xceivercount();
1043 void clear_has_xceivercount();
1044 void set_has_location();
1045 void clear_has_location();
1046 void set_has_adminstate();
1047 void clear_has_adminstate();
1048 void set_has_cachecapacity();
1049 void clear_has_cachecapacity();
1050 void set_has_cacheused();
1051 void clear_has_cacheused();
1052
1053 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1054 ::google::protobuf::internal::HasBits<1> _has_bits_;
1055 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1056 ::google::protobuf::internal::ArenaStringPtr location_;
1057 ::Hdfs::Internal::DatanodeIDProto* id_;
1058 ::google::protobuf::uint64 capacity_;
1059 ::google::protobuf::uint64 dfsused_;
1060 ::google::protobuf::uint64 remaining_;
1061 ::google::protobuf::uint64 blockpoolused_;
1062 ::google::protobuf::uint64 lastupdate_;
1063 ::google::protobuf::uint32 xceivercount_;
1064 int adminstate_;
1065 ::google::protobuf::uint64 cachecapacity_;
1066 ::google::protobuf::uint64 cacheused_;
1067 friend struct ::protobuf_hdfs_2eproto::TableStruct;
1068};
1069// -------------------------------------------------------------------
1070
1071class ContentSummaryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.ContentSummaryProto) */ {
1072 public:
1073 ContentSummaryProto();
1074 virtual ~ContentSummaryProto();
1075
1076 ContentSummaryProto(const ContentSummaryProto& from);
1077
1078 inline ContentSummaryProto& operator=(const ContentSummaryProto& from) {
1079 CopyFrom(from);
1080 return *this;
1081 }
1082 #if LANG_CXX11
1083 ContentSummaryProto(ContentSummaryProto&& from) noexcept
1084 : ContentSummaryProto() {
1085 *this = ::std::move(from);
1086 }
1087
1088 inline ContentSummaryProto& operator=(ContentSummaryProto&& from) noexcept {
1089 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1090 if (this != &from) InternalSwap(&from);
1091 } else {
1092 CopyFrom(from);
1093 }
1094 return *this;
1095 }
1096 #endif
1097 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1098 return _internal_metadata_.unknown_fields();
1099 }
1100 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1101 return _internal_metadata_.mutable_unknown_fields();
1102 }
1103
1104 static const ::google::protobuf::Descriptor* descriptor();
1105 static const ContentSummaryProto& default_instance();
1106
1107 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1108 static inline const ContentSummaryProto* internal_default_instance() {
1109 return reinterpret_cast<const ContentSummaryProto*>(
1110 &_ContentSummaryProto_default_instance_);
1111 }
1112 static constexpr int kIndexInFileMessages =
1113 4;
1114
1115 void Swap(ContentSummaryProto* other);
1116 friend void swap(ContentSummaryProto& a, ContentSummaryProto& b) {
1117 a.Swap(&b);
1118 }
1119
1120 // implements Message ----------------------------------------------
1121
1122 inline ContentSummaryProto* New() const final {
1123 return CreateMaybeMessage<ContentSummaryProto>(NULL);
1124 }
1125
1126 ContentSummaryProto* New(::google::protobuf::Arena* arena) const final {
1127 return CreateMaybeMessage<ContentSummaryProto>(arena);
1128 }
1129 void CopyFrom(const ::google::protobuf::Message& from) final;
1130 void MergeFrom(const ::google::protobuf::Message& from) final;
1131 void CopyFrom(const ContentSummaryProto& from);
1132 void MergeFrom(const ContentSummaryProto& from);
1133 void Clear() final;
1134 bool IsInitialized() const final;
1135
1136 size_t ByteSizeLong() const final;
1137 bool MergePartialFromCodedStream(
1138 ::google::protobuf::io::CodedInputStream* input) final;
1139 void SerializeWithCachedSizes(
1140 ::google::protobuf::io::CodedOutputStream* output) const final;
1141 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1142 bool deterministic, ::google::protobuf::uint8* target) const final;
1143 int GetCachedSize() const final { return _cached_size_.Get(); }
1144
1145 private:
1146 void SharedCtor();
1147 void SharedDtor();
1148 void SetCachedSize(int size) const final;
1149 void InternalSwap(ContentSummaryProto* other);
1150 private:
1151 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1152 return NULL;
1153 }
1154 inline void* MaybeArenaPtr() const {
1155 return NULL;
1156 }
1157 public:
1158
1159 ::google::protobuf::Metadata GetMetadata() const final;
1160
1161 // nested types ----------------------------------------------------
1162
1163 // accessors -------------------------------------------------------
1164
1165 // required uint64 length = 1;
1166 bool has_length() const;
1167 void clear_length();
1168 static const int kLengthFieldNumber = 1;
1169 ::google::protobuf::uint64 length() const;
1170 void set_length(::google::protobuf::uint64 value);
1171
1172 // required uint64 fileCount = 2;
1173 bool has_filecount() const;
1174 void clear_filecount();
1175 static const int kFileCountFieldNumber = 2;
1176 ::google::protobuf::uint64 filecount() const;
1177 void set_filecount(::google::protobuf::uint64 value);
1178
1179 // required uint64 directoryCount = 3;
1180 bool has_directorycount() const;
1181 void clear_directorycount();
1182 static const int kDirectoryCountFieldNumber = 3;
1183 ::google::protobuf::uint64 directorycount() const;
1184 void set_directorycount(::google::protobuf::uint64 value);
1185
1186 // required uint64 quota = 4;
1187 bool has_quota() const;
1188 void clear_quota();
1189 static const int kQuotaFieldNumber = 4;
1190 ::google::protobuf::uint64 quota() const;
1191 void set_quota(::google::protobuf::uint64 value);
1192
1193 // required uint64 spaceConsumed = 5;
1194 bool has_spaceconsumed() const;
1195 void clear_spaceconsumed();
1196 static const int kSpaceConsumedFieldNumber = 5;
1197 ::google::protobuf::uint64 spaceconsumed() const;
1198 void set_spaceconsumed(::google::protobuf::uint64 value);
1199
1200 // required uint64 spaceQuota = 6;
1201 bool has_spacequota() const;
1202 void clear_spacequota();
1203 static const int kSpaceQuotaFieldNumber = 6;
1204 ::google::protobuf::uint64 spacequota() const;
1205 void set_spacequota(::google::protobuf::uint64 value);
1206
1207 // @@protoc_insertion_point(class_scope:Hdfs.Internal.ContentSummaryProto)
1208 private:
1209 void set_has_length();
1210 void clear_has_length();
1211 void set_has_filecount();
1212 void clear_has_filecount();
1213 void set_has_directorycount();
1214 void clear_has_directorycount();
1215 void set_has_quota();
1216 void clear_has_quota();
1217 void set_has_spaceconsumed();
1218 void clear_has_spaceconsumed();
1219 void set_has_spacequota();
1220 void clear_has_spacequota();
1221
1222 // helper for ByteSizeLong()
1223 size_t RequiredFieldsByteSizeFallback() const;
1224
1225 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1226 ::google::protobuf::internal::HasBits<1> _has_bits_;
1227 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1228 ::google::protobuf::uint64 length_;
1229 ::google::protobuf::uint64 filecount_;
1230 ::google::protobuf::uint64 directorycount_;
1231 ::google::protobuf::uint64 quota_;
1232 ::google::protobuf::uint64 spaceconsumed_;
1233 ::google::protobuf::uint64 spacequota_;
1234 friend struct ::protobuf_hdfs_2eproto::TableStruct;
1235};
1236// -------------------------------------------------------------------
1237
1238class CorruptFileBlocksProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.CorruptFileBlocksProto) */ {
1239 public:
1240 CorruptFileBlocksProto();
1241 virtual ~CorruptFileBlocksProto();
1242
1243 CorruptFileBlocksProto(const CorruptFileBlocksProto& from);
1244
1245 inline CorruptFileBlocksProto& operator=(const CorruptFileBlocksProto& from) {
1246 CopyFrom(from);
1247 return *this;
1248 }
1249 #if LANG_CXX11
1250 CorruptFileBlocksProto(CorruptFileBlocksProto&& from) noexcept
1251 : CorruptFileBlocksProto() {
1252 *this = ::std::move(from);
1253 }
1254
1255 inline CorruptFileBlocksProto& operator=(CorruptFileBlocksProto&& from) noexcept {
1256 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1257 if (this != &from) InternalSwap(&from);
1258 } else {
1259 CopyFrom(from);
1260 }
1261 return *this;
1262 }
1263 #endif
1264 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1265 return _internal_metadata_.unknown_fields();
1266 }
1267 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1268 return _internal_metadata_.mutable_unknown_fields();
1269 }
1270
1271 static const ::google::protobuf::Descriptor* descriptor();
1272 static const CorruptFileBlocksProto& default_instance();
1273
1274 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1275 static inline const CorruptFileBlocksProto* internal_default_instance() {
1276 return reinterpret_cast<const CorruptFileBlocksProto*>(
1277 &_CorruptFileBlocksProto_default_instance_);
1278 }
1279 static constexpr int kIndexInFileMessages =
1280 5;
1281
1282 void Swap(CorruptFileBlocksProto* other);
1283 friend void swap(CorruptFileBlocksProto& a, CorruptFileBlocksProto& b) {
1284 a.Swap(&b);
1285 }
1286
1287 // implements Message ----------------------------------------------
1288
1289 inline CorruptFileBlocksProto* New() const final {
1290 return CreateMaybeMessage<CorruptFileBlocksProto>(NULL);
1291 }
1292
1293 CorruptFileBlocksProto* New(::google::protobuf::Arena* arena) const final {
1294 return CreateMaybeMessage<CorruptFileBlocksProto>(arena);
1295 }
1296 void CopyFrom(const ::google::protobuf::Message& from) final;
1297 void MergeFrom(const ::google::protobuf::Message& from) final;
1298 void CopyFrom(const CorruptFileBlocksProto& from);
1299 void MergeFrom(const CorruptFileBlocksProto& from);
1300 void Clear() final;
1301 bool IsInitialized() const final;
1302
1303 size_t ByteSizeLong() const final;
1304 bool MergePartialFromCodedStream(
1305 ::google::protobuf::io::CodedInputStream* input) final;
1306 void SerializeWithCachedSizes(
1307 ::google::protobuf::io::CodedOutputStream* output) const final;
1308 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1309 bool deterministic, ::google::protobuf::uint8* target) const final;
1310 int GetCachedSize() const final { return _cached_size_.Get(); }
1311
1312 private:
1313 void SharedCtor();
1314 void SharedDtor();
1315 void SetCachedSize(int size) const final;
1316 void InternalSwap(CorruptFileBlocksProto* other);
1317 private:
1318 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1319 return NULL;
1320 }
1321 inline void* MaybeArenaPtr() const {
1322 return NULL;
1323 }
1324 public:
1325
1326 ::google::protobuf::Metadata GetMetadata() const final;
1327
1328 // nested types ----------------------------------------------------
1329
1330 // accessors -------------------------------------------------------
1331
1332 // repeated string files = 1;
1333 int files_size() const;
1334 void clear_files();
1335 static const int kFilesFieldNumber = 1;
1336 const ::std::string& files(int index) const;
1337 ::std::string* mutable_files(int index);
1338 void set_files(int index, const ::std::string& value);
1339 #if LANG_CXX11
1340 void set_files(int index, ::std::string&& value);
1341 #endif
1342 void set_files(int index, const char* value);
1343 void set_files(int index, const char* value, size_t size);
1344 ::std::string* add_files();
1345 void add_files(const ::std::string& value);
1346 #if LANG_CXX11
1347 void add_files(::std::string&& value);
1348 #endif
1349 void add_files(const char* value);
1350 void add_files(const char* value, size_t size);
1351 const ::google::protobuf::RepeatedPtrField< ::std::string>& files() const;
1352 ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_files();
1353
1354 // required string cookie = 2;
1355 bool has_cookie() const;
1356 void clear_cookie();
1357 static const int kCookieFieldNumber = 2;
1358 const ::std::string& cookie() const;
1359 void set_cookie(const ::std::string& value);
1360 #if LANG_CXX11
1361 void set_cookie(::std::string&& value);
1362 #endif
1363 void set_cookie(const char* value);
1364 void set_cookie(const char* value, size_t size);
1365 ::std::string* mutable_cookie();
1366 ::std::string* release_cookie();
1367 void set_allocated_cookie(::std::string* cookie);
1368
1369 // @@protoc_insertion_point(class_scope:Hdfs.Internal.CorruptFileBlocksProto)
1370 private:
1371 void set_has_cookie();
1372 void clear_has_cookie();
1373
1374 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1375 ::google::protobuf::internal::HasBits<1> _has_bits_;
1376 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1377 ::google::protobuf::RepeatedPtrField< ::std::string> files_;
1378 ::google::protobuf::internal::ArenaStringPtr cookie_;
1379 friend struct ::protobuf_hdfs_2eproto::TableStruct;
1380};
1381// -------------------------------------------------------------------
1382
1383class FsPermissionProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.FsPermissionProto) */ {
1384 public:
1385 FsPermissionProto();
1386 virtual ~FsPermissionProto();
1387
1388 FsPermissionProto(const FsPermissionProto& from);
1389
1390 inline FsPermissionProto& operator=(const FsPermissionProto& from) {
1391 CopyFrom(from);
1392 return *this;
1393 }
1394 #if LANG_CXX11
1395 FsPermissionProto(FsPermissionProto&& from) noexcept
1396 : FsPermissionProto() {
1397 *this = ::std::move(from);
1398 }
1399
1400 inline FsPermissionProto& operator=(FsPermissionProto&& from) noexcept {
1401 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1402 if (this != &from) InternalSwap(&from);
1403 } else {
1404 CopyFrom(from);
1405 }
1406 return *this;
1407 }
1408 #endif
1409 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1410 return _internal_metadata_.unknown_fields();
1411 }
1412 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1413 return _internal_metadata_.mutable_unknown_fields();
1414 }
1415
1416 static const ::google::protobuf::Descriptor* descriptor();
1417 static const FsPermissionProto& default_instance();
1418
1419 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1420 static inline const FsPermissionProto* internal_default_instance() {
1421 return reinterpret_cast<const FsPermissionProto*>(
1422 &_FsPermissionProto_default_instance_);
1423 }
1424 static constexpr int kIndexInFileMessages =
1425 6;
1426
1427 void Swap(FsPermissionProto* other);
1428 friend void swap(FsPermissionProto& a, FsPermissionProto& b) {
1429 a.Swap(&b);
1430 }
1431
1432 // implements Message ----------------------------------------------
1433
1434 inline FsPermissionProto* New() const final {
1435 return CreateMaybeMessage<FsPermissionProto>(NULL);
1436 }
1437
1438 FsPermissionProto* New(::google::protobuf::Arena* arena) const final {
1439 return CreateMaybeMessage<FsPermissionProto>(arena);
1440 }
1441 void CopyFrom(const ::google::protobuf::Message& from) final;
1442 void MergeFrom(const ::google::protobuf::Message& from) final;
1443 void CopyFrom(const FsPermissionProto& from);
1444 void MergeFrom(const FsPermissionProto& from);
1445 void Clear() final;
1446 bool IsInitialized() const final;
1447
1448 size_t ByteSizeLong() const final;
1449 bool MergePartialFromCodedStream(
1450 ::google::protobuf::io::CodedInputStream* input) final;
1451 void SerializeWithCachedSizes(
1452 ::google::protobuf::io::CodedOutputStream* output) const final;
1453 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1454 bool deterministic, ::google::protobuf::uint8* target) const final;
1455 int GetCachedSize() const final { return _cached_size_.Get(); }
1456
1457 private:
1458 void SharedCtor();
1459 void SharedDtor();
1460 void SetCachedSize(int size) const final;
1461 void InternalSwap(FsPermissionProto* other);
1462 private:
1463 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1464 return NULL;
1465 }
1466 inline void* MaybeArenaPtr() const {
1467 return NULL;
1468 }
1469 public:
1470
1471 ::google::protobuf::Metadata GetMetadata() const final;
1472
1473 // nested types ----------------------------------------------------
1474
1475 // accessors -------------------------------------------------------
1476
1477 // required uint32 perm = 1;
1478 bool has_perm() const;
1479 void clear_perm();
1480 static const int kPermFieldNumber = 1;
1481 ::google::protobuf::uint32 perm() const;
1482 void set_perm(::google::protobuf::uint32 value);
1483
1484 // @@protoc_insertion_point(class_scope:Hdfs.Internal.FsPermissionProto)
1485 private:
1486 void set_has_perm();
1487 void clear_has_perm();
1488
1489 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1490 ::google::protobuf::internal::HasBits<1> _has_bits_;
1491 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1492 ::google::protobuf::uint32 perm_;
1493 friend struct ::protobuf_hdfs_2eproto::TableStruct;
1494};
1495// -------------------------------------------------------------------
1496
1497class StorageUuidsProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.StorageUuidsProto) */ {
1498 public:
1499 StorageUuidsProto();
1500 virtual ~StorageUuidsProto();
1501
1502 StorageUuidsProto(const StorageUuidsProto& from);
1503
1504 inline StorageUuidsProto& operator=(const StorageUuidsProto& from) {
1505 CopyFrom(from);
1506 return *this;
1507 }
1508 #if LANG_CXX11
1509 StorageUuidsProto(StorageUuidsProto&& from) noexcept
1510 : StorageUuidsProto() {
1511 *this = ::std::move(from);
1512 }
1513
1514 inline StorageUuidsProto& operator=(StorageUuidsProto&& from) noexcept {
1515 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1516 if (this != &from) InternalSwap(&from);
1517 } else {
1518 CopyFrom(from);
1519 }
1520 return *this;
1521 }
1522 #endif
1523 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1524 return _internal_metadata_.unknown_fields();
1525 }
1526 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1527 return _internal_metadata_.mutable_unknown_fields();
1528 }
1529
1530 static const ::google::protobuf::Descriptor* descriptor();
1531 static const StorageUuidsProto& default_instance();
1532
1533 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1534 static inline const StorageUuidsProto* internal_default_instance() {
1535 return reinterpret_cast<const StorageUuidsProto*>(
1536 &_StorageUuidsProto_default_instance_);
1537 }
1538 static constexpr int kIndexInFileMessages =
1539 7;
1540
1541 void Swap(StorageUuidsProto* other);
1542 friend void swap(StorageUuidsProto& a, StorageUuidsProto& b) {
1543 a.Swap(&b);
1544 }
1545
1546 // implements Message ----------------------------------------------
1547
1548 inline StorageUuidsProto* New() const final {
1549 return CreateMaybeMessage<StorageUuidsProto>(NULL);
1550 }
1551
1552 StorageUuidsProto* New(::google::protobuf::Arena* arena) const final {
1553 return CreateMaybeMessage<StorageUuidsProto>(arena);
1554 }
1555 void CopyFrom(const ::google::protobuf::Message& from) final;
1556 void MergeFrom(const ::google::protobuf::Message& from) final;
1557 void CopyFrom(const StorageUuidsProto& from);
1558 void MergeFrom(const StorageUuidsProto& from);
1559 void Clear() final;
1560 bool IsInitialized() const final;
1561
1562 size_t ByteSizeLong() const final;
1563 bool MergePartialFromCodedStream(
1564 ::google::protobuf::io::CodedInputStream* input) final;
1565 void SerializeWithCachedSizes(
1566 ::google::protobuf::io::CodedOutputStream* output) const final;
1567 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1568 bool deterministic, ::google::protobuf::uint8* target) const final;
1569 int GetCachedSize() const final { return _cached_size_.Get(); }
1570
1571 private:
1572 void SharedCtor();
1573 void SharedDtor();
1574 void SetCachedSize(int size) const final;
1575 void InternalSwap(StorageUuidsProto* other);
1576 private:
1577 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1578 return NULL;
1579 }
1580 inline void* MaybeArenaPtr() const {
1581 return NULL;
1582 }
1583 public:
1584
1585 ::google::protobuf::Metadata GetMetadata() const final;
1586
1587 // nested types ----------------------------------------------------
1588
1589 // accessors -------------------------------------------------------
1590
1591 // repeated string storageUuids = 1;
1592 int storageuuids_size() const;
1593 void clear_storageuuids();
1594 static const int kStorageUuidsFieldNumber = 1;
1595 const ::std::string& storageuuids(int index) const;
1596 ::std::string* mutable_storageuuids(int index);
1597 void set_storageuuids(int index, const ::std::string& value);
1598 #if LANG_CXX11
1599 void set_storageuuids(int index, ::std::string&& value);
1600 #endif
1601 void set_storageuuids(int index, const char* value);
1602 void set_storageuuids(int index, const char* value, size_t size);
1603 ::std::string* add_storageuuids();
1604 void add_storageuuids(const ::std::string& value);
1605 #if LANG_CXX11
1606 void add_storageuuids(::std::string&& value);
1607 #endif
1608 void add_storageuuids(const char* value);
1609 void add_storageuuids(const char* value, size_t size);
1610 const ::google::protobuf::RepeatedPtrField< ::std::string>& storageuuids() const;
1611 ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_storageuuids();
1612
1613 // @@protoc_insertion_point(class_scope:Hdfs.Internal.StorageUuidsProto)
1614 private:
1615
1616 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1617 ::google::protobuf::internal::HasBits<1> _has_bits_;
1618 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1619 ::google::protobuf::RepeatedPtrField< ::std::string> storageuuids_;
1620 friend struct ::protobuf_hdfs_2eproto::TableStruct;
1621};
1622// -------------------------------------------------------------------
1623
1624class LocatedBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.LocatedBlockProto) */ {
1625 public:
1626 LocatedBlockProto();
1627 virtual ~LocatedBlockProto();
1628
1629 LocatedBlockProto(const LocatedBlockProto& from);
1630
1631 inline LocatedBlockProto& operator=(const LocatedBlockProto& from) {
1632 CopyFrom(from);
1633 return *this;
1634 }
1635 #if LANG_CXX11
1636 LocatedBlockProto(LocatedBlockProto&& from) noexcept
1637 : LocatedBlockProto() {
1638 *this = ::std::move(from);
1639 }
1640
1641 inline LocatedBlockProto& operator=(LocatedBlockProto&& from) noexcept {
1642 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1643 if (this != &from) InternalSwap(&from);
1644 } else {
1645 CopyFrom(from);
1646 }
1647 return *this;
1648 }
1649 #endif
1650 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1651 return _internal_metadata_.unknown_fields();
1652 }
1653 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1654 return _internal_metadata_.mutable_unknown_fields();
1655 }
1656
1657 static const ::google::protobuf::Descriptor* descriptor();
1658 static const LocatedBlockProto& default_instance();
1659
1660 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1661 static inline const LocatedBlockProto* internal_default_instance() {
1662 return reinterpret_cast<const LocatedBlockProto*>(
1663 &_LocatedBlockProto_default_instance_);
1664 }
1665 static constexpr int kIndexInFileMessages =
1666 8;
1667
1668 void Swap(LocatedBlockProto* other);
1669 friend void swap(LocatedBlockProto& a, LocatedBlockProto& b) {
1670 a.Swap(&b);
1671 }
1672
1673 // implements Message ----------------------------------------------
1674
1675 inline LocatedBlockProto* New() const final {
1676 return CreateMaybeMessage<LocatedBlockProto>(NULL);
1677 }
1678
1679 LocatedBlockProto* New(::google::protobuf::Arena* arena) const final {
1680 return CreateMaybeMessage<LocatedBlockProto>(arena);
1681 }
1682 void CopyFrom(const ::google::protobuf::Message& from) final;
1683 void MergeFrom(const ::google::protobuf::Message& from) final;
1684 void CopyFrom(const LocatedBlockProto& from);
1685 void MergeFrom(const LocatedBlockProto& from);
1686 void Clear() final;
1687 bool IsInitialized() const final;
1688
1689 size_t ByteSizeLong() const final;
1690 bool MergePartialFromCodedStream(
1691 ::google::protobuf::io::CodedInputStream* input) final;
1692 void SerializeWithCachedSizes(
1693 ::google::protobuf::io::CodedOutputStream* output) const final;
1694 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1695 bool deterministic, ::google::protobuf::uint8* target) const final;
1696 int GetCachedSize() const final { return _cached_size_.Get(); }
1697
1698 private:
1699 void SharedCtor();
1700 void SharedDtor();
1701 void SetCachedSize(int size) const final;
1702 void InternalSwap(LocatedBlockProto* other);
1703 private:
1704 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1705 return NULL;
1706 }
1707 inline void* MaybeArenaPtr() const {
1708 return NULL;
1709 }
1710 public:
1711
1712 ::google::protobuf::Metadata GetMetadata() const final;
1713
1714 // nested types ----------------------------------------------------
1715
1716 // accessors -------------------------------------------------------
1717
1718 // repeated .Hdfs.Internal.DatanodeInfoProto locs = 3;
1719 int locs_size() const;
1720 void clear_locs();
1721 static const int kLocsFieldNumber = 3;
1722 ::Hdfs::Internal::DatanodeInfoProto* mutable_locs(int index);
1723 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >*
1724 mutable_locs();
1725 const ::Hdfs::Internal::DatanodeInfoProto& locs(int index) const;
1726 ::Hdfs::Internal::DatanodeInfoProto* add_locs();
1727 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >&
1728 locs() const;
1729
1730 // repeated bool isCached = 6 [packed = true];
1731 int iscached_size() const;
1732 void clear_iscached();
1733 static const int kIsCachedFieldNumber = 6;
1734 bool iscached(int index) const;
1735 void set_iscached(int index, bool value);
1736 void add_iscached(bool value);
1737 const ::google::protobuf::RepeatedField< bool >&
1738 iscached() const;
1739 ::google::protobuf::RepeatedField< bool >*
1740 mutable_iscached();
1741
1742 // repeated .Hdfs.Internal.StorageTypeProto storageTypes = 7;
1743 int storagetypes_size() const;
1744 void clear_storagetypes();
1745 static const int kStorageTypesFieldNumber = 7;
1746 ::Hdfs::Internal::StorageTypeProto storagetypes(int index) const;
1747 void set_storagetypes(int index, ::Hdfs::Internal::StorageTypeProto value);
1748 void add_storagetypes(::Hdfs::Internal::StorageTypeProto value);
1749 const ::google::protobuf::RepeatedField<int>& storagetypes() const;
1750 ::google::protobuf::RepeatedField<int>* mutable_storagetypes();
1751
1752 // repeated string storageIDs = 8;
1753 int storageids_size() const;
1754 void clear_storageids();
1755 static const int kStorageIDsFieldNumber = 8;
1756 const ::std::string& storageids(int index) const;
1757 ::std::string* mutable_storageids(int index);
1758 void set_storageids(int index, const ::std::string& value);
1759 #if LANG_CXX11
1760 void set_storageids(int index, ::std::string&& value);
1761 #endif
1762 void set_storageids(int index, const char* value);
1763 void set_storageids(int index, const char* value, size_t size);
1764 ::std::string* add_storageids();
1765 void add_storageids(const ::std::string& value);
1766 #if LANG_CXX11
1767 void add_storageids(::std::string&& value);
1768 #endif
1769 void add_storageids(const char* value);
1770 void add_storageids(const char* value, size_t size);
1771 const ::google::protobuf::RepeatedPtrField< ::std::string>& storageids() const;
1772 ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_storageids();
1773
1774 // required .Hdfs.Internal.ExtendedBlockProto b = 1;
1775 bool has_b() const;
1776 void clear_b();
1777 static const int kBFieldNumber = 1;
1778 private:
1779 const ::Hdfs::Internal::ExtendedBlockProto& _internal_b() const;
1780 public:
1781 const ::Hdfs::Internal::ExtendedBlockProto& b() const;
1782 ::Hdfs::Internal::ExtendedBlockProto* release_b();
1783 ::Hdfs::Internal::ExtendedBlockProto* mutable_b();
1784 void set_allocated_b(::Hdfs::Internal::ExtendedBlockProto* b);
1785
1786 // required .Hdfs.Internal.TokenProto blockToken = 5;
1787 bool has_blocktoken() const;
1788 void clear_blocktoken();
1789 static const int kBlockTokenFieldNumber = 5;
1790 private:
1791 const ::Hdfs::Internal::TokenProto& _internal_blocktoken() const;
1792 public:
1793 const ::Hdfs::Internal::TokenProto& blocktoken() const;
1794 ::Hdfs::Internal::TokenProto* release_blocktoken();
1795 ::Hdfs::Internal::TokenProto* mutable_blocktoken();
1796 void set_allocated_blocktoken(::Hdfs::Internal::TokenProto* blocktoken);
1797
1798 // required uint64 offset = 2;
1799 bool has_offset() const;
1800 void clear_offset();
1801 static const int kOffsetFieldNumber = 2;
1802 ::google::protobuf::uint64 offset() const;
1803 void set_offset(::google::protobuf::uint64 value);
1804
1805 // required bool corrupt = 4;
1806 bool has_corrupt() const;
1807 void clear_corrupt();
1808 static const int kCorruptFieldNumber = 4;
1809 bool corrupt() const;
1810 void set_corrupt(bool value);
1811
1812 // @@protoc_insertion_point(class_scope:Hdfs.Internal.LocatedBlockProto)
1813 private:
1814 void set_has_b();
1815 void clear_has_b();
1816 void set_has_offset();
1817 void clear_has_offset();
1818 void set_has_corrupt();
1819 void clear_has_corrupt();
1820 void set_has_blocktoken();
1821 void clear_has_blocktoken();
1822
1823 // helper for ByteSizeLong()
1824 size_t RequiredFieldsByteSizeFallback() const;
1825
1826 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1827 ::google::protobuf::internal::HasBits<1> _has_bits_;
1828 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1829 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto > locs_;
1830 ::google::protobuf::RepeatedField< bool > iscached_;
1831 mutable int _iscached_cached_byte_size_;
1832 ::google::protobuf::RepeatedField<int> storagetypes_;
1833 ::google::protobuf::RepeatedPtrField< ::std::string> storageids_;
1834 ::Hdfs::Internal::ExtendedBlockProto* b_;
1835 ::Hdfs::Internal::TokenProto* blocktoken_;
1836 ::google::protobuf::uint64 offset_;
1837 bool corrupt_;
1838 friend struct ::protobuf_hdfs_2eproto::TableStruct;
1839};
1840// -------------------------------------------------------------------
1841
1842class DataEncryptionKeyProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DataEncryptionKeyProto) */ {
1843 public:
1844 DataEncryptionKeyProto();
1845 virtual ~DataEncryptionKeyProto();
1846
1847 DataEncryptionKeyProto(const DataEncryptionKeyProto& from);
1848
1849 inline DataEncryptionKeyProto& operator=(const DataEncryptionKeyProto& from) {
1850 CopyFrom(from);
1851 return *this;
1852 }
1853 #if LANG_CXX11
1854 DataEncryptionKeyProto(DataEncryptionKeyProto&& from) noexcept
1855 : DataEncryptionKeyProto() {
1856 *this = ::std::move(from);
1857 }
1858
1859 inline DataEncryptionKeyProto& operator=(DataEncryptionKeyProto&& from) noexcept {
1860 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1861 if (this != &from) InternalSwap(&from);
1862 } else {
1863 CopyFrom(from);
1864 }
1865 return *this;
1866 }
1867 #endif
1868 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1869 return _internal_metadata_.unknown_fields();
1870 }
1871 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1872 return _internal_metadata_.mutable_unknown_fields();
1873 }
1874
1875 static const ::google::protobuf::Descriptor* descriptor();
1876 static const DataEncryptionKeyProto& default_instance();
1877
1878 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1879 static inline const DataEncryptionKeyProto* internal_default_instance() {
1880 return reinterpret_cast<const DataEncryptionKeyProto*>(
1881 &_DataEncryptionKeyProto_default_instance_);
1882 }
1883 static constexpr int kIndexInFileMessages =
1884 9;
1885
1886 void Swap(DataEncryptionKeyProto* other);
1887 friend void swap(DataEncryptionKeyProto& a, DataEncryptionKeyProto& b) {
1888 a.Swap(&b);
1889 }
1890
1891 // implements Message ----------------------------------------------
1892
1893 inline DataEncryptionKeyProto* New() const final {
1894 return CreateMaybeMessage<DataEncryptionKeyProto>(NULL);
1895 }
1896
1897 DataEncryptionKeyProto* New(::google::protobuf::Arena* arena) const final {
1898 return CreateMaybeMessage<DataEncryptionKeyProto>(arena);
1899 }
1900 void CopyFrom(const ::google::protobuf::Message& from) final;
1901 void MergeFrom(const ::google::protobuf::Message& from) final;
1902 void CopyFrom(const DataEncryptionKeyProto& from);
1903 void MergeFrom(const DataEncryptionKeyProto& from);
1904 void Clear() final;
1905 bool IsInitialized() const final;
1906
1907 size_t ByteSizeLong() const final;
1908 bool MergePartialFromCodedStream(
1909 ::google::protobuf::io::CodedInputStream* input) final;
1910 void SerializeWithCachedSizes(
1911 ::google::protobuf::io::CodedOutputStream* output) const final;
1912 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1913 bool deterministic, ::google::protobuf::uint8* target) const final;
1914 int GetCachedSize() const final { return _cached_size_.Get(); }
1915
1916 private:
1917 void SharedCtor();
1918 void SharedDtor();
1919 void SetCachedSize(int size) const final;
1920 void InternalSwap(DataEncryptionKeyProto* other);
1921 private:
1922 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1923 return NULL;
1924 }
1925 inline void* MaybeArenaPtr() const {
1926 return NULL;
1927 }
1928 public:
1929
1930 ::google::protobuf::Metadata GetMetadata() const final;
1931
1932 // nested types ----------------------------------------------------
1933
1934 // accessors -------------------------------------------------------
1935
1936 // required string blockPoolId = 2;
1937 bool has_blockpoolid() const;
1938 void clear_blockpoolid();
1939 static const int kBlockPoolIdFieldNumber = 2;
1940 const ::std::string& blockpoolid() const;
1941 void set_blockpoolid(const ::std::string& value);
1942 #if LANG_CXX11
1943 void set_blockpoolid(::std::string&& value);
1944 #endif
1945 void set_blockpoolid(const char* value);
1946 void set_blockpoolid(const char* value, size_t size);
1947 ::std::string* mutable_blockpoolid();
1948 ::std::string* release_blockpoolid();
1949 void set_allocated_blockpoolid(::std::string* blockpoolid);
1950
1951 // required bytes nonce = 3;
1952 bool has_nonce() const;
1953 void clear_nonce();
1954 static const int kNonceFieldNumber = 3;
1955 const ::std::string& nonce() const;
1956 void set_nonce(const ::std::string& value);
1957 #if LANG_CXX11
1958 void set_nonce(::std::string&& value);
1959 #endif
1960 void set_nonce(const char* value);
1961 void set_nonce(const void* value, size_t size);
1962 ::std::string* mutable_nonce();
1963 ::std::string* release_nonce();
1964 void set_allocated_nonce(::std::string* nonce);
1965
1966 // required bytes encryptionKey = 4;
1967 bool has_encryptionkey() const;
1968 void clear_encryptionkey();
1969 static const int kEncryptionKeyFieldNumber = 4;
1970 const ::std::string& encryptionkey() const;
1971 void set_encryptionkey(const ::std::string& value);
1972 #if LANG_CXX11
1973 void set_encryptionkey(::std::string&& value);
1974 #endif
1975 void set_encryptionkey(const char* value);
1976 void set_encryptionkey(const void* value, size_t size);
1977 ::std::string* mutable_encryptionkey();
1978 ::std::string* release_encryptionkey();
1979 void set_allocated_encryptionkey(::std::string* encryptionkey);
1980
1981 // optional string encryptionAlgorithm = 6;
1982 bool has_encryptionalgorithm() const;
1983 void clear_encryptionalgorithm();
1984 static const int kEncryptionAlgorithmFieldNumber = 6;
1985 const ::std::string& encryptionalgorithm() const;
1986 void set_encryptionalgorithm(const ::std::string& value);
1987 #if LANG_CXX11
1988 void set_encryptionalgorithm(::std::string&& value);
1989 #endif
1990 void set_encryptionalgorithm(const char* value);
1991 void set_encryptionalgorithm(const char* value, size_t size);
1992 ::std::string* mutable_encryptionalgorithm();
1993 ::std::string* release_encryptionalgorithm();
1994 void set_allocated_encryptionalgorithm(::std::string* encryptionalgorithm);
1995
1996 // required uint64 expiryDate = 5;
1997 bool has_expirydate() const;
1998 void clear_expirydate();
1999 static const int kExpiryDateFieldNumber = 5;
2000 ::google::protobuf::uint64 expirydate() const;
2001 void set_expirydate(::google::protobuf::uint64 value);
2002
2003 // required uint32 keyId = 1;
2004 bool has_keyid() const;
2005 void clear_keyid();
2006 static const int kKeyIdFieldNumber = 1;
2007 ::google::protobuf::uint32 keyid() const;
2008 void set_keyid(::google::protobuf::uint32 value);
2009
2010 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DataEncryptionKeyProto)
2011 private:
2012 void set_has_keyid();
2013 void clear_has_keyid();
2014 void set_has_blockpoolid();
2015 void clear_has_blockpoolid();
2016 void set_has_nonce();
2017 void clear_has_nonce();
2018 void set_has_encryptionkey();
2019 void clear_has_encryptionkey();
2020 void set_has_expirydate();
2021 void clear_has_expirydate();
2022 void set_has_encryptionalgorithm();
2023 void clear_has_encryptionalgorithm();
2024
2025 // helper for ByteSizeLong()
2026 size_t RequiredFieldsByteSizeFallback() const;
2027
2028 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2029 ::google::protobuf::internal::HasBits<1> _has_bits_;
2030 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2031 ::google::protobuf::internal::ArenaStringPtr blockpoolid_;
2032 ::google::protobuf::internal::ArenaStringPtr nonce_;
2033 ::google::protobuf::internal::ArenaStringPtr encryptionkey_;
2034 ::google::protobuf::internal::ArenaStringPtr encryptionalgorithm_;
2035 ::google::protobuf::uint64 expirydate_;
2036 ::google::protobuf::uint32 keyid_;
2037 friend struct ::protobuf_hdfs_2eproto::TableStruct;
2038};
2039// -------------------------------------------------------------------
2040
2041class LocatedBlocksProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.LocatedBlocksProto) */ {
2042 public:
2043 LocatedBlocksProto();
2044 virtual ~LocatedBlocksProto();
2045
2046 LocatedBlocksProto(const LocatedBlocksProto& from);
2047
2048 inline LocatedBlocksProto& operator=(const LocatedBlocksProto& from) {
2049 CopyFrom(from);
2050 return *this;
2051 }
2052 #if LANG_CXX11
2053 LocatedBlocksProto(LocatedBlocksProto&& from) noexcept
2054 : LocatedBlocksProto() {
2055 *this = ::std::move(from);
2056 }
2057
2058 inline LocatedBlocksProto& operator=(LocatedBlocksProto&& from) noexcept {
2059 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2060 if (this != &from) InternalSwap(&from);
2061 } else {
2062 CopyFrom(from);
2063 }
2064 return *this;
2065 }
2066 #endif
2067 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2068 return _internal_metadata_.unknown_fields();
2069 }
2070 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2071 return _internal_metadata_.mutable_unknown_fields();
2072 }
2073
2074 static const ::google::protobuf::Descriptor* descriptor();
2075 static const LocatedBlocksProto& default_instance();
2076
2077 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2078 static inline const LocatedBlocksProto* internal_default_instance() {
2079 return reinterpret_cast<const LocatedBlocksProto*>(
2080 &_LocatedBlocksProto_default_instance_);
2081 }
2082 static constexpr int kIndexInFileMessages =
2083 10;
2084
2085 void Swap(LocatedBlocksProto* other);
2086 friend void swap(LocatedBlocksProto& a, LocatedBlocksProto& b) {
2087 a.Swap(&b);
2088 }
2089
2090 // implements Message ----------------------------------------------
2091
2092 inline LocatedBlocksProto* New() const final {
2093 return CreateMaybeMessage<LocatedBlocksProto>(NULL);
2094 }
2095
2096 LocatedBlocksProto* New(::google::protobuf::Arena* arena) const final {
2097 return CreateMaybeMessage<LocatedBlocksProto>(arena);
2098 }
2099 void CopyFrom(const ::google::protobuf::Message& from) final;
2100 void MergeFrom(const ::google::protobuf::Message& from) final;
2101 void CopyFrom(const LocatedBlocksProto& from);
2102 void MergeFrom(const LocatedBlocksProto& from);
2103 void Clear() final;
2104 bool IsInitialized() const final;
2105
2106 size_t ByteSizeLong() const final;
2107 bool MergePartialFromCodedStream(
2108 ::google::protobuf::io::CodedInputStream* input) final;
2109 void SerializeWithCachedSizes(
2110 ::google::protobuf::io::CodedOutputStream* output) const final;
2111 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2112 bool deterministic, ::google::protobuf::uint8* target) const final;
2113 int GetCachedSize() const final { return _cached_size_.Get(); }
2114
2115 private:
2116 void SharedCtor();
2117 void SharedDtor();
2118 void SetCachedSize(int size) const final;
2119 void InternalSwap(LocatedBlocksProto* other);
2120 private:
2121 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2122 return NULL;
2123 }
2124 inline void* MaybeArenaPtr() const {
2125 return NULL;
2126 }
2127 public:
2128
2129 ::google::protobuf::Metadata GetMetadata() const final;
2130
2131 // nested types ----------------------------------------------------
2132
2133 // accessors -------------------------------------------------------
2134
2135 // repeated .Hdfs.Internal.LocatedBlockProto blocks = 2;
2136 int blocks_size() const;
2137 void clear_blocks();
2138 static const int kBlocksFieldNumber = 2;
2139 ::Hdfs::Internal::LocatedBlockProto* mutable_blocks(int index);
2140 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::LocatedBlockProto >*
2141 mutable_blocks();
2142 const ::Hdfs::Internal::LocatedBlockProto& blocks(int index) const;
2143 ::Hdfs::Internal::LocatedBlockProto* add_blocks();
2144 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::LocatedBlockProto >&
2145 blocks() const;
2146
2147 // optional .Hdfs.Internal.LocatedBlockProto lastBlock = 4;
2148 bool has_lastblock() const;
2149 void clear_lastblock();
2150 static const int kLastBlockFieldNumber = 4;
2151 private:
2152 const ::Hdfs::Internal::LocatedBlockProto& _internal_lastblock() const;
2153 public:
2154 const ::Hdfs::Internal::LocatedBlockProto& lastblock() const;
2155 ::Hdfs::Internal::LocatedBlockProto* release_lastblock();
2156 ::Hdfs::Internal::LocatedBlockProto* mutable_lastblock();
2157 void set_allocated_lastblock(::Hdfs::Internal::LocatedBlockProto* lastblock);
2158
2159 // required uint64 fileLength = 1;
2160 bool has_filelength() const;
2161 void clear_filelength();
2162 static const int kFileLengthFieldNumber = 1;
2163 ::google::protobuf::uint64 filelength() const;
2164 void set_filelength(::google::protobuf::uint64 value);
2165
2166 // required bool underConstruction = 3;
2167 bool has_underconstruction() const;
2168 void clear_underconstruction();
2169 static const int kUnderConstructionFieldNumber = 3;
2170 bool underconstruction() const;
2171 void set_underconstruction(bool value);
2172
2173 // required bool isLastBlockComplete = 5;
2174 bool has_islastblockcomplete() const;
2175 void clear_islastblockcomplete();
2176 static const int kIsLastBlockCompleteFieldNumber = 5;
2177 bool islastblockcomplete() const;
2178 void set_islastblockcomplete(bool value);
2179
2180 // @@protoc_insertion_point(class_scope:Hdfs.Internal.LocatedBlocksProto)
2181 private:
2182 void set_has_filelength();
2183 void clear_has_filelength();
2184 void set_has_underconstruction();
2185 void clear_has_underconstruction();
2186 void set_has_lastblock();
2187 void clear_has_lastblock();
2188 void set_has_islastblockcomplete();
2189 void clear_has_islastblockcomplete();
2190
2191 // helper for ByteSizeLong()
2192 size_t RequiredFieldsByteSizeFallback() const;
2193
2194 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2195 ::google::protobuf::internal::HasBits<1> _has_bits_;
2196 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2197 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::LocatedBlockProto > blocks_;
2198 ::Hdfs::Internal::LocatedBlockProto* lastblock_;
2199 ::google::protobuf::uint64 filelength_;
2200 bool underconstruction_;
2201 bool islastblockcomplete_;
2202 friend struct ::protobuf_hdfs_2eproto::TableStruct;
2203};
2204// -------------------------------------------------------------------
2205
2206class HdfsFileStatusProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.HdfsFileStatusProto) */ {
2207 public:
2208 HdfsFileStatusProto();
2209 virtual ~HdfsFileStatusProto();
2210
2211 HdfsFileStatusProto(const HdfsFileStatusProto& from);
2212
2213 inline HdfsFileStatusProto& operator=(const HdfsFileStatusProto& from) {
2214 CopyFrom(from);
2215 return *this;
2216 }
2217 #if LANG_CXX11
2218 HdfsFileStatusProto(HdfsFileStatusProto&& from) noexcept
2219 : HdfsFileStatusProto() {
2220 *this = ::std::move(from);
2221 }
2222
2223 inline HdfsFileStatusProto& operator=(HdfsFileStatusProto&& from) noexcept {
2224 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2225 if (this != &from) InternalSwap(&from);
2226 } else {
2227 CopyFrom(from);
2228 }
2229 return *this;
2230 }
2231 #endif
2232 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2233 return _internal_metadata_.unknown_fields();
2234 }
2235 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2236 return _internal_metadata_.mutable_unknown_fields();
2237 }
2238
2239 static const ::google::protobuf::Descriptor* descriptor();
2240 static const HdfsFileStatusProto& default_instance();
2241
2242 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2243 static inline const HdfsFileStatusProto* internal_default_instance() {
2244 return reinterpret_cast<const HdfsFileStatusProto*>(
2245 &_HdfsFileStatusProto_default_instance_);
2246 }
2247 static constexpr int kIndexInFileMessages =
2248 11;
2249
2250 void Swap(HdfsFileStatusProto* other);
2251 friend void swap(HdfsFileStatusProto& a, HdfsFileStatusProto& b) {
2252 a.Swap(&b);
2253 }
2254
2255 // implements Message ----------------------------------------------
2256
2257 inline HdfsFileStatusProto* New() const final {
2258 return CreateMaybeMessage<HdfsFileStatusProto>(NULL);
2259 }
2260
2261 HdfsFileStatusProto* New(::google::protobuf::Arena* arena) const final {
2262 return CreateMaybeMessage<HdfsFileStatusProto>(arena);
2263 }
2264 void CopyFrom(const ::google::protobuf::Message& from) final;
2265 void MergeFrom(const ::google::protobuf::Message& from) final;
2266 void CopyFrom(const HdfsFileStatusProto& from);
2267 void MergeFrom(const HdfsFileStatusProto& from);
2268 void Clear() final;
2269 bool IsInitialized() const final;
2270
2271 size_t ByteSizeLong() const final;
2272 bool MergePartialFromCodedStream(
2273 ::google::protobuf::io::CodedInputStream* input) final;
2274 void SerializeWithCachedSizes(
2275 ::google::protobuf::io::CodedOutputStream* output) const final;
2276 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2277 bool deterministic, ::google::protobuf::uint8* target) const final;
2278 int GetCachedSize() const final { return _cached_size_.Get(); }
2279
2280 private:
2281 void SharedCtor();
2282 void SharedDtor();
2283 void SetCachedSize(int size) const final;
2284 void InternalSwap(HdfsFileStatusProto* other);
2285 private:
2286 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2287 return NULL;
2288 }
2289 inline void* MaybeArenaPtr() const {
2290 return NULL;
2291 }
2292 public:
2293
2294 ::google::protobuf::Metadata GetMetadata() const final;
2295
2296 // nested types ----------------------------------------------------
2297
2298 typedef HdfsFileStatusProto_FileType FileType;
2299 static const FileType IS_DIR =
2300 HdfsFileStatusProto_FileType_IS_DIR;
2301 static const FileType IS_FILE =
2302 HdfsFileStatusProto_FileType_IS_FILE;
2303 static const FileType IS_SYMLINK =
2304 HdfsFileStatusProto_FileType_IS_SYMLINK;
2305 static inline bool FileType_IsValid(int value) {
2306 return HdfsFileStatusProto_FileType_IsValid(value);
2307 }
2308 static const FileType FileType_MIN =
2309 HdfsFileStatusProto_FileType_FileType_MIN;
2310 static const FileType FileType_MAX =
2311 HdfsFileStatusProto_FileType_FileType_MAX;
2312 static const int FileType_ARRAYSIZE =
2313 HdfsFileStatusProto_FileType_FileType_ARRAYSIZE;
2314 static inline const ::google::protobuf::EnumDescriptor*
2315 FileType_descriptor() {
2316 return HdfsFileStatusProto_FileType_descriptor();
2317 }
2318 static inline const ::std::string& FileType_Name(FileType value) {
2319 return HdfsFileStatusProto_FileType_Name(value);
2320 }
2321 static inline bool FileType_Parse(const ::std::string& name,
2322 FileType* value) {
2323 return HdfsFileStatusProto_FileType_Parse(name, value);
2324 }
2325
2326 // accessors -------------------------------------------------------
2327
2328 // required bytes path = 2;
2329 bool has_path() const;
2330 void clear_path();
2331 static const int kPathFieldNumber = 2;
2332 const ::std::string& path() const;
2333 void set_path(const ::std::string& value);
2334 #if LANG_CXX11
2335 void set_path(::std::string&& value);
2336 #endif
2337 void set_path(const char* value);
2338 void set_path(const void* value, size_t size);
2339 ::std::string* mutable_path();
2340 ::std::string* release_path();
2341 void set_allocated_path(::std::string* path);
2342
2343 // required string owner = 5;
2344 bool has_owner() const;
2345 void clear_owner();
2346 static const int kOwnerFieldNumber = 5;
2347 const ::std::string& owner() const;
2348 void set_owner(const ::std::string& value);
2349 #if LANG_CXX11
2350 void set_owner(::std::string&& value);
2351 #endif
2352 void set_owner(const char* value);
2353 void set_owner(const char* value, size_t size);
2354 ::std::string* mutable_owner();
2355 ::std::string* release_owner();
2356 void set_allocated_owner(::std::string* owner);
2357
2358 // required string group = 6;
2359 bool has_group() const;
2360 void clear_group();
2361 static const int kGroupFieldNumber = 6;
2362 const ::std::string& group() const;
2363 void set_group(const ::std::string& value);
2364 #if LANG_CXX11
2365 void set_group(::std::string&& value);
2366 #endif
2367 void set_group(const char* value);
2368 void set_group(const char* value, size_t size);
2369 ::std::string* mutable_group();
2370 ::std::string* release_group();
2371 void set_allocated_group(::std::string* group);
2372
2373 // optional bytes symlink = 9;
2374 bool has_symlink() const;
2375 void clear_symlink();
2376 static const int kSymlinkFieldNumber = 9;
2377 const ::std::string& symlink() const;
2378 void set_symlink(const ::std::string& value);
2379 #if LANG_CXX11
2380 void set_symlink(::std::string&& value);
2381 #endif
2382 void set_symlink(const char* value);
2383 void set_symlink(const void* value, size_t size);
2384 ::std::string* mutable_symlink();
2385 ::std::string* release_symlink();
2386 void set_allocated_symlink(::std::string* symlink);
2387
2388 // required .Hdfs.Internal.FsPermissionProto permission = 4;
2389 bool has_permission() const;
2390 void clear_permission();
2391 static const int kPermissionFieldNumber = 4;
2392 private:
2393 const ::Hdfs::Internal::FsPermissionProto& _internal_permission() const;
2394 public:
2395 const ::Hdfs::Internal::FsPermissionProto& permission() const;
2396 ::Hdfs::Internal::FsPermissionProto* release_permission();
2397 ::Hdfs::Internal::FsPermissionProto* mutable_permission();
2398 void set_allocated_permission(::Hdfs::Internal::FsPermissionProto* permission);
2399
2400 // optional .Hdfs.Internal.LocatedBlocksProto locations = 12;
2401 bool has_locations() const;
2402 void clear_locations();
2403 static const int kLocationsFieldNumber = 12;
2404 private:
2405 const ::Hdfs::Internal::LocatedBlocksProto& _internal_locations() const;
2406 public:
2407 const ::Hdfs::Internal::LocatedBlocksProto& locations() const;
2408 ::Hdfs::Internal::LocatedBlocksProto* release_locations();
2409 ::Hdfs::Internal::LocatedBlocksProto* mutable_locations();
2410 void set_allocated_locations(::Hdfs::Internal::LocatedBlocksProto* locations);
2411
2412 // required uint64 length = 3;
2413 bool has_length() const;
2414 void clear_length();
2415 static const int kLengthFieldNumber = 3;
2416 ::google::protobuf::uint64 length() const;
2417 void set_length(::google::protobuf::uint64 value);
2418
2419 // required uint64 modification_time = 7;
2420 bool has_modification_time() const;
2421 void clear_modification_time();
2422 static const int kModificationTimeFieldNumber = 7;
2423 ::google::protobuf::uint64 modification_time() const;
2424 void set_modification_time(::google::protobuf::uint64 value);
2425
2426 // required uint64 access_time = 8;
2427 bool has_access_time() const;
2428 void clear_access_time();
2429 static const int kAccessTimeFieldNumber = 8;
2430 ::google::protobuf::uint64 access_time() const;
2431 void set_access_time(::google::protobuf::uint64 value);
2432
2433 // optional uint64 blocksize = 11 [default = 0];
2434 bool has_blocksize() const;
2435 void clear_blocksize();
2436 static const int kBlocksizeFieldNumber = 11;
2437 ::google::protobuf::uint64 blocksize() const;
2438 void set_blocksize(::google::protobuf::uint64 value);
2439
2440 // optional uint64 fileId = 13 [default = 0];
2441 bool has_fileid() const;
2442 void clear_fileid();
2443 static const int kFileIdFieldNumber = 13;
2444 ::google::protobuf::uint64 fileid() const;
2445 void set_fileid(::google::protobuf::uint64 value);
2446
2447 // optional uint32 block_replication = 10 [default = 0];
2448 bool has_block_replication() const;
2449 void clear_block_replication();
2450 static const int kBlockReplicationFieldNumber = 10;
2451 ::google::protobuf::uint32 block_replication() const;
2452 void set_block_replication(::google::protobuf::uint32 value);
2453
2454 // required .Hdfs.Internal.HdfsFileStatusProto.FileType fileType = 1;
2455 bool has_filetype() const;
2456 void clear_filetype();
2457 static const int kFileTypeFieldNumber = 1;
2458 ::Hdfs::Internal::HdfsFileStatusProto_FileType filetype() const;
2459 void set_filetype(::Hdfs::Internal::HdfsFileStatusProto_FileType value);
2460
2461 // optional int32 childrenNum = 14 [default = -1];
2462 bool has_childrennum() const;
2463 void clear_childrennum();
2464 static const int kChildrenNumFieldNumber = 14;
2465 ::google::protobuf::int32 childrennum() const;
2466 void set_childrennum(::google::protobuf::int32 value);
2467
2468 // @@protoc_insertion_point(class_scope:Hdfs.Internal.HdfsFileStatusProto)
2469 private:
2470 void set_has_filetype();
2471 void clear_has_filetype();
2472 void set_has_path();
2473 void clear_has_path();
2474 void set_has_length();
2475 void clear_has_length();
2476 void set_has_permission();
2477 void clear_has_permission();
2478 void set_has_owner();
2479 void clear_has_owner();
2480 void set_has_group();
2481 void clear_has_group();
2482 void set_has_modification_time();
2483 void clear_has_modification_time();
2484 void set_has_access_time();
2485 void clear_has_access_time();
2486 void set_has_symlink();
2487 void clear_has_symlink();
2488 void set_has_block_replication();
2489 void clear_has_block_replication();
2490 void set_has_blocksize();
2491 void clear_has_blocksize();
2492 void set_has_locations();
2493 void clear_has_locations();
2494 void set_has_fileid();
2495 void clear_has_fileid();
2496 void set_has_childrennum();
2497 void clear_has_childrennum();
2498
2499 // helper for ByteSizeLong()
2500 size_t RequiredFieldsByteSizeFallback() const;
2501
2502 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2503 ::google::protobuf::internal::HasBits<1> _has_bits_;
2504 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2505 ::google::protobuf::internal::ArenaStringPtr path_;
2506 ::google::protobuf::internal::ArenaStringPtr owner_;
2507 ::google::protobuf::internal::ArenaStringPtr group_;
2508 ::google::protobuf::internal::ArenaStringPtr symlink_;
2509 ::Hdfs::Internal::FsPermissionProto* permission_;
2510 ::Hdfs::Internal::LocatedBlocksProto* locations_;
2511 ::google::protobuf::uint64 length_;
2512 ::google::protobuf::uint64 modification_time_;
2513 ::google::protobuf::uint64 access_time_;
2514 ::google::protobuf::uint64 blocksize_;
2515 ::google::protobuf::uint64 fileid_;
2516 ::google::protobuf::uint32 block_replication_;
2517 int filetype_;
2518 ::google::protobuf::int32 childrennum_;
2519 friend struct ::protobuf_hdfs_2eproto::TableStruct;
2520};
2521// -------------------------------------------------------------------
2522
2523class FsServerDefaultsProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.FsServerDefaultsProto) */ {
2524 public:
2525 FsServerDefaultsProto();
2526 virtual ~FsServerDefaultsProto();
2527
2528 FsServerDefaultsProto(const FsServerDefaultsProto& from);
2529
2530 inline FsServerDefaultsProto& operator=(const FsServerDefaultsProto& from) {
2531 CopyFrom(from);
2532 return *this;
2533 }
2534 #if LANG_CXX11
2535 FsServerDefaultsProto(FsServerDefaultsProto&& from) noexcept
2536 : FsServerDefaultsProto() {
2537 *this = ::std::move(from);
2538 }
2539
2540 inline FsServerDefaultsProto& operator=(FsServerDefaultsProto&& from) noexcept {
2541 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2542 if (this != &from) InternalSwap(&from);
2543 } else {
2544 CopyFrom(from);
2545 }
2546 return *this;
2547 }
2548 #endif
2549 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2550 return _internal_metadata_.unknown_fields();
2551 }
2552 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2553 return _internal_metadata_.mutable_unknown_fields();
2554 }
2555
2556 static const ::google::protobuf::Descriptor* descriptor();
2557 static const FsServerDefaultsProto& default_instance();
2558
2559 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2560 static inline const FsServerDefaultsProto* internal_default_instance() {
2561 return reinterpret_cast<const FsServerDefaultsProto*>(
2562 &_FsServerDefaultsProto_default_instance_);
2563 }
2564 static constexpr int kIndexInFileMessages =
2565 12;
2566
2567 void Swap(FsServerDefaultsProto* other);
2568 friend void swap(FsServerDefaultsProto& a, FsServerDefaultsProto& b) {
2569 a.Swap(&b);
2570 }
2571
2572 // implements Message ----------------------------------------------
2573
2574 inline FsServerDefaultsProto* New() const final {
2575 return CreateMaybeMessage<FsServerDefaultsProto>(NULL);
2576 }
2577
2578 FsServerDefaultsProto* New(::google::protobuf::Arena* arena) const final {
2579 return CreateMaybeMessage<FsServerDefaultsProto>(arena);
2580 }
2581 void CopyFrom(const ::google::protobuf::Message& from) final;
2582 void MergeFrom(const ::google::protobuf::Message& from) final;
2583 void CopyFrom(const FsServerDefaultsProto& from);
2584 void MergeFrom(const FsServerDefaultsProto& from);
2585 void Clear() final;
2586 bool IsInitialized() const final;
2587
2588 size_t ByteSizeLong() const final;
2589 bool MergePartialFromCodedStream(
2590 ::google::protobuf::io::CodedInputStream* input) final;
2591 void SerializeWithCachedSizes(
2592 ::google::protobuf::io::CodedOutputStream* output) const final;
2593 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2594 bool deterministic, ::google::protobuf::uint8* target) const final;
2595 int GetCachedSize() const final { return _cached_size_.Get(); }
2596
2597 private:
2598 void SharedCtor();
2599 void SharedDtor();
2600 void SetCachedSize(int size) const final;
2601 void InternalSwap(FsServerDefaultsProto* other);
2602 private:
2603 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2604 return NULL;
2605 }
2606 inline void* MaybeArenaPtr() const {
2607 return NULL;
2608 }
2609 public:
2610
2611 ::google::protobuf::Metadata GetMetadata() const final;
2612
2613 // nested types ----------------------------------------------------
2614
2615 // accessors -------------------------------------------------------
2616
2617 // required uint64 blockSize = 1;
2618 bool has_blocksize() const;
2619 void clear_blocksize();
2620 static const int kBlockSizeFieldNumber = 1;
2621 ::google::protobuf::uint64 blocksize() const;
2622 void set_blocksize(::google::protobuf::uint64 value);
2623
2624 // required uint32 bytesPerChecksum = 2;
2625 bool has_bytesperchecksum() const;
2626 void clear_bytesperchecksum();
2627 static const int kBytesPerChecksumFieldNumber = 2;
2628 ::google::protobuf::uint32 bytesperchecksum() const;
2629 void set_bytesperchecksum(::google::protobuf::uint32 value);
2630
2631 // required uint32 writePacketSize = 3;
2632 bool has_writepacketsize() const;
2633 void clear_writepacketsize();
2634 static const int kWritePacketSizeFieldNumber = 3;
2635 ::google::protobuf::uint32 writepacketsize() const;
2636 void set_writepacketsize(::google::protobuf::uint32 value);
2637
2638 // required uint32 replication = 4;
2639 bool has_replication() const;
2640 void clear_replication();
2641 static const int kReplicationFieldNumber = 4;
2642 ::google::protobuf::uint32 replication() const;
2643 void set_replication(::google::protobuf::uint32 value);
2644
2645 // required uint32 fileBufferSize = 5;
2646 bool has_filebuffersize() const;
2647 void clear_filebuffersize();
2648 static const int kFileBufferSizeFieldNumber = 5;
2649 ::google::protobuf::uint32 filebuffersize() const;
2650 void set_filebuffersize(::google::protobuf::uint32 value);
2651
2652 // optional uint64 trashInterval = 7 [default = 0];
2653 bool has_trashinterval() const;
2654 void clear_trashinterval();
2655 static const int kTrashIntervalFieldNumber = 7;
2656 ::google::protobuf::uint64 trashinterval() const;
2657 void set_trashinterval(::google::protobuf::uint64 value);
2658
2659 // optional bool encryptDataTransfer = 6 [default = false];
2660 bool has_encryptdatatransfer() const;
2661 void clear_encryptdatatransfer();
2662 static const int kEncryptDataTransferFieldNumber = 6;
2663 bool encryptdatatransfer() const;
2664 void set_encryptdatatransfer(bool value);
2665
2666 // optional .Hdfs.Internal.ChecksumTypeProto checksumType = 8 [default = CHECKSUM_CRC32];
2667 bool has_checksumtype() const;
2668 void clear_checksumtype();
2669 static const int kChecksumTypeFieldNumber = 8;
2670 ::Hdfs::Internal::ChecksumTypeProto checksumtype() const;
2671 void set_checksumtype(::Hdfs::Internal::ChecksumTypeProto value);
2672
2673 // @@protoc_insertion_point(class_scope:Hdfs.Internal.FsServerDefaultsProto)
2674 private:
2675 void set_has_blocksize();
2676 void clear_has_blocksize();
2677 void set_has_bytesperchecksum();
2678 void clear_has_bytesperchecksum();
2679 void set_has_writepacketsize();
2680 void clear_has_writepacketsize();
2681 void set_has_replication();
2682 void clear_has_replication();
2683 void set_has_filebuffersize();
2684 void clear_has_filebuffersize();
2685 void set_has_encryptdatatransfer();
2686 void clear_has_encryptdatatransfer();
2687 void set_has_trashinterval();
2688 void clear_has_trashinterval();
2689 void set_has_checksumtype();
2690 void clear_has_checksumtype();
2691
2692 // helper for ByteSizeLong()
2693 size_t RequiredFieldsByteSizeFallback() const;
2694
2695 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2696 ::google::protobuf::internal::HasBits<1> _has_bits_;
2697 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2698 ::google::protobuf::uint64 blocksize_;
2699 ::google::protobuf::uint32 bytesperchecksum_;
2700 ::google::protobuf::uint32 writepacketsize_;
2701 ::google::protobuf::uint32 replication_;
2702 ::google::protobuf::uint32 filebuffersize_;
2703 ::google::protobuf::uint64 trashinterval_;
2704 bool encryptdatatransfer_;
2705 int checksumtype_;
2706 friend struct ::protobuf_hdfs_2eproto::TableStruct;
2707};
2708// -------------------------------------------------------------------
2709
2710class DirectoryListingProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DirectoryListingProto) */ {
2711 public:
2712 DirectoryListingProto();
2713 virtual ~DirectoryListingProto();
2714
2715 DirectoryListingProto(const DirectoryListingProto& from);
2716
2717 inline DirectoryListingProto& operator=(const DirectoryListingProto& from) {
2718 CopyFrom(from);
2719 return *this;
2720 }
2721 #if LANG_CXX11
2722 DirectoryListingProto(DirectoryListingProto&& from) noexcept
2723 : DirectoryListingProto() {
2724 *this = ::std::move(from);
2725 }
2726
2727 inline DirectoryListingProto& operator=(DirectoryListingProto&& from) noexcept {
2728 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2729 if (this != &from) InternalSwap(&from);
2730 } else {
2731 CopyFrom(from);
2732 }
2733 return *this;
2734 }
2735 #endif
2736 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2737 return _internal_metadata_.unknown_fields();
2738 }
2739 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2740 return _internal_metadata_.mutable_unknown_fields();
2741 }
2742
2743 static const ::google::protobuf::Descriptor* descriptor();
2744 static const DirectoryListingProto& default_instance();
2745
2746 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2747 static inline const DirectoryListingProto* internal_default_instance() {
2748 return reinterpret_cast<const DirectoryListingProto*>(
2749 &_DirectoryListingProto_default_instance_);
2750 }
2751 static constexpr int kIndexInFileMessages =
2752 13;
2753
2754 void Swap(DirectoryListingProto* other);
2755 friend void swap(DirectoryListingProto& a, DirectoryListingProto& b) {
2756 a.Swap(&b);
2757 }
2758
2759 // implements Message ----------------------------------------------
2760
2761 inline DirectoryListingProto* New() const final {
2762 return CreateMaybeMessage<DirectoryListingProto>(NULL);
2763 }
2764
2765 DirectoryListingProto* New(::google::protobuf::Arena* arena) const final {
2766 return CreateMaybeMessage<DirectoryListingProto>(arena);
2767 }
2768 void CopyFrom(const ::google::protobuf::Message& from) final;
2769 void MergeFrom(const ::google::protobuf::Message& from) final;
2770 void CopyFrom(const DirectoryListingProto& from);
2771 void MergeFrom(const DirectoryListingProto& from);
2772 void Clear() final;
2773 bool IsInitialized() const final;
2774
2775 size_t ByteSizeLong() const final;
2776 bool MergePartialFromCodedStream(
2777 ::google::protobuf::io::CodedInputStream* input) final;
2778 void SerializeWithCachedSizes(
2779 ::google::protobuf::io::CodedOutputStream* output) const final;
2780 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2781 bool deterministic, ::google::protobuf::uint8* target) const final;
2782 int GetCachedSize() const final { return _cached_size_.Get(); }
2783
2784 private:
2785 void SharedCtor();
2786 void SharedDtor();
2787 void SetCachedSize(int size) const final;
2788 void InternalSwap(DirectoryListingProto* other);
2789 private:
2790 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2791 return NULL;
2792 }
2793 inline void* MaybeArenaPtr() const {
2794 return NULL;
2795 }
2796 public:
2797
2798 ::google::protobuf::Metadata GetMetadata() const final;
2799
2800 // nested types ----------------------------------------------------
2801
2802 // accessors -------------------------------------------------------
2803
2804 // repeated .Hdfs.Internal.HdfsFileStatusProto partialListing = 1;
2805 int partiallisting_size() const;
2806 void clear_partiallisting();
2807 static const int kPartialListingFieldNumber = 1;
2808 ::Hdfs::Internal::HdfsFileStatusProto* mutable_partiallisting(int index);
2809 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::HdfsFileStatusProto >*
2810 mutable_partiallisting();
2811 const ::Hdfs::Internal::HdfsFileStatusProto& partiallisting(int index) const;
2812 ::Hdfs::Internal::HdfsFileStatusProto* add_partiallisting();
2813 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::HdfsFileStatusProto >&
2814 partiallisting() const;
2815
2816 // required uint32 remainingEntries = 2;
2817 bool has_remainingentries() const;
2818 void clear_remainingentries();
2819 static const int kRemainingEntriesFieldNumber = 2;
2820 ::google::protobuf::uint32 remainingentries() const;
2821 void set_remainingentries(::google::protobuf::uint32 value);
2822
2823 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DirectoryListingProto)
2824 private:
2825 void set_has_remainingentries();
2826 void clear_has_remainingentries();
2827
2828 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2829 ::google::protobuf::internal::HasBits<1> _has_bits_;
2830 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2831 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::HdfsFileStatusProto > partiallisting_;
2832 ::google::protobuf::uint32 remainingentries_;
2833 friend struct ::protobuf_hdfs_2eproto::TableStruct;
2834};
2835// -------------------------------------------------------------------
2836
2837class SnapshottableDirectoryStatusProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.SnapshottableDirectoryStatusProto) */ {
2838 public:
2839 SnapshottableDirectoryStatusProto();
2840 virtual ~SnapshottableDirectoryStatusProto();
2841
2842 SnapshottableDirectoryStatusProto(const SnapshottableDirectoryStatusProto& from);
2843
2844 inline SnapshottableDirectoryStatusProto& operator=(const SnapshottableDirectoryStatusProto& from) {
2845 CopyFrom(from);
2846 return *this;
2847 }
2848 #if LANG_CXX11
2849 SnapshottableDirectoryStatusProto(SnapshottableDirectoryStatusProto&& from) noexcept
2850 : SnapshottableDirectoryStatusProto() {
2851 *this = ::std::move(from);
2852 }
2853
2854 inline SnapshottableDirectoryStatusProto& operator=(SnapshottableDirectoryStatusProto&& from) noexcept {
2855 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2856 if (this != &from) InternalSwap(&from);
2857 } else {
2858 CopyFrom(from);
2859 }
2860 return *this;
2861 }
2862 #endif
2863 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2864 return _internal_metadata_.unknown_fields();
2865 }
2866 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2867 return _internal_metadata_.mutable_unknown_fields();
2868 }
2869
2870 static const ::google::protobuf::Descriptor* descriptor();
2871 static const SnapshottableDirectoryStatusProto& default_instance();
2872
2873 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2874 static inline const SnapshottableDirectoryStatusProto* internal_default_instance() {
2875 return reinterpret_cast<const SnapshottableDirectoryStatusProto*>(
2876 &_SnapshottableDirectoryStatusProto_default_instance_);
2877 }
2878 static constexpr int kIndexInFileMessages =
2879 14;
2880
2881 void Swap(SnapshottableDirectoryStatusProto* other);
2882 friend void swap(SnapshottableDirectoryStatusProto& a, SnapshottableDirectoryStatusProto& b) {
2883 a.Swap(&b);
2884 }
2885
2886 // implements Message ----------------------------------------------
2887
2888 inline SnapshottableDirectoryStatusProto* New() const final {
2889 return CreateMaybeMessage<SnapshottableDirectoryStatusProto>(NULL);
2890 }
2891
2892 SnapshottableDirectoryStatusProto* New(::google::protobuf::Arena* arena) const final {
2893 return CreateMaybeMessage<SnapshottableDirectoryStatusProto>(arena);
2894 }
2895 void CopyFrom(const ::google::protobuf::Message& from) final;
2896 void MergeFrom(const ::google::protobuf::Message& from) final;
2897 void CopyFrom(const SnapshottableDirectoryStatusProto& from);
2898 void MergeFrom(const SnapshottableDirectoryStatusProto& from);
2899 void Clear() final;
2900 bool IsInitialized() const final;
2901
2902 size_t ByteSizeLong() const final;
2903 bool MergePartialFromCodedStream(
2904 ::google::protobuf::io::CodedInputStream* input) final;
2905 void SerializeWithCachedSizes(
2906 ::google::protobuf::io::CodedOutputStream* output) const final;
2907 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2908 bool deterministic, ::google::protobuf::uint8* target) const final;
2909 int GetCachedSize() const final { return _cached_size_.Get(); }
2910
2911 private:
2912 void SharedCtor();
2913 void SharedDtor();
2914 void SetCachedSize(int size) const final;
2915 void InternalSwap(SnapshottableDirectoryStatusProto* other);
2916 private:
2917 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2918 return NULL;
2919 }
2920 inline void* MaybeArenaPtr() const {
2921 return NULL;
2922 }
2923 public:
2924
2925 ::google::protobuf::Metadata GetMetadata() const final;
2926
2927 // nested types ----------------------------------------------------
2928
2929 // accessors -------------------------------------------------------
2930
2931 // required bytes parent_fullpath = 4;
2932 bool has_parent_fullpath() const;
2933 void clear_parent_fullpath();
2934 static const int kParentFullpathFieldNumber = 4;
2935 const ::std::string& parent_fullpath() const;
2936 void set_parent_fullpath(const ::std::string& value);
2937 #if LANG_CXX11
2938 void set_parent_fullpath(::std::string&& value);
2939 #endif
2940 void set_parent_fullpath(const char* value);
2941 void set_parent_fullpath(const void* value, size_t size);
2942 ::std::string* mutable_parent_fullpath();
2943 ::std::string* release_parent_fullpath();
2944 void set_allocated_parent_fullpath(::std::string* parent_fullpath);
2945
2946 // required .Hdfs.Internal.HdfsFileStatusProto dirStatus = 1;
2947 bool has_dirstatus() const;
2948 void clear_dirstatus();
2949 static const int kDirStatusFieldNumber = 1;
2950 private:
2951 const ::Hdfs::Internal::HdfsFileStatusProto& _internal_dirstatus() const;
2952 public:
2953 const ::Hdfs::Internal::HdfsFileStatusProto& dirstatus() const;
2954 ::Hdfs::Internal::HdfsFileStatusProto* release_dirstatus();
2955 ::Hdfs::Internal::HdfsFileStatusProto* mutable_dirstatus();
2956 void set_allocated_dirstatus(::Hdfs::Internal::HdfsFileStatusProto* dirstatus);
2957
2958 // required uint32 snapshot_quota = 2;
2959 bool has_snapshot_quota() const;
2960 void clear_snapshot_quota();
2961 static const int kSnapshotQuotaFieldNumber = 2;
2962 ::google::protobuf::uint32 snapshot_quota() const;
2963 void set_snapshot_quota(::google::protobuf::uint32 value);
2964
2965 // required uint32 snapshot_number = 3;
2966 bool has_snapshot_number() const;
2967 void clear_snapshot_number();
2968 static const int kSnapshotNumberFieldNumber = 3;
2969 ::google::protobuf::uint32 snapshot_number() const;
2970 void set_snapshot_number(::google::protobuf::uint32 value);
2971
2972 // @@protoc_insertion_point(class_scope:Hdfs.Internal.SnapshottableDirectoryStatusProto)
2973 private:
2974 void set_has_dirstatus();
2975 void clear_has_dirstatus();
2976 void set_has_snapshot_quota();
2977 void clear_has_snapshot_quota();
2978 void set_has_snapshot_number();
2979 void clear_has_snapshot_number();
2980 void set_has_parent_fullpath();
2981 void clear_has_parent_fullpath();
2982
2983 // helper for ByteSizeLong()
2984 size_t RequiredFieldsByteSizeFallback() const;
2985
2986 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2987 ::google::protobuf::internal::HasBits<1> _has_bits_;
2988 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2989 ::google::protobuf::internal::ArenaStringPtr parent_fullpath_;
2990 ::Hdfs::Internal::HdfsFileStatusProto* dirstatus_;
2991 ::google::protobuf::uint32 snapshot_quota_;
2992 ::google::protobuf::uint32 snapshot_number_;
2993 friend struct ::protobuf_hdfs_2eproto::TableStruct;
2994};
2995// -------------------------------------------------------------------
2996
2997class SnapshottableDirectoryListingProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.SnapshottableDirectoryListingProto) */ {
2998 public:
2999 SnapshottableDirectoryListingProto();
3000 virtual ~SnapshottableDirectoryListingProto();
3001
3002 SnapshottableDirectoryListingProto(const SnapshottableDirectoryListingProto& from);
3003
3004 inline SnapshottableDirectoryListingProto& operator=(const SnapshottableDirectoryListingProto& from) {
3005 CopyFrom(from);
3006 return *this;
3007 }
3008 #if LANG_CXX11
3009 SnapshottableDirectoryListingProto(SnapshottableDirectoryListingProto&& from) noexcept
3010 : SnapshottableDirectoryListingProto() {
3011 *this = ::std::move(from);
3012 }
3013
3014 inline SnapshottableDirectoryListingProto& operator=(SnapshottableDirectoryListingProto&& from) noexcept {
3015 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3016 if (this != &from) InternalSwap(&from);
3017 } else {
3018 CopyFrom(from);
3019 }
3020 return *this;
3021 }
3022 #endif
3023 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3024 return _internal_metadata_.unknown_fields();
3025 }
3026 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3027 return _internal_metadata_.mutable_unknown_fields();
3028 }
3029
3030 static const ::google::protobuf::Descriptor* descriptor();
3031 static const SnapshottableDirectoryListingProto& default_instance();
3032
3033 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3034 static inline const SnapshottableDirectoryListingProto* internal_default_instance() {
3035 return reinterpret_cast<const SnapshottableDirectoryListingProto*>(
3036 &_SnapshottableDirectoryListingProto_default_instance_);
3037 }
3038 static constexpr int kIndexInFileMessages =
3039 15;
3040
3041 void Swap(SnapshottableDirectoryListingProto* other);
3042 friend void swap(SnapshottableDirectoryListingProto& a, SnapshottableDirectoryListingProto& b) {
3043 a.Swap(&b);
3044 }
3045
3046 // implements Message ----------------------------------------------
3047
3048 inline SnapshottableDirectoryListingProto* New() const final {
3049 return CreateMaybeMessage<SnapshottableDirectoryListingProto>(NULL);
3050 }
3051
3052 SnapshottableDirectoryListingProto* New(::google::protobuf::Arena* arena) const final {
3053 return CreateMaybeMessage<SnapshottableDirectoryListingProto>(arena);
3054 }
3055 void CopyFrom(const ::google::protobuf::Message& from) final;
3056 void MergeFrom(const ::google::protobuf::Message& from) final;
3057 void CopyFrom(const SnapshottableDirectoryListingProto& from);
3058 void MergeFrom(const SnapshottableDirectoryListingProto& from);
3059 void Clear() final;
3060 bool IsInitialized() const final;
3061
3062 size_t ByteSizeLong() const final;
3063 bool MergePartialFromCodedStream(
3064 ::google::protobuf::io::CodedInputStream* input) final;
3065 void SerializeWithCachedSizes(
3066 ::google::protobuf::io::CodedOutputStream* output) const final;
3067 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
3068 bool deterministic, ::google::protobuf::uint8* target) const final;
3069 int GetCachedSize() const final { return _cached_size_.Get(); }
3070
3071 private:
3072 void SharedCtor();
3073 void SharedDtor();
3074 void SetCachedSize(int size) const final;
3075 void InternalSwap(SnapshottableDirectoryListingProto* other);
3076 private:
3077 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
3078 return NULL;
3079 }
3080 inline void* MaybeArenaPtr() const {
3081 return NULL;
3082 }
3083 public:
3084
3085 ::google::protobuf::Metadata GetMetadata() const final;
3086
3087 // nested types ----------------------------------------------------
3088
3089 // accessors -------------------------------------------------------
3090
3091 // repeated .Hdfs.Internal.SnapshottableDirectoryStatusProto snapshottableDirListing = 1;
3092 int snapshottabledirlisting_size() const;
3093 void clear_snapshottabledirlisting();
3094 static const int kSnapshottableDirListingFieldNumber = 1;
3095 ::Hdfs::Internal::SnapshottableDirectoryStatusProto* mutable_snapshottabledirlisting(int index);
3096 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshottableDirectoryStatusProto >*
3097 mutable_snapshottabledirlisting();
3098 const ::Hdfs::Internal::SnapshottableDirectoryStatusProto& snapshottabledirlisting(int index) const;
3099 ::Hdfs::Internal::SnapshottableDirectoryStatusProto* add_snapshottabledirlisting();
3100 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshottableDirectoryStatusProto >&
3101 snapshottabledirlisting() const;
3102
3103 // @@protoc_insertion_point(class_scope:Hdfs.Internal.SnapshottableDirectoryListingProto)
3104 private:
3105
3106 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3107 ::google::protobuf::internal::HasBits<1> _has_bits_;
3108 mutable ::google::protobuf::internal::CachedSize _cached_size_;
3109 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshottableDirectoryStatusProto > snapshottabledirlisting_;
3110 friend struct ::protobuf_hdfs_2eproto::TableStruct;
3111};
3112// -------------------------------------------------------------------
3113
3114class SnapshotDiffReportEntryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.SnapshotDiffReportEntryProto) */ {
3115 public:
3116 SnapshotDiffReportEntryProto();
3117 virtual ~SnapshotDiffReportEntryProto();
3118
3119 SnapshotDiffReportEntryProto(const SnapshotDiffReportEntryProto& from);
3120
3121 inline SnapshotDiffReportEntryProto& operator=(const SnapshotDiffReportEntryProto& from) {
3122 CopyFrom(from);
3123 return *this;
3124 }
3125 #if LANG_CXX11
3126 SnapshotDiffReportEntryProto(SnapshotDiffReportEntryProto&& from) noexcept
3127 : SnapshotDiffReportEntryProto() {
3128 *this = ::std::move(from);
3129 }
3130
3131 inline SnapshotDiffReportEntryProto& operator=(SnapshotDiffReportEntryProto&& from) noexcept {
3132 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3133 if (this != &from) InternalSwap(&from);
3134 } else {
3135 CopyFrom(from);
3136 }
3137 return *this;
3138 }
3139 #endif
3140 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3141 return _internal_metadata_.unknown_fields();
3142 }
3143 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3144 return _internal_metadata_.mutable_unknown_fields();
3145 }
3146
3147 static const ::google::protobuf::Descriptor* descriptor();
3148 static const SnapshotDiffReportEntryProto& default_instance();
3149
3150 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3151 static inline const SnapshotDiffReportEntryProto* internal_default_instance() {
3152 return reinterpret_cast<const SnapshotDiffReportEntryProto*>(
3153 &_SnapshotDiffReportEntryProto_default_instance_);
3154 }
3155 static constexpr int kIndexInFileMessages =
3156 16;
3157
3158 void Swap(SnapshotDiffReportEntryProto* other);
3159 friend void swap(SnapshotDiffReportEntryProto& a, SnapshotDiffReportEntryProto& b) {
3160 a.Swap(&b);
3161 }
3162
3163 // implements Message ----------------------------------------------
3164
3165 inline SnapshotDiffReportEntryProto* New() const final {
3166 return CreateMaybeMessage<SnapshotDiffReportEntryProto>(NULL);
3167 }
3168
3169 SnapshotDiffReportEntryProto* New(::google::protobuf::Arena* arena) const final {
3170 return CreateMaybeMessage<SnapshotDiffReportEntryProto>(arena);
3171 }
3172 void CopyFrom(const ::google::protobuf::Message& from) final;
3173 void MergeFrom(const ::google::protobuf::Message& from) final;
3174 void CopyFrom(const SnapshotDiffReportEntryProto& from);
3175 void MergeFrom(const SnapshotDiffReportEntryProto& from);
3176 void Clear() final;
3177 bool IsInitialized() const final;
3178
3179 size_t ByteSizeLong() const final;
3180 bool MergePartialFromCodedStream(
3181 ::google::protobuf::io::CodedInputStream* input) final;
3182 void SerializeWithCachedSizes(
3183 ::google::protobuf::io::CodedOutputStream* output) const final;
3184 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
3185 bool deterministic, ::google::protobuf::uint8* target) const final;
3186 int GetCachedSize() const final { return _cached_size_.Get(); }
3187
3188 private:
3189 void SharedCtor();
3190 void SharedDtor();
3191 void SetCachedSize(int size) const final;
3192 void InternalSwap(SnapshotDiffReportEntryProto* other);
3193 private:
3194 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
3195 return NULL;
3196 }
3197 inline void* MaybeArenaPtr() const {
3198 return NULL;
3199 }
3200 public:
3201
3202 ::google::protobuf::Metadata GetMetadata() const final;
3203
3204 // nested types ----------------------------------------------------
3205
3206 // accessors -------------------------------------------------------
3207
3208 // required bytes fullpath = 1;
3209 bool has_fullpath() const;
3210 void clear_fullpath();
3211 static const int kFullpathFieldNumber = 1;
3212 const ::std::string& fullpath() const;
3213 void set_fullpath(const ::std::string& value);
3214 #if LANG_CXX11
3215 void set_fullpath(::std::string&& value);
3216 #endif
3217 void set_fullpath(const char* value);
3218 void set_fullpath(const void* value, size_t size);
3219 ::std::string* mutable_fullpath();
3220 ::std::string* release_fullpath();
3221 void set_allocated_fullpath(::std::string* fullpath);
3222
3223 // required string modificationLabel = 2;
3224 bool has_modificationlabel() const;
3225 void clear_modificationlabel();
3226 static const int kModificationLabelFieldNumber = 2;
3227 const ::std::string& modificationlabel() const;
3228 void set_modificationlabel(const ::std::string& value);
3229 #if LANG_CXX11
3230 void set_modificationlabel(::std::string&& value);
3231 #endif
3232 void set_modificationlabel(const char* value);
3233 void set_modificationlabel(const char* value, size_t size);
3234 ::std::string* mutable_modificationlabel();
3235 ::std::string* release_modificationlabel();
3236 void set_allocated_modificationlabel(::std::string* modificationlabel);
3237
3238 // @@protoc_insertion_point(class_scope:Hdfs.Internal.SnapshotDiffReportEntryProto)
3239 private:
3240 void set_has_fullpath();
3241 void clear_has_fullpath();
3242 void set_has_modificationlabel();
3243 void clear_has_modificationlabel();
3244
3245 // helper for ByteSizeLong()
3246 size_t RequiredFieldsByteSizeFallback() const;
3247
3248 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3249 ::google::protobuf::internal::HasBits<1> _has_bits_;
3250 mutable ::google::protobuf::internal::CachedSize _cached_size_;
3251 ::google::protobuf::internal::ArenaStringPtr fullpath_;
3252 ::google::protobuf::internal::ArenaStringPtr modificationlabel_;
3253 friend struct ::protobuf_hdfs_2eproto::TableStruct;
3254};
3255// -------------------------------------------------------------------
3256
3257class SnapshotDiffReportProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.SnapshotDiffReportProto) */ {
3258 public:
3259 SnapshotDiffReportProto();
3260 virtual ~SnapshotDiffReportProto();
3261
3262 SnapshotDiffReportProto(const SnapshotDiffReportProto& from);
3263
3264 inline SnapshotDiffReportProto& operator=(const SnapshotDiffReportProto& from) {
3265 CopyFrom(from);
3266 return *this;
3267 }
3268 #if LANG_CXX11
3269 SnapshotDiffReportProto(SnapshotDiffReportProto&& from) noexcept
3270 : SnapshotDiffReportProto() {
3271 *this = ::std::move(from);
3272 }
3273
3274 inline SnapshotDiffReportProto& operator=(SnapshotDiffReportProto&& from) noexcept {
3275 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3276 if (this != &from) InternalSwap(&from);
3277 } else {
3278 CopyFrom(from);
3279 }
3280 return *this;
3281 }
3282 #endif
3283 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3284 return _internal_metadata_.unknown_fields();
3285 }
3286 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3287 return _internal_metadata_.mutable_unknown_fields();
3288 }
3289
3290 static const ::google::protobuf::Descriptor* descriptor();
3291 static const SnapshotDiffReportProto& default_instance();
3292
3293 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3294 static inline const SnapshotDiffReportProto* internal_default_instance() {
3295 return reinterpret_cast<const SnapshotDiffReportProto*>(
3296 &_SnapshotDiffReportProto_default_instance_);
3297 }
3298 static constexpr int kIndexInFileMessages =
3299 17;
3300
3301 void Swap(SnapshotDiffReportProto* other);
3302 friend void swap(SnapshotDiffReportProto& a, SnapshotDiffReportProto& b) {
3303 a.Swap(&b);
3304 }
3305
3306 // implements Message ----------------------------------------------
3307
3308 inline SnapshotDiffReportProto* New() const final {
3309 return CreateMaybeMessage<SnapshotDiffReportProto>(NULL);
3310 }
3311
3312 SnapshotDiffReportProto* New(::google::protobuf::Arena* arena) const final {
3313 return CreateMaybeMessage<SnapshotDiffReportProto>(arena);
3314 }
3315 void CopyFrom(const ::google::protobuf::Message& from) final;
3316 void MergeFrom(const ::google::protobuf::Message& from) final;
3317 void CopyFrom(const SnapshotDiffReportProto& from);
3318 void MergeFrom(const SnapshotDiffReportProto& from);
3319 void Clear() final;
3320 bool IsInitialized() const final;
3321
3322 size_t ByteSizeLong() const final;
3323 bool MergePartialFromCodedStream(
3324 ::google::protobuf::io::CodedInputStream* input) final;
3325 void SerializeWithCachedSizes(
3326 ::google::protobuf::io::CodedOutputStream* output) const final;
3327 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
3328 bool deterministic, ::google::protobuf::uint8* target) const final;
3329 int GetCachedSize() const final { return _cached_size_.Get(); }
3330
3331 private:
3332 void SharedCtor();
3333 void SharedDtor();
3334 void SetCachedSize(int size) const final;
3335 void InternalSwap(SnapshotDiffReportProto* other);
3336 private:
3337 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
3338 return NULL;
3339 }
3340 inline void* MaybeArenaPtr() const {
3341 return NULL;
3342 }
3343 public:
3344
3345 ::google::protobuf::Metadata GetMetadata() const final;
3346
3347 // nested types ----------------------------------------------------
3348
3349 // accessors -------------------------------------------------------
3350
3351 // repeated .Hdfs.Internal.SnapshotDiffReportEntryProto diffReportEntries = 4;
3352 int diffreportentries_size() const;
3353 void clear_diffreportentries();
3354 static const int kDiffReportEntriesFieldNumber = 4;
3355 ::Hdfs::Internal::SnapshotDiffReportEntryProto* mutable_diffreportentries(int index);
3356 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshotDiffReportEntryProto >*
3357 mutable_diffreportentries();
3358 const ::Hdfs::Internal::SnapshotDiffReportEntryProto& diffreportentries(int index) const;
3359 ::Hdfs::Internal::SnapshotDiffReportEntryProto* add_diffreportentries();
3360 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshotDiffReportEntryProto >&
3361 diffreportentries() const;
3362
3363 // required string snapshotRoot = 1;
3364 bool has_snapshotroot() const;
3365 void clear_snapshotroot();
3366 static const int kSnapshotRootFieldNumber = 1;
3367 const ::std::string& snapshotroot() const;
3368 void set_snapshotroot(const ::std::string& value);
3369 #if LANG_CXX11
3370 void set_snapshotroot(::std::string&& value);
3371 #endif
3372 void set_snapshotroot(const char* value);
3373 void set_snapshotroot(const char* value, size_t size);
3374 ::std::string* mutable_snapshotroot();
3375 ::std::string* release_snapshotroot();
3376 void set_allocated_snapshotroot(::std::string* snapshotroot);
3377
3378 // required string fromSnapshot = 2;
3379 bool has_fromsnapshot() const;
3380 void clear_fromsnapshot();
3381 static const int kFromSnapshotFieldNumber = 2;
3382 const ::std::string& fromsnapshot() const;
3383 void set_fromsnapshot(const ::std::string& value);
3384 #if LANG_CXX11
3385 void set_fromsnapshot(::std::string&& value);
3386 #endif
3387 void set_fromsnapshot(const char* value);
3388 void set_fromsnapshot(const char* value, size_t size);
3389 ::std::string* mutable_fromsnapshot();
3390 ::std::string* release_fromsnapshot();
3391 void set_allocated_fromsnapshot(::std::string* fromsnapshot);
3392
3393 // required string toSnapshot = 3;
3394 bool has_tosnapshot() const;
3395 void clear_tosnapshot();
3396 static const int kToSnapshotFieldNumber = 3;
3397 const ::std::string& tosnapshot() const;
3398 void set_tosnapshot(const ::std::string& value);
3399 #if LANG_CXX11
3400 void set_tosnapshot(::std::string&& value);
3401 #endif
3402 void set_tosnapshot(const char* value);
3403 void set_tosnapshot(const char* value, size_t size);
3404 ::std::string* mutable_tosnapshot();
3405 ::std::string* release_tosnapshot();
3406 void set_allocated_tosnapshot(::std::string* tosnapshot);
3407
3408 // @@protoc_insertion_point(class_scope:Hdfs.Internal.SnapshotDiffReportProto)
3409 private:
3410 void set_has_snapshotroot();
3411 void clear_has_snapshotroot();
3412 void set_has_fromsnapshot();
3413 void clear_has_fromsnapshot();
3414 void set_has_tosnapshot();
3415 void clear_has_tosnapshot();
3416
3417 // helper for ByteSizeLong()
3418 size_t RequiredFieldsByteSizeFallback() const;
3419
3420 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3421 ::google::protobuf::internal::HasBits<1> _has_bits_;
3422 mutable ::google::protobuf::internal::CachedSize _cached_size_;
3423 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshotDiffReportEntryProto > diffreportentries_;
3424 ::google::protobuf::internal::ArenaStringPtr snapshotroot_;
3425 ::google::protobuf::internal::ArenaStringPtr fromsnapshot_;
3426 ::google::protobuf::internal::ArenaStringPtr tosnapshot_;
3427 friend struct ::protobuf_hdfs_2eproto::TableStruct;
3428};
3429// -------------------------------------------------------------------
3430
3431class StorageInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.StorageInfoProto) */ {
3432 public:
3433 StorageInfoProto();
3434 virtual ~StorageInfoProto();
3435
3436 StorageInfoProto(const StorageInfoProto& from);
3437
3438 inline StorageInfoProto& operator=(const StorageInfoProto& from) {
3439 CopyFrom(from);
3440 return *this;
3441 }
3442 #if LANG_CXX11
3443 StorageInfoProto(StorageInfoProto&& from) noexcept
3444 : StorageInfoProto() {
3445 *this = ::std::move(from);
3446 }
3447
3448 inline StorageInfoProto& operator=(StorageInfoProto&& from) noexcept {
3449 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3450 if (this != &from) InternalSwap(&from);
3451 } else {
3452 CopyFrom(from);
3453 }
3454 return *this;
3455 }
3456 #endif
3457 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3458 return _internal_metadata_.unknown_fields();
3459 }
3460 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3461 return _internal_metadata_.mutable_unknown_fields();
3462 }
3463
3464 static const ::google::protobuf::Descriptor* descriptor();
3465 static const StorageInfoProto& default_instance();
3466
3467 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3468 static inline const StorageInfoProto* internal_default_instance() {
3469 return reinterpret_cast<const StorageInfoProto*>(
3470 &_StorageInfoProto_default_instance_);
3471 }
3472 static constexpr int kIndexInFileMessages =
3473 18;
3474
3475 void Swap(StorageInfoProto* other);
3476 friend void swap(StorageInfoProto& a, StorageInfoProto& b) {
3477 a.Swap(&b);
3478 }
3479
3480 // implements Message ----------------------------------------------
3481
3482 inline StorageInfoProto* New() const final {
3483 return CreateMaybeMessage<StorageInfoProto>(NULL);
3484 }
3485
3486 StorageInfoProto* New(::google::protobuf::Arena* arena) const final {
3487 return CreateMaybeMessage<StorageInfoProto>(arena);
3488 }
3489 void CopyFrom(const ::google::protobuf::Message& from) final;
3490 void MergeFrom(const ::google::protobuf::Message& from) final;
3491 void CopyFrom(const StorageInfoProto& from);
3492 void MergeFrom(const StorageInfoProto& from);
3493 void Clear() final;
3494 bool IsInitialized() const final;
3495
3496 size_t ByteSizeLong() const final;
3497 bool MergePartialFromCodedStream(
3498 ::google::protobuf::io::CodedInputStream* input) final;
3499 void SerializeWithCachedSizes(
3500 ::google::protobuf::io::CodedOutputStream* output) const final;
3501 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
3502 bool deterministic, ::google::protobuf::uint8* target) const final;
3503 int GetCachedSize() const final { return _cached_size_.Get(); }
3504
3505 private:
3506 void SharedCtor();
3507 void SharedDtor();
3508 void SetCachedSize(int size) const final;
3509 void InternalSwap(StorageInfoProto* other);
3510 private:
3511 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
3512 return NULL;
3513 }
3514 inline void* MaybeArenaPtr() const {
3515 return NULL;
3516 }
3517 public:
3518
3519 ::google::protobuf::Metadata GetMetadata() const final;
3520
3521 // nested types ----------------------------------------------------
3522
3523 // accessors -------------------------------------------------------
3524
3525 // required string clusterID = 3;
3526 bool has_clusterid() const;
3527 void clear_clusterid();
3528 static const int kClusterIDFieldNumber = 3;
3529 const ::std::string& clusterid() const;
3530 void set_clusterid(const ::std::string& value);
3531 #if LANG_CXX11
3532 void set_clusterid(::std::string&& value);
3533 #endif
3534 void set_clusterid(const char* value);
3535 void set_clusterid(const char* value, size_t size);
3536 ::std::string* mutable_clusterid();
3537 ::std::string* release_clusterid();
3538 void set_allocated_clusterid(::std::string* clusterid);
3539
3540 // required uint32 layoutVersion = 1;
3541 bool has_layoutversion() const;
3542 void clear_layoutversion();
3543 static const int kLayoutVersionFieldNumber = 1;
3544 ::google::protobuf::uint32 layoutversion() const;
3545 void set_layoutversion(::google::protobuf::uint32 value);
3546
3547 // required uint32 namespceID = 2;
3548 bool has_namespceid() const;
3549 void clear_namespceid();
3550 static const int kNamespceIDFieldNumber = 2;
3551 ::google::protobuf::uint32 namespceid() const;
3552 void set_namespceid(::google::protobuf::uint32 value);
3553
3554 // required uint64 cTime = 4;
3555 bool has_ctime() const;
3556 void clear_ctime();
3557 static const int kCTimeFieldNumber = 4;
3558 ::google::protobuf::uint64 ctime() const;
3559 void set_ctime(::google::protobuf::uint64 value);
3560
3561 // @@protoc_insertion_point(class_scope:Hdfs.Internal.StorageInfoProto)
3562 private:
3563 void set_has_layoutversion();
3564 void clear_has_layoutversion();
3565 void set_has_namespceid();
3566 void clear_has_namespceid();
3567 void set_has_clusterid();
3568 void clear_has_clusterid();
3569 void set_has_ctime();
3570 void clear_has_ctime();
3571
3572 // helper for ByteSizeLong()
3573 size_t RequiredFieldsByteSizeFallback() const;
3574
3575 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3576 ::google::protobuf::internal::HasBits<1> _has_bits_;
3577 mutable ::google::protobuf::internal::CachedSize _cached_size_;
3578 ::google::protobuf::internal::ArenaStringPtr clusterid_;
3579 ::google::protobuf::uint32 layoutversion_;
3580 ::google::protobuf::uint32 namespceid_;
3581 ::google::protobuf::uint64 ctime_;
3582 friend struct ::protobuf_hdfs_2eproto::TableStruct;
3583};
3584// -------------------------------------------------------------------
3585
3586class NamenodeRegistrationProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.NamenodeRegistrationProto) */ {
3587 public:
3588 NamenodeRegistrationProto();
3589 virtual ~NamenodeRegistrationProto();
3590
3591 NamenodeRegistrationProto(const NamenodeRegistrationProto& from);
3592
3593 inline NamenodeRegistrationProto& operator=(const NamenodeRegistrationProto& from) {
3594 CopyFrom(from);
3595 return *this;
3596 }
3597 #if LANG_CXX11
3598 NamenodeRegistrationProto(NamenodeRegistrationProto&& from) noexcept
3599 : NamenodeRegistrationProto() {
3600 *this = ::std::move(from);
3601 }
3602
3603 inline NamenodeRegistrationProto& operator=(NamenodeRegistrationProto&& from) noexcept {
3604 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3605 if (this != &from) InternalSwap(&from);
3606 } else {
3607 CopyFrom(from);
3608 }
3609 return *this;
3610 }
3611 #endif
3612 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3613 return _internal_metadata_.unknown_fields();
3614 }
3615 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3616 return _internal_metadata_.mutable_unknown_fields();
3617 }
3618
3619 static const ::google::protobuf::Descriptor* descriptor();
3620 static const NamenodeRegistrationProto& default_instance();
3621
3622 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3623 static inline const NamenodeRegistrationProto* internal_default_instance() {
3624 return reinterpret_cast<const NamenodeRegistrationProto*>(
3625 &_NamenodeRegistrationProto_default_instance_);
3626 }
3627 static constexpr int kIndexInFileMessages =
3628 19;
3629
3630 void Swap(NamenodeRegistrationProto* other);
3631 friend void swap(NamenodeRegistrationProto& a, NamenodeRegistrationProto& b) {
3632 a.Swap(&b);
3633 }
3634
3635 // implements Message ----------------------------------------------
3636
3637 inline NamenodeRegistrationProto* New() const final {
3638 return CreateMaybeMessage<NamenodeRegistrationProto>(NULL);
3639 }
3640
3641 NamenodeRegistrationProto* New(::google::protobuf::Arena* arena) const final {
3642 return CreateMaybeMessage<NamenodeRegistrationProto>(arena);
3643 }
3644 void CopyFrom(const ::google::protobuf::Message& from) final;
3645 void MergeFrom(const ::google::protobuf::Message& from) final;
3646 void CopyFrom(const NamenodeRegistrationProto& from);
3647 void MergeFrom(const NamenodeRegistrationProto& from);
3648 void Clear() final;
3649 bool IsInitialized() const final;
3650
3651 size_t ByteSizeLong() const final;
3652 bool MergePartialFromCodedStream(
3653 ::google::protobuf::io::CodedInputStream* input) final;
3654 void SerializeWithCachedSizes(
3655 ::google::protobuf::io::CodedOutputStream* output) const final;
3656 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
3657 bool deterministic, ::google::protobuf::uint8* target) const final;
3658 int GetCachedSize() const final { return _cached_size_.Get(); }
3659
3660 private:
3661 void SharedCtor();
3662 void SharedDtor();
3663 void SetCachedSize(int size) const final;
3664 void InternalSwap(NamenodeRegistrationProto* other);
3665 private:
3666 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
3667 return NULL;
3668 }
3669 inline void* MaybeArenaPtr() const {
3670 return NULL;
3671 }
3672 public:
3673
3674 ::google::protobuf::Metadata GetMetadata() const final;
3675
3676 // nested types ----------------------------------------------------
3677
3678 typedef NamenodeRegistrationProto_NamenodeRoleProto NamenodeRoleProto;
3679 static const NamenodeRoleProto NAMENODE =
3680 NamenodeRegistrationProto_NamenodeRoleProto_NAMENODE;
3681 static const NamenodeRoleProto BACKUP =
3682 NamenodeRegistrationProto_NamenodeRoleProto_BACKUP;
3683 static const NamenodeRoleProto CHECKPOINT =
3684 NamenodeRegistrationProto_NamenodeRoleProto_CHECKPOINT;
3685 static inline bool NamenodeRoleProto_IsValid(int value) {
3686 return NamenodeRegistrationProto_NamenodeRoleProto_IsValid(value);
3687 }
3688 static const NamenodeRoleProto NamenodeRoleProto_MIN =
3689 NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MIN;
3690 static const NamenodeRoleProto NamenodeRoleProto_MAX =
3691 NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_MAX;
3692 static const int NamenodeRoleProto_ARRAYSIZE =
3693 NamenodeRegistrationProto_NamenodeRoleProto_NamenodeRoleProto_ARRAYSIZE;
3694 static inline const ::google::protobuf::EnumDescriptor*
3695 NamenodeRoleProto_descriptor() {
3696 return NamenodeRegistrationProto_NamenodeRoleProto_descriptor();
3697 }
3698 static inline const ::std::string& NamenodeRoleProto_Name(NamenodeRoleProto value) {
3699 return NamenodeRegistrationProto_NamenodeRoleProto_Name(value);
3700 }
3701 static inline bool NamenodeRoleProto_Parse(const ::std::string& name,
3702 NamenodeRoleProto* value) {
3703 return NamenodeRegistrationProto_NamenodeRoleProto_Parse(name, value);
3704 }
3705
3706 // accessors -------------------------------------------------------
3707
3708 // required string rpcAddress = 1;
3709 bool has_rpcaddress() const;
3710 void clear_rpcaddress();
3711 static const int kRpcAddressFieldNumber = 1;
3712 const ::std::string& rpcaddress() const;
3713 void set_rpcaddress(const ::std::string& value);
3714 #if LANG_CXX11
3715 void set_rpcaddress(::std::string&& value);
3716 #endif
3717 void set_rpcaddress(const char* value);
3718 void set_rpcaddress(const char* value, size_t size);
3719 ::std::string* mutable_rpcaddress();
3720 ::std::string* release_rpcaddress();
3721 void set_allocated_rpcaddress(::std::string* rpcaddress);
3722
3723 // required string httpAddress = 2;
3724 bool has_httpaddress() const;
3725 void clear_httpaddress();
3726 static const int kHttpAddressFieldNumber = 2;
3727 const ::std::string& httpaddress() const;
3728 void set_httpaddress(const ::std::string& value);
3729 #if LANG_CXX11
3730 void set_httpaddress(::std::string&& value);
3731 #endif
3732 void set_httpaddress(const char* value);
3733 void set_httpaddress(const char* value, size_t size);
3734 ::std::string* mutable_httpaddress();
3735 ::std::string* release_httpaddress();
3736 void set_allocated_httpaddress(::std::string* httpaddress);
3737
3738 // required .Hdfs.Internal.StorageInfoProto storageInfo = 3;
3739 bool has_storageinfo() const;
3740 void clear_storageinfo();
3741 static const int kStorageInfoFieldNumber = 3;
3742 private:
3743 const ::Hdfs::Internal::StorageInfoProto& _internal_storageinfo() const;
3744 public:
3745 const ::Hdfs::Internal::StorageInfoProto& storageinfo() const;
3746 ::Hdfs::Internal::StorageInfoProto* release_storageinfo();
3747 ::Hdfs::Internal::StorageInfoProto* mutable_storageinfo();
3748 void set_allocated_storageinfo(::Hdfs::Internal::StorageInfoProto* storageinfo);
3749
3750 // optional .Hdfs.Internal.NamenodeRegistrationProto.NamenodeRoleProto role = 4 [default = NAMENODE];
3751 bool has_role() const;
3752 void clear_role();
3753 static const int kRoleFieldNumber = 4;
3754 ::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto role() const;
3755 void set_role(::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto value);
3756
3757 // @@protoc_insertion_point(class_scope:Hdfs.Internal.NamenodeRegistrationProto)
3758 private:
3759 void set_has_rpcaddress();
3760 void clear_has_rpcaddress();
3761 void set_has_httpaddress();
3762 void clear_has_httpaddress();
3763 void set_has_storageinfo();
3764 void clear_has_storageinfo();
3765 void set_has_role();
3766 void clear_has_role();
3767
3768 // helper for ByteSizeLong()
3769 size_t RequiredFieldsByteSizeFallback() const;
3770
3771 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3772 ::google::protobuf::internal::HasBits<1> _has_bits_;
3773 mutable ::google::protobuf::internal::CachedSize _cached_size_;
3774 ::google::protobuf::internal::ArenaStringPtr rpcaddress_;
3775 ::google::protobuf::internal::ArenaStringPtr httpaddress_;
3776 ::Hdfs::Internal::StorageInfoProto* storageinfo_;
3777 int role_;
3778 friend struct ::protobuf_hdfs_2eproto::TableStruct;
3779};
3780// -------------------------------------------------------------------
3781
3782class CheckpointSignatureProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.CheckpointSignatureProto) */ {
3783 public:
3784 CheckpointSignatureProto();
3785 virtual ~CheckpointSignatureProto();
3786
3787 CheckpointSignatureProto(const CheckpointSignatureProto& from);
3788
3789 inline CheckpointSignatureProto& operator=(const CheckpointSignatureProto& from) {
3790 CopyFrom(from);
3791 return *this;
3792 }
3793 #if LANG_CXX11
3794 CheckpointSignatureProto(CheckpointSignatureProto&& from) noexcept
3795 : CheckpointSignatureProto() {
3796 *this = ::std::move(from);
3797 }
3798
3799 inline CheckpointSignatureProto& operator=(CheckpointSignatureProto&& from) noexcept {
3800 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3801 if (this != &from) InternalSwap(&from);
3802 } else {
3803 CopyFrom(from);
3804 }
3805 return *this;
3806 }
3807 #endif
3808 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3809 return _internal_metadata_.unknown_fields();
3810 }
3811 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3812 return _internal_metadata_.mutable_unknown_fields();
3813 }
3814
3815 static const ::google::protobuf::Descriptor* descriptor();
3816 static const CheckpointSignatureProto& default_instance();
3817
3818 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3819 static inline const CheckpointSignatureProto* internal_default_instance() {
3820 return reinterpret_cast<const CheckpointSignatureProto*>(
3821 &_CheckpointSignatureProto_default_instance_);
3822 }
3823 static constexpr int kIndexInFileMessages =
3824 20;
3825
3826 void Swap(CheckpointSignatureProto* other);
3827 friend void swap(CheckpointSignatureProto& a, CheckpointSignatureProto& b) {
3828 a.Swap(&b);
3829 }
3830
3831 // implements Message ----------------------------------------------
3832
3833 inline CheckpointSignatureProto* New() const final {
3834 return CreateMaybeMessage<CheckpointSignatureProto>(NULL);
3835 }
3836
3837 CheckpointSignatureProto* New(::google::protobuf::Arena* arena) const final {
3838 return CreateMaybeMessage<CheckpointSignatureProto>(arena);
3839 }
3840 void CopyFrom(const ::google::protobuf::Message& from) final;
3841 void MergeFrom(const ::google::protobuf::Message& from) final;
3842 void CopyFrom(const CheckpointSignatureProto& from);
3843 void MergeFrom(const CheckpointSignatureProto& from);
3844 void Clear() final;
3845 bool IsInitialized() const final;
3846
3847 size_t ByteSizeLong() const final;
3848 bool MergePartialFromCodedStream(
3849 ::google::protobuf::io::CodedInputStream* input) final;
3850 void SerializeWithCachedSizes(
3851 ::google::protobuf::io::CodedOutputStream* output) const final;
3852 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
3853 bool deterministic, ::google::protobuf::uint8* target) const final;
3854 int GetCachedSize() const final { return _cached_size_.Get(); }
3855
3856 private:
3857 void SharedCtor();
3858 void SharedDtor();
3859 void SetCachedSize(int size) const final;
3860 void InternalSwap(CheckpointSignatureProto* other);
3861 private:
3862 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
3863 return NULL;
3864 }
3865 inline void* MaybeArenaPtr() const {
3866 return NULL;
3867 }
3868 public:
3869
3870 ::google::protobuf::Metadata GetMetadata() const final;
3871
3872 // nested types ----------------------------------------------------
3873
3874 // accessors -------------------------------------------------------
3875
3876 // required string blockPoolId = 1;
3877 bool has_blockpoolid() const;
3878 void clear_blockpoolid();
3879 static const int kBlockPoolIdFieldNumber = 1;
3880 const ::std::string& blockpoolid() const;
3881 void set_blockpoolid(const ::std::string& value);
3882 #if LANG_CXX11
3883 void set_blockpoolid(::std::string&& value);
3884 #endif
3885 void set_blockpoolid(const char* value);
3886 void set_blockpoolid(const char* value, size_t size);
3887 ::std::string* mutable_blockpoolid();
3888 ::std::string* release_blockpoolid();
3889 void set_allocated_blockpoolid(::std::string* blockpoolid);
3890
3891 // required .Hdfs.Internal.StorageInfoProto storageInfo = 4;
3892 bool has_storageinfo() const;
3893 void clear_storageinfo();
3894 static const int kStorageInfoFieldNumber = 4;
3895 private:
3896 const ::Hdfs::Internal::StorageInfoProto& _internal_storageinfo() const;
3897 public:
3898 const ::Hdfs::Internal::StorageInfoProto& storageinfo() const;
3899 ::Hdfs::Internal::StorageInfoProto* release_storageinfo();
3900 ::Hdfs::Internal::StorageInfoProto* mutable_storageinfo();
3901 void set_allocated_storageinfo(::Hdfs::Internal::StorageInfoProto* storageinfo);
3902
3903 // required uint64 mostRecentCheckpointTxId = 2;
3904 bool has_mostrecentcheckpointtxid() const;
3905 void clear_mostrecentcheckpointtxid();
3906 static const int kMostRecentCheckpointTxIdFieldNumber = 2;
3907 ::google::protobuf::uint64 mostrecentcheckpointtxid() const;
3908 void set_mostrecentcheckpointtxid(::google::protobuf::uint64 value);
3909
3910 // required uint64 curSegmentTxId = 3;
3911 bool has_cursegmenttxid() const;
3912 void clear_cursegmenttxid();
3913 static const int kCurSegmentTxIdFieldNumber = 3;
3914 ::google::protobuf::uint64 cursegmenttxid() const;
3915 void set_cursegmenttxid(::google::protobuf::uint64 value);
3916
3917 // @@protoc_insertion_point(class_scope:Hdfs.Internal.CheckpointSignatureProto)
3918 private:
3919 void set_has_blockpoolid();
3920 void clear_has_blockpoolid();
3921 void set_has_mostrecentcheckpointtxid();
3922 void clear_has_mostrecentcheckpointtxid();
3923 void set_has_cursegmenttxid();
3924 void clear_has_cursegmenttxid();
3925 void set_has_storageinfo();
3926 void clear_has_storageinfo();
3927
3928 // helper for ByteSizeLong()
3929 size_t RequiredFieldsByteSizeFallback() const;
3930
3931 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3932 ::google::protobuf::internal::HasBits<1> _has_bits_;
3933 mutable ::google::protobuf::internal::CachedSize _cached_size_;
3934 ::google::protobuf::internal::ArenaStringPtr blockpoolid_;
3935 ::Hdfs::Internal::StorageInfoProto* storageinfo_;
3936 ::google::protobuf::uint64 mostrecentcheckpointtxid_;
3937 ::google::protobuf::uint64 cursegmenttxid_;
3938 friend struct ::protobuf_hdfs_2eproto::TableStruct;
3939};
3940// -------------------------------------------------------------------
3941
3942class NamenodeCommandProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.NamenodeCommandProto) */ {
3943 public:
3944 NamenodeCommandProto();
3945 virtual ~NamenodeCommandProto();
3946
3947 NamenodeCommandProto(const NamenodeCommandProto& from);
3948
3949 inline NamenodeCommandProto& operator=(const NamenodeCommandProto& from) {
3950 CopyFrom(from);
3951 return *this;
3952 }
3953 #if LANG_CXX11
3954 NamenodeCommandProto(NamenodeCommandProto&& from) noexcept
3955 : NamenodeCommandProto() {
3956 *this = ::std::move(from);
3957 }
3958
3959 inline NamenodeCommandProto& operator=(NamenodeCommandProto&& from) noexcept {
3960 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3961 if (this != &from) InternalSwap(&from);
3962 } else {
3963 CopyFrom(from);
3964 }
3965 return *this;
3966 }
3967 #endif
3968 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3969 return _internal_metadata_.unknown_fields();
3970 }
3971 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3972 return _internal_metadata_.mutable_unknown_fields();
3973 }
3974
3975 static const ::google::protobuf::Descriptor* descriptor();
3976 static const NamenodeCommandProto& default_instance();
3977
3978 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3979 static inline const NamenodeCommandProto* internal_default_instance() {
3980 return reinterpret_cast<const NamenodeCommandProto*>(
3981 &_NamenodeCommandProto_default_instance_);
3982 }
3983 static constexpr int kIndexInFileMessages =
3984 21;
3985
3986 void Swap(NamenodeCommandProto* other);
3987 friend void swap(NamenodeCommandProto& a, NamenodeCommandProto& b) {
3988 a.Swap(&b);
3989 }
3990
3991 // implements Message ----------------------------------------------
3992
3993 inline NamenodeCommandProto* New() const final {
3994 return CreateMaybeMessage<NamenodeCommandProto>(NULL);
3995 }
3996
3997 NamenodeCommandProto* New(::google::protobuf::Arena* arena) const final {
3998 return CreateMaybeMessage<NamenodeCommandProto>(arena);
3999 }
4000 void CopyFrom(const ::google::protobuf::Message& from) final;
4001 void MergeFrom(const ::google::protobuf::Message& from) final;
4002 void CopyFrom(const NamenodeCommandProto& from);
4003 void MergeFrom(const NamenodeCommandProto& from);
4004 void Clear() final;
4005 bool IsInitialized() const final;
4006
4007 size_t ByteSizeLong() const final;
4008 bool MergePartialFromCodedStream(
4009 ::google::protobuf::io::CodedInputStream* input) final;
4010 void SerializeWithCachedSizes(
4011 ::google::protobuf::io::CodedOutputStream* output) const final;
4012 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
4013 bool deterministic, ::google::protobuf::uint8* target) const final;
4014 int GetCachedSize() const final { return _cached_size_.Get(); }
4015
4016 private:
4017 void SharedCtor();
4018 void SharedDtor();
4019 void SetCachedSize(int size) const final;
4020 void InternalSwap(NamenodeCommandProto* other);
4021 private:
4022 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
4023 return NULL;
4024 }
4025 inline void* MaybeArenaPtr() const {
4026 return NULL;
4027 }
4028 public:
4029
4030 ::google::protobuf::Metadata GetMetadata() const final;
4031
4032 // nested types ----------------------------------------------------
4033
4034 typedef NamenodeCommandProto_Type Type;
4035 static const Type NamenodeCommand =
4036 NamenodeCommandProto_Type_NamenodeCommand;
4037 static const Type CheckPointCommand =
4038 NamenodeCommandProto_Type_CheckPointCommand;
4039 static inline bool Type_IsValid(int value) {
4040 return NamenodeCommandProto_Type_IsValid(value);
4041 }
4042 static const Type Type_MIN =
4043 NamenodeCommandProto_Type_Type_MIN;
4044 static const Type Type_MAX =
4045 NamenodeCommandProto_Type_Type_MAX;
4046 static const int Type_ARRAYSIZE =
4047 NamenodeCommandProto_Type_Type_ARRAYSIZE;
4048 static inline const ::google::protobuf::EnumDescriptor*
4049 Type_descriptor() {
4050 return NamenodeCommandProto_Type_descriptor();
4051 }
4052 static inline const ::std::string& Type_Name(Type value) {
4053 return NamenodeCommandProto_Type_Name(value);
4054 }
4055 static inline bool Type_Parse(const ::std::string& name,
4056 Type* value) {
4057 return NamenodeCommandProto_Type_Parse(name, value);
4058 }
4059
4060 // accessors -------------------------------------------------------
4061
4062 // optional .Hdfs.Internal.CheckpointCommandProto checkpointCmd = 3;
4063 bool has_checkpointcmd() const;
4064 void clear_checkpointcmd();
4065 static const int kCheckpointCmdFieldNumber = 3;
4066 private:
4067 const ::Hdfs::Internal::CheckpointCommandProto& _internal_checkpointcmd() const;
4068 public:
4069 const ::Hdfs::Internal::CheckpointCommandProto& checkpointcmd() const;
4070 ::Hdfs::Internal::CheckpointCommandProto* release_checkpointcmd();
4071 ::Hdfs::Internal::CheckpointCommandProto* mutable_checkpointcmd();
4072 void set_allocated_checkpointcmd(::Hdfs::Internal::CheckpointCommandProto* checkpointcmd);
4073
4074 // required uint32 action = 1;
4075 bool has_action() const;
4076 void clear_action();
4077 static const int kActionFieldNumber = 1;
4078 ::google::protobuf::uint32 action() const;
4079 void set_action(::google::protobuf::uint32 value);
4080
4081 // required .Hdfs.Internal.NamenodeCommandProto.Type type = 2;
4082 bool has_type() const;
4083 void clear_type();
4084 static const int kTypeFieldNumber = 2;
4085 ::Hdfs::Internal::NamenodeCommandProto_Type type() const;
4086 void set_type(::Hdfs::Internal::NamenodeCommandProto_Type value);
4087
4088 // @@protoc_insertion_point(class_scope:Hdfs.Internal.NamenodeCommandProto)
4089 private:
4090 void set_has_action();
4091 void clear_has_action();
4092 void set_has_type();
4093 void clear_has_type();
4094 void set_has_checkpointcmd();
4095 void clear_has_checkpointcmd();
4096
4097 // helper for ByteSizeLong()
4098 size_t RequiredFieldsByteSizeFallback() const;
4099
4100 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
4101 ::google::protobuf::internal::HasBits<1> _has_bits_;
4102 mutable ::google::protobuf::internal::CachedSize _cached_size_;
4103 ::Hdfs::Internal::CheckpointCommandProto* checkpointcmd_;
4104 ::google::protobuf::uint32 action_;
4105 int type_;
4106 friend struct ::protobuf_hdfs_2eproto::TableStruct;
4107};
4108// -------------------------------------------------------------------
4109
4110class CheckpointCommandProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.CheckpointCommandProto) */ {
4111 public:
4112 CheckpointCommandProto();
4113 virtual ~CheckpointCommandProto();
4114
4115 CheckpointCommandProto(const CheckpointCommandProto& from);
4116
4117 inline CheckpointCommandProto& operator=(const CheckpointCommandProto& from) {
4118 CopyFrom(from);
4119 return *this;
4120 }
4121 #if LANG_CXX11
4122 CheckpointCommandProto(CheckpointCommandProto&& from) noexcept
4123 : CheckpointCommandProto() {
4124 *this = ::std::move(from);
4125 }
4126
4127 inline CheckpointCommandProto& operator=(CheckpointCommandProto&& from) noexcept {
4128 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4129 if (this != &from) InternalSwap(&from);
4130 } else {
4131 CopyFrom(from);
4132 }
4133 return *this;
4134 }
4135 #endif
4136 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
4137 return _internal_metadata_.unknown_fields();
4138 }
4139 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
4140 return _internal_metadata_.mutable_unknown_fields();
4141 }
4142
4143 static const ::google::protobuf::Descriptor* descriptor();
4144 static const CheckpointCommandProto& default_instance();
4145
4146 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4147 static inline const CheckpointCommandProto* internal_default_instance() {
4148 return reinterpret_cast<const CheckpointCommandProto*>(
4149 &_CheckpointCommandProto_default_instance_);
4150 }
4151 static constexpr int kIndexInFileMessages =
4152 22;
4153
4154 void Swap(CheckpointCommandProto* other);
4155 friend void swap(CheckpointCommandProto& a, CheckpointCommandProto& b) {
4156 a.Swap(&b);
4157 }
4158
4159 // implements Message ----------------------------------------------
4160
4161 inline CheckpointCommandProto* New() const final {
4162 return CreateMaybeMessage<CheckpointCommandProto>(NULL);
4163 }
4164
4165 CheckpointCommandProto* New(::google::protobuf::Arena* arena) const final {
4166 return CreateMaybeMessage<CheckpointCommandProto>(arena);
4167 }
4168 void CopyFrom(const ::google::protobuf::Message& from) final;
4169 void MergeFrom(const ::google::protobuf::Message& from) final;
4170 void CopyFrom(const CheckpointCommandProto& from);
4171 void MergeFrom(const CheckpointCommandProto& from);
4172 void Clear() final;
4173 bool IsInitialized() const final;
4174
4175 size_t ByteSizeLong() const final;
4176 bool MergePartialFromCodedStream(
4177 ::google::protobuf::io::CodedInputStream* input) final;
4178 void SerializeWithCachedSizes(
4179 ::google::protobuf::io::CodedOutputStream* output) const final;
4180 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
4181 bool deterministic, ::google::protobuf::uint8* target) const final;
4182 int GetCachedSize() const final { return _cached_size_.Get(); }
4183
4184 private:
4185 void SharedCtor();
4186 void SharedDtor();
4187 void SetCachedSize(int size) const final;
4188 void InternalSwap(CheckpointCommandProto* other);
4189 private:
4190 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
4191 return NULL;
4192 }
4193 inline void* MaybeArenaPtr() const {
4194 return NULL;
4195 }
4196 public:
4197
4198 ::google::protobuf::Metadata GetMetadata() const final;
4199
4200 // nested types ----------------------------------------------------
4201
4202 // accessors -------------------------------------------------------
4203
4204 // required .Hdfs.Internal.CheckpointSignatureProto signature = 1;
4205 bool has_signature() const;
4206 void clear_signature();
4207 static const int kSignatureFieldNumber = 1;
4208 private:
4209 const ::Hdfs::Internal::CheckpointSignatureProto& _internal_signature() const;
4210 public:
4211 const ::Hdfs::Internal::CheckpointSignatureProto& signature() const;
4212 ::Hdfs::Internal::CheckpointSignatureProto* release_signature();
4213 ::Hdfs::Internal::CheckpointSignatureProto* mutable_signature();
4214 void set_allocated_signature(::Hdfs::Internal::CheckpointSignatureProto* signature);
4215
4216 // required bool needToReturnImage = 2;
4217 bool has_needtoreturnimage() const;
4218 void clear_needtoreturnimage();
4219 static const int kNeedToReturnImageFieldNumber = 2;
4220 bool needtoreturnimage() const;
4221 void set_needtoreturnimage(bool value);
4222
4223 // @@protoc_insertion_point(class_scope:Hdfs.Internal.CheckpointCommandProto)
4224 private:
4225 void set_has_signature();
4226 void clear_has_signature();
4227 void set_has_needtoreturnimage();
4228 void clear_has_needtoreturnimage();
4229
4230 // helper for ByteSizeLong()
4231 size_t RequiredFieldsByteSizeFallback() const;
4232
4233 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
4234 ::google::protobuf::internal::HasBits<1> _has_bits_;
4235 mutable ::google::protobuf::internal::CachedSize _cached_size_;
4236 ::Hdfs::Internal::CheckpointSignatureProto* signature_;
4237 bool needtoreturnimage_;
4238 friend struct ::protobuf_hdfs_2eproto::TableStruct;
4239};
4240// -------------------------------------------------------------------
4241
4242class BlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.BlockProto) */ {
4243 public:
4244 BlockProto();
4245 virtual ~BlockProto();
4246
4247 BlockProto(const BlockProto& from);
4248
4249 inline BlockProto& operator=(const BlockProto& from) {
4250 CopyFrom(from);
4251 return *this;
4252 }
4253 #if LANG_CXX11
4254 BlockProto(BlockProto&& from) noexcept
4255 : BlockProto() {
4256 *this = ::std::move(from);
4257 }
4258
4259 inline BlockProto& operator=(BlockProto&& from) noexcept {
4260 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4261 if (this != &from) InternalSwap(&from);
4262 } else {
4263 CopyFrom(from);
4264 }
4265 return *this;
4266 }
4267 #endif
4268 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
4269 return _internal_metadata_.unknown_fields();
4270 }
4271 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
4272 return _internal_metadata_.mutable_unknown_fields();
4273 }
4274
4275 static const ::google::protobuf::Descriptor* descriptor();
4276 static const BlockProto& default_instance();
4277
4278 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4279 static inline const BlockProto* internal_default_instance() {
4280 return reinterpret_cast<const BlockProto*>(
4281 &_BlockProto_default_instance_);
4282 }
4283 static constexpr int kIndexInFileMessages =
4284 23;
4285
4286 void Swap(BlockProto* other);
4287 friend void swap(BlockProto& a, BlockProto& b) {
4288 a.Swap(&b);
4289 }
4290
4291 // implements Message ----------------------------------------------
4292
4293 inline BlockProto* New() const final {
4294 return CreateMaybeMessage<BlockProto>(NULL);
4295 }
4296
4297 BlockProto* New(::google::protobuf::Arena* arena) const final {
4298 return CreateMaybeMessage<BlockProto>(arena);
4299 }
4300 void CopyFrom(const ::google::protobuf::Message& from) final;
4301 void MergeFrom(const ::google::protobuf::Message& from) final;
4302 void CopyFrom(const BlockProto& from);
4303 void MergeFrom(const BlockProto& from);
4304 void Clear() final;
4305 bool IsInitialized() const final;
4306
4307 size_t ByteSizeLong() const final;
4308 bool MergePartialFromCodedStream(
4309 ::google::protobuf::io::CodedInputStream* input) final;
4310 void SerializeWithCachedSizes(
4311 ::google::protobuf::io::CodedOutputStream* output) const final;
4312 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
4313 bool deterministic, ::google::protobuf::uint8* target) const final;
4314 int GetCachedSize() const final { return _cached_size_.Get(); }
4315
4316 private:
4317 void SharedCtor();
4318 void SharedDtor();
4319 void SetCachedSize(int size) const final;
4320 void InternalSwap(BlockProto* other);
4321 private:
4322 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
4323 return NULL;
4324 }
4325 inline void* MaybeArenaPtr() const {
4326 return NULL;
4327 }
4328 public:
4329
4330 ::google::protobuf::Metadata GetMetadata() const final;
4331
4332 // nested types ----------------------------------------------------
4333
4334 // accessors -------------------------------------------------------
4335
4336 // required uint64 blockId = 1;
4337 bool has_blockid() const;
4338 void clear_blockid();
4339 static const int kBlockIdFieldNumber = 1;
4340 ::google::protobuf::uint64 blockid() const;
4341 void set_blockid(::google::protobuf::uint64 value);
4342
4343 // required uint64 genStamp = 2;
4344 bool has_genstamp() const;
4345 void clear_genstamp();
4346 static const int kGenStampFieldNumber = 2;
4347 ::google::protobuf::uint64 genstamp() const;
4348 void set_genstamp(::google::protobuf::uint64 value);
4349
4350 // optional uint64 numBytes = 3 [default = 0];
4351 bool has_numbytes() const;
4352 void clear_numbytes();
4353 static const int kNumBytesFieldNumber = 3;
4354 ::google::protobuf::uint64 numbytes() const;
4355 void set_numbytes(::google::protobuf::uint64 value);
4356
4357 // @@protoc_insertion_point(class_scope:Hdfs.Internal.BlockProto)
4358 private:
4359 void set_has_blockid();
4360 void clear_has_blockid();
4361 void set_has_genstamp();
4362 void clear_has_genstamp();
4363 void set_has_numbytes();
4364 void clear_has_numbytes();
4365
4366 // helper for ByteSizeLong()
4367 size_t RequiredFieldsByteSizeFallback() const;
4368
4369 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
4370 ::google::protobuf::internal::HasBits<1> _has_bits_;
4371 mutable ::google::protobuf::internal::CachedSize _cached_size_;
4372 ::google::protobuf::uint64 blockid_;
4373 ::google::protobuf::uint64 genstamp_;
4374 ::google::protobuf::uint64 numbytes_;
4375 friend struct ::protobuf_hdfs_2eproto::TableStruct;
4376};
4377// -------------------------------------------------------------------
4378
4379class BlockWithLocationsProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.BlockWithLocationsProto) */ {
4380 public:
4381 BlockWithLocationsProto();
4382 virtual ~BlockWithLocationsProto();
4383
4384 BlockWithLocationsProto(const BlockWithLocationsProto& from);
4385
4386 inline BlockWithLocationsProto& operator=(const BlockWithLocationsProto& from) {
4387 CopyFrom(from);
4388 return *this;
4389 }
4390 #if LANG_CXX11
4391 BlockWithLocationsProto(BlockWithLocationsProto&& from) noexcept
4392 : BlockWithLocationsProto() {
4393 *this = ::std::move(from);
4394 }
4395
4396 inline BlockWithLocationsProto& operator=(BlockWithLocationsProto&& from) noexcept {
4397 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4398 if (this != &from) InternalSwap(&from);
4399 } else {
4400 CopyFrom(from);
4401 }
4402 return *this;
4403 }
4404 #endif
4405 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
4406 return _internal_metadata_.unknown_fields();
4407 }
4408 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
4409 return _internal_metadata_.mutable_unknown_fields();
4410 }
4411
4412 static const ::google::protobuf::Descriptor* descriptor();
4413 static const BlockWithLocationsProto& default_instance();
4414
4415 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4416 static inline const BlockWithLocationsProto* internal_default_instance() {
4417 return reinterpret_cast<const BlockWithLocationsProto*>(
4418 &_BlockWithLocationsProto_default_instance_);
4419 }
4420 static constexpr int kIndexInFileMessages =
4421 24;
4422
4423 void Swap(BlockWithLocationsProto* other);
4424 friend void swap(BlockWithLocationsProto& a, BlockWithLocationsProto& b) {
4425 a.Swap(&b);
4426 }
4427
4428 // implements Message ----------------------------------------------
4429
4430 inline BlockWithLocationsProto* New() const final {
4431 return CreateMaybeMessage<BlockWithLocationsProto>(NULL);
4432 }
4433
4434 BlockWithLocationsProto* New(::google::protobuf::Arena* arena) const final {
4435 return CreateMaybeMessage<BlockWithLocationsProto>(arena);
4436 }
4437 void CopyFrom(const ::google::protobuf::Message& from) final;
4438 void MergeFrom(const ::google::protobuf::Message& from) final;
4439 void CopyFrom(const BlockWithLocationsProto& from);
4440 void MergeFrom(const BlockWithLocationsProto& from);
4441 void Clear() final;
4442 bool IsInitialized() const final;
4443
4444 size_t ByteSizeLong() const final;
4445 bool MergePartialFromCodedStream(
4446 ::google::protobuf::io::CodedInputStream* input) final;
4447 void SerializeWithCachedSizes(
4448 ::google::protobuf::io::CodedOutputStream* output) const final;
4449 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
4450 bool deterministic, ::google::protobuf::uint8* target) const final;
4451 int GetCachedSize() const final { return _cached_size_.Get(); }
4452
4453 private:
4454 void SharedCtor();
4455 void SharedDtor();
4456 void SetCachedSize(int size) const final;
4457 void InternalSwap(BlockWithLocationsProto* other);
4458 private:
4459 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
4460 return NULL;
4461 }
4462 inline void* MaybeArenaPtr() const {
4463 return NULL;
4464 }
4465 public:
4466
4467 ::google::protobuf::Metadata GetMetadata() const final;
4468
4469 // nested types ----------------------------------------------------
4470
4471 // accessors -------------------------------------------------------
4472
4473 // repeated string datanodeUuids = 2;
4474 int datanodeuuids_size() const;
4475 void clear_datanodeuuids();
4476 static const int kDatanodeUuidsFieldNumber = 2;
4477 const ::std::string& datanodeuuids(int index) const;
4478 ::std::string* mutable_datanodeuuids(int index);
4479 void set_datanodeuuids(int index, const ::std::string& value);
4480 #if LANG_CXX11
4481 void set_datanodeuuids(int index, ::std::string&& value);
4482 #endif
4483 void set_datanodeuuids(int index, const char* value);
4484 void set_datanodeuuids(int index, const char* value, size_t size);
4485 ::std::string* add_datanodeuuids();
4486 void add_datanodeuuids(const ::std::string& value);
4487 #if LANG_CXX11
4488 void add_datanodeuuids(::std::string&& value);
4489 #endif
4490 void add_datanodeuuids(const char* value);
4491 void add_datanodeuuids(const char* value, size_t size);
4492 const ::google::protobuf::RepeatedPtrField< ::std::string>& datanodeuuids() const;
4493 ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_datanodeuuids();
4494
4495 // repeated string storageUuids = 3;
4496 int storageuuids_size() const;
4497 void clear_storageuuids();
4498 static const int kStorageUuidsFieldNumber = 3;
4499 const ::std::string& storageuuids(int index) const;
4500 ::std::string* mutable_storageuuids(int index);
4501 void set_storageuuids(int index, const ::std::string& value);
4502 #if LANG_CXX11
4503 void set_storageuuids(int index, ::std::string&& value);
4504 #endif
4505 void set_storageuuids(int index, const char* value);
4506 void set_storageuuids(int index, const char* value, size_t size);
4507 ::std::string* add_storageuuids();
4508 void add_storageuuids(const ::std::string& value);
4509 #if LANG_CXX11
4510 void add_storageuuids(::std::string&& value);
4511 #endif
4512 void add_storageuuids(const char* value);
4513 void add_storageuuids(const char* value, size_t size);
4514 const ::google::protobuf::RepeatedPtrField< ::std::string>& storageuuids() const;
4515 ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_storageuuids();
4516
4517 // required .Hdfs.Internal.BlockProto block = 1;
4518 bool has_block() const;
4519 void clear_block();
4520 static const int kBlockFieldNumber = 1;
4521 private:
4522 const ::Hdfs::Internal::BlockProto& _internal_block() const;
4523 public:
4524 const ::Hdfs::Internal::BlockProto& block() const;
4525 ::Hdfs::Internal::BlockProto* release_block();
4526 ::Hdfs::Internal::BlockProto* mutable_block();
4527 void set_allocated_block(::Hdfs::Internal::BlockProto* block);
4528
4529 // @@protoc_insertion_point(class_scope:Hdfs.Internal.BlockWithLocationsProto)
4530 private:
4531 void set_has_block();
4532 void clear_has_block();
4533
4534 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
4535 ::google::protobuf::internal::HasBits<1> _has_bits_;
4536 mutable ::google::protobuf::internal::CachedSize _cached_size_;
4537 ::google::protobuf::RepeatedPtrField< ::std::string> datanodeuuids_;
4538 ::google::protobuf::RepeatedPtrField< ::std::string> storageuuids_;
4539 ::Hdfs::Internal::BlockProto* block_;
4540 friend struct ::protobuf_hdfs_2eproto::TableStruct;
4541};
4542// -------------------------------------------------------------------
4543
4544class BlocksWithLocationsProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.BlocksWithLocationsProto) */ {
4545 public:
4546 BlocksWithLocationsProto();
4547 virtual ~BlocksWithLocationsProto();
4548
4549 BlocksWithLocationsProto(const BlocksWithLocationsProto& from);
4550
4551 inline BlocksWithLocationsProto& operator=(const BlocksWithLocationsProto& from) {
4552 CopyFrom(from);
4553 return *this;
4554 }
4555 #if LANG_CXX11
4556 BlocksWithLocationsProto(BlocksWithLocationsProto&& from) noexcept
4557 : BlocksWithLocationsProto() {
4558 *this = ::std::move(from);
4559 }
4560
4561 inline BlocksWithLocationsProto& operator=(BlocksWithLocationsProto&& from) noexcept {
4562 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4563 if (this != &from) InternalSwap(&from);
4564 } else {
4565 CopyFrom(from);
4566 }
4567 return *this;
4568 }
4569 #endif
4570 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
4571 return _internal_metadata_.unknown_fields();
4572 }
4573 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
4574 return _internal_metadata_.mutable_unknown_fields();
4575 }
4576
4577 static const ::google::protobuf::Descriptor* descriptor();
4578 static const BlocksWithLocationsProto& default_instance();
4579
4580 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4581 static inline const BlocksWithLocationsProto* internal_default_instance() {
4582 return reinterpret_cast<const BlocksWithLocationsProto*>(
4583 &_BlocksWithLocationsProto_default_instance_);
4584 }
4585 static constexpr int kIndexInFileMessages =
4586 25;
4587
4588 void Swap(BlocksWithLocationsProto* other);
4589 friend void swap(BlocksWithLocationsProto& a, BlocksWithLocationsProto& b) {
4590 a.Swap(&b);
4591 }
4592
4593 // implements Message ----------------------------------------------
4594
4595 inline BlocksWithLocationsProto* New() const final {
4596 return CreateMaybeMessage<BlocksWithLocationsProto>(NULL);
4597 }
4598
4599 BlocksWithLocationsProto* New(::google::protobuf::Arena* arena) const final {
4600 return CreateMaybeMessage<BlocksWithLocationsProto>(arena);
4601 }
4602 void CopyFrom(const ::google::protobuf::Message& from) final;
4603 void MergeFrom(const ::google::protobuf::Message& from) final;
4604 void CopyFrom(const BlocksWithLocationsProto& from);
4605 void MergeFrom(const BlocksWithLocationsProto& from);
4606 void Clear() final;
4607 bool IsInitialized() const final;
4608
4609 size_t ByteSizeLong() const final;
4610 bool MergePartialFromCodedStream(
4611 ::google::protobuf::io::CodedInputStream* input) final;
4612 void SerializeWithCachedSizes(
4613 ::google::protobuf::io::CodedOutputStream* output) const final;
4614 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
4615 bool deterministic, ::google::protobuf::uint8* target) const final;
4616 int GetCachedSize() const final { return _cached_size_.Get(); }
4617
4618 private:
4619 void SharedCtor();
4620 void SharedDtor();
4621 void SetCachedSize(int size) const final;
4622 void InternalSwap(BlocksWithLocationsProto* other);
4623 private:
4624 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
4625 return NULL;
4626 }
4627 inline void* MaybeArenaPtr() const {
4628 return NULL;
4629 }
4630 public:
4631
4632 ::google::protobuf::Metadata GetMetadata() const final;
4633
4634 // nested types ----------------------------------------------------
4635
4636 // accessors -------------------------------------------------------
4637
4638 // repeated .Hdfs.Internal.BlockWithLocationsProto blocks = 1;
4639 int blocks_size() const;
4640 void clear_blocks();
4641 static const int kBlocksFieldNumber = 1;
4642 ::Hdfs::Internal::BlockWithLocationsProto* mutable_blocks(int index);
4643 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockWithLocationsProto >*
4644 mutable_blocks();
4645 const ::Hdfs::Internal::BlockWithLocationsProto& blocks(int index) const;
4646 ::Hdfs::Internal::BlockWithLocationsProto* add_blocks();
4647 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockWithLocationsProto >&
4648 blocks() const;
4649
4650 // @@protoc_insertion_point(class_scope:Hdfs.Internal.BlocksWithLocationsProto)
4651 private:
4652
4653 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
4654 ::google::protobuf::internal::HasBits<1> _has_bits_;
4655 mutable ::google::protobuf::internal::CachedSize _cached_size_;
4656 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockWithLocationsProto > blocks_;
4657 friend struct ::protobuf_hdfs_2eproto::TableStruct;
4658};
4659// -------------------------------------------------------------------
4660
4661class RemoteEditLogProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RemoteEditLogProto) */ {
4662 public:
4663 RemoteEditLogProto();
4664 virtual ~RemoteEditLogProto();
4665
4666 RemoteEditLogProto(const RemoteEditLogProto& from);
4667
4668 inline RemoteEditLogProto& operator=(const RemoteEditLogProto& from) {
4669 CopyFrom(from);
4670 return *this;
4671 }
4672 #if LANG_CXX11
4673 RemoteEditLogProto(RemoteEditLogProto&& from) noexcept
4674 : RemoteEditLogProto() {
4675 *this = ::std::move(from);
4676 }
4677
4678 inline RemoteEditLogProto& operator=(RemoteEditLogProto&& from) noexcept {
4679 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4680 if (this != &from) InternalSwap(&from);
4681 } else {
4682 CopyFrom(from);
4683 }
4684 return *this;
4685 }
4686 #endif
4687 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
4688 return _internal_metadata_.unknown_fields();
4689 }
4690 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
4691 return _internal_metadata_.mutable_unknown_fields();
4692 }
4693
4694 static const ::google::protobuf::Descriptor* descriptor();
4695 static const RemoteEditLogProto& default_instance();
4696
4697 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4698 static inline const RemoteEditLogProto* internal_default_instance() {
4699 return reinterpret_cast<const RemoteEditLogProto*>(
4700 &_RemoteEditLogProto_default_instance_);
4701 }
4702 static constexpr int kIndexInFileMessages =
4703 26;
4704
4705 void Swap(RemoteEditLogProto* other);
4706 friend void swap(RemoteEditLogProto& a, RemoteEditLogProto& b) {
4707 a.Swap(&b);
4708 }
4709
4710 // implements Message ----------------------------------------------
4711
4712 inline RemoteEditLogProto* New() const final {
4713 return CreateMaybeMessage<RemoteEditLogProto>(NULL);
4714 }
4715
4716 RemoteEditLogProto* New(::google::protobuf::Arena* arena) const final {
4717 return CreateMaybeMessage<RemoteEditLogProto>(arena);
4718 }
4719 void CopyFrom(const ::google::protobuf::Message& from) final;
4720 void MergeFrom(const ::google::protobuf::Message& from) final;
4721 void CopyFrom(const RemoteEditLogProto& from);
4722 void MergeFrom(const RemoteEditLogProto& from);
4723 void Clear() final;
4724 bool IsInitialized() const final;
4725
4726 size_t ByteSizeLong() const final;
4727 bool MergePartialFromCodedStream(
4728 ::google::protobuf::io::CodedInputStream* input) final;
4729 void SerializeWithCachedSizes(
4730 ::google::protobuf::io::CodedOutputStream* output) const final;
4731 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
4732 bool deterministic, ::google::protobuf::uint8* target) const final;
4733 int GetCachedSize() const final { return _cached_size_.Get(); }
4734
4735 private:
4736 void SharedCtor();
4737 void SharedDtor();
4738 void SetCachedSize(int size) const final;
4739 void InternalSwap(RemoteEditLogProto* other);
4740 private:
4741 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
4742 return NULL;
4743 }
4744 inline void* MaybeArenaPtr() const {
4745 return NULL;
4746 }
4747 public:
4748
4749 ::google::protobuf::Metadata GetMetadata() const final;
4750
4751 // nested types ----------------------------------------------------
4752
4753 // accessors -------------------------------------------------------
4754
4755 // required uint64 startTxId = 1;
4756 bool has_starttxid() const;
4757 void clear_starttxid();
4758 static const int kStartTxIdFieldNumber = 1;
4759 ::google::protobuf::uint64 starttxid() const;
4760 void set_starttxid(::google::protobuf::uint64 value);
4761
4762 // required uint64 endTxId = 2;
4763 bool has_endtxid() const;
4764 void clear_endtxid();
4765 static const int kEndTxIdFieldNumber = 2;
4766 ::google::protobuf::uint64 endtxid() const;
4767 void set_endtxid(::google::protobuf::uint64 value);
4768
4769 // optional bool isInProgress = 3 [default = false];
4770 bool has_isinprogress() const;
4771 void clear_isinprogress();
4772 static const int kIsInProgressFieldNumber = 3;
4773 bool isinprogress() const;
4774 void set_isinprogress(bool value);
4775
4776 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RemoteEditLogProto)
4777 private:
4778 void set_has_starttxid();
4779 void clear_has_starttxid();
4780 void set_has_endtxid();
4781 void clear_has_endtxid();
4782 void set_has_isinprogress();
4783 void clear_has_isinprogress();
4784
4785 // helper for ByteSizeLong()
4786 size_t RequiredFieldsByteSizeFallback() const;
4787
4788 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
4789 ::google::protobuf::internal::HasBits<1> _has_bits_;
4790 mutable ::google::protobuf::internal::CachedSize _cached_size_;
4791 ::google::protobuf::uint64 starttxid_;
4792 ::google::protobuf::uint64 endtxid_;
4793 bool isinprogress_;
4794 friend struct ::protobuf_hdfs_2eproto::TableStruct;
4795};
4796// -------------------------------------------------------------------
4797
4798class RemoteEditLogManifestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RemoteEditLogManifestProto) */ {
4799 public:
4800 RemoteEditLogManifestProto();
4801 virtual ~RemoteEditLogManifestProto();
4802
4803 RemoteEditLogManifestProto(const RemoteEditLogManifestProto& from);
4804
4805 inline RemoteEditLogManifestProto& operator=(const RemoteEditLogManifestProto& from) {
4806 CopyFrom(from);
4807 return *this;
4808 }
4809 #if LANG_CXX11
4810 RemoteEditLogManifestProto(RemoteEditLogManifestProto&& from) noexcept
4811 : RemoteEditLogManifestProto() {
4812 *this = ::std::move(from);
4813 }
4814
4815 inline RemoteEditLogManifestProto& operator=(RemoteEditLogManifestProto&& from) noexcept {
4816 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4817 if (this != &from) InternalSwap(&from);
4818 } else {
4819 CopyFrom(from);
4820 }
4821 return *this;
4822 }
4823 #endif
4824 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
4825 return _internal_metadata_.unknown_fields();
4826 }
4827 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
4828 return _internal_metadata_.mutable_unknown_fields();
4829 }
4830
4831 static const ::google::protobuf::Descriptor* descriptor();
4832 static const RemoteEditLogManifestProto& default_instance();
4833
4834 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4835 static inline const RemoteEditLogManifestProto* internal_default_instance() {
4836 return reinterpret_cast<const RemoteEditLogManifestProto*>(
4837 &_RemoteEditLogManifestProto_default_instance_);
4838 }
4839 static constexpr int kIndexInFileMessages =
4840 27;
4841
4842 void Swap(RemoteEditLogManifestProto* other);
4843 friend void swap(RemoteEditLogManifestProto& a, RemoteEditLogManifestProto& b) {
4844 a.Swap(&b);
4845 }
4846
4847 // implements Message ----------------------------------------------
4848
4849 inline RemoteEditLogManifestProto* New() const final {
4850 return CreateMaybeMessage<RemoteEditLogManifestProto>(NULL);
4851 }
4852
4853 RemoteEditLogManifestProto* New(::google::protobuf::Arena* arena) const final {
4854 return CreateMaybeMessage<RemoteEditLogManifestProto>(arena);
4855 }
4856 void CopyFrom(const ::google::protobuf::Message& from) final;
4857 void MergeFrom(const ::google::protobuf::Message& from) final;
4858 void CopyFrom(const RemoteEditLogManifestProto& from);
4859 void MergeFrom(const RemoteEditLogManifestProto& from);
4860 void Clear() final;
4861 bool IsInitialized() const final;
4862
4863 size_t ByteSizeLong() const final;
4864 bool MergePartialFromCodedStream(
4865 ::google::protobuf::io::CodedInputStream* input) final;
4866 void SerializeWithCachedSizes(
4867 ::google::protobuf::io::CodedOutputStream* output) const final;
4868 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
4869 bool deterministic, ::google::protobuf::uint8* target) const final;
4870 int GetCachedSize() const final { return _cached_size_.Get(); }
4871
4872 private:
4873 void SharedCtor();
4874 void SharedDtor();
4875 void SetCachedSize(int size) const final;
4876 void InternalSwap(RemoteEditLogManifestProto* other);
4877 private:
4878 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
4879 return NULL;
4880 }
4881 inline void* MaybeArenaPtr() const {
4882 return NULL;
4883 }
4884 public:
4885
4886 ::google::protobuf::Metadata GetMetadata() const final;
4887
4888 // nested types ----------------------------------------------------
4889
4890 // accessors -------------------------------------------------------
4891
4892 // repeated .Hdfs.Internal.RemoteEditLogProto logs = 1;
4893 int logs_size() const;
4894 void clear_logs();
4895 static const int kLogsFieldNumber = 1;
4896 ::Hdfs::Internal::RemoteEditLogProto* mutable_logs(int index);
4897 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RemoteEditLogProto >*
4898 mutable_logs();
4899 const ::Hdfs::Internal::RemoteEditLogProto& logs(int index) const;
4900 ::Hdfs::Internal::RemoteEditLogProto* add_logs();
4901 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RemoteEditLogProto >&
4902 logs() const;
4903
4904 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RemoteEditLogManifestProto)
4905 private:
4906
4907 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
4908 ::google::protobuf::internal::HasBits<1> _has_bits_;
4909 mutable ::google::protobuf::internal::CachedSize _cached_size_;
4910 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RemoteEditLogProto > logs_;
4911 friend struct ::protobuf_hdfs_2eproto::TableStruct;
4912};
4913// -------------------------------------------------------------------
4914
4915class NamespaceInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.NamespaceInfoProto) */ {
4916 public:
4917 NamespaceInfoProto();
4918 virtual ~NamespaceInfoProto();
4919
4920 NamespaceInfoProto(const NamespaceInfoProto& from);
4921
4922 inline NamespaceInfoProto& operator=(const NamespaceInfoProto& from) {
4923 CopyFrom(from);
4924 return *this;
4925 }
4926 #if LANG_CXX11
4927 NamespaceInfoProto(NamespaceInfoProto&& from) noexcept
4928 : NamespaceInfoProto() {
4929 *this = ::std::move(from);
4930 }
4931
4932 inline NamespaceInfoProto& operator=(NamespaceInfoProto&& from) noexcept {
4933 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4934 if (this != &from) InternalSwap(&from);
4935 } else {
4936 CopyFrom(from);
4937 }
4938 return *this;
4939 }
4940 #endif
4941 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
4942 return _internal_metadata_.unknown_fields();
4943 }
4944 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
4945 return _internal_metadata_.mutable_unknown_fields();
4946 }
4947
4948 static const ::google::protobuf::Descriptor* descriptor();
4949 static const NamespaceInfoProto& default_instance();
4950
4951 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4952 static inline const NamespaceInfoProto* internal_default_instance() {
4953 return reinterpret_cast<const NamespaceInfoProto*>(
4954 &_NamespaceInfoProto_default_instance_);
4955 }
4956 static constexpr int kIndexInFileMessages =
4957 28;
4958
4959 void Swap(NamespaceInfoProto* other);
4960 friend void swap(NamespaceInfoProto& a, NamespaceInfoProto& b) {
4961 a.Swap(&b);
4962 }
4963
4964 // implements Message ----------------------------------------------
4965
4966 inline NamespaceInfoProto* New() const final {
4967 return CreateMaybeMessage<NamespaceInfoProto>(NULL);
4968 }
4969
4970 NamespaceInfoProto* New(::google::protobuf::Arena* arena) const final {
4971 return CreateMaybeMessage<NamespaceInfoProto>(arena);
4972 }
4973 void CopyFrom(const ::google::protobuf::Message& from) final;
4974 void MergeFrom(const ::google::protobuf::Message& from) final;
4975 void CopyFrom(const NamespaceInfoProto& from);
4976 void MergeFrom(const NamespaceInfoProto& from);
4977 void Clear() final;
4978 bool IsInitialized() const final;
4979
4980 size_t ByteSizeLong() const final;
4981 bool MergePartialFromCodedStream(
4982 ::google::protobuf::io::CodedInputStream* input) final;
4983 void SerializeWithCachedSizes(
4984 ::google::protobuf::io::CodedOutputStream* output) const final;
4985 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
4986 bool deterministic, ::google::protobuf::uint8* target) const final;
4987 int GetCachedSize() const final { return _cached_size_.Get(); }
4988
4989 private:
4990 void SharedCtor();
4991 void SharedDtor();
4992 void SetCachedSize(int size) const final;
4993 void InternalSwap(NamespaceInfoProto* other);
4994 private:
4995 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
4996 return NULL;
4997 }
4998 inline void* MaybeArenaPtr() const {
4999 return NULL;
5000 }
5001 public:
5002
5003 ::google::protobuf::Metadata GetMetadata() const final;
5004
5005 // nested types ----------------------------------------------------
5006
5007 // accessors -------------------------------------------------------
5008
5009 // required string buildVersion = 1;
5010 bool has_buildversion() const;
5011 void clear_buildversion();
5012 static const int kBuildVersionFieldNumber = 1;
5013 const ::std::string& buildversion() const;
5014 void set_buildversion(const ::std::string& value);
5015 #if LANG_CXX11
5016 void set_buildversion(::std::string&& value);
5017 #endif
5018 void set_buildversion(const char* value);
5019 void set_buildversion(const char* value, size_t size);
5020 ::std::string* mutable_buildversion();
5021 ::std::string* release_buildversion();
5022 void set_allocated_buildversion(::std::string* buildversion);
5023
5024 // required string blockPoolID = 3;
5025 bool has_blockpoolid() const;
5026 void clear_blockpoolid();
5027 static const int kBlockPoolIDFieldNumber = 3;
5028 const ::std::string& blockpoolid() const;
5029 void set_blockpoolid(const ::std::string& value);
5030 #if LANG_CXX11
5031 void set_blockpoolid(::std::string&& value);
5032 #endif
5033 void set_blockpoolid(const char* value);
5034 void set_blockpoolid(const char* value, size_t size);
5035 ::std::string* mutable_blockpoolid();
5036 ::std::string* release_blockpoolid();
5037 void set_allocated_blockpoolid(::std::string* blockpoolid);
5038
5039 // required string softwareVersion = 5;
5040 bool has_softwareversion() const;
5041 void clear_softwareversion();
5042 static const int kSoftwareVersionFieldNumber = 5;
5043 const ::std::string& softwareversion() const;
5044 void set_softwareversion(const ::std::string& value);
5045 #if LANG_CXX11
5046 void set_softwareversion(::std::string&& value);
5047 #endif
5048 void set_softwareversion(const char* value);
5049 void set_softwareversion(const char* value, size_t size);
5050 ::std::string* mutable_softwareversion();
5051 ::std::string* release_softwareversion();
5052 void set_allocated_softwareversion(::std::string* softwareversion);
5053
5054 // required .Hdfs.Internal.StorageInfoProto storageInfo = 4;
5055 bool has_storageinfo() const;
5056 void clear_storageinfo();
5057 static const int kStorageInfoFieldNumber = 4;
5058 private:
5059 const ::Hdfs::Internal::StorageInfoProto& _internal_storageinfo() const;
5060 public:
5061 const ::Hdfs::Internal::StorageInfoProto& storageinfo() const;
5062 ::Hdfs::Internal::StorageInfoProto* release_storageinfo();
5063 ::Hdfs::Internal::StorageInfoProto* mutable_storageinfo();
5064 void set_allocated_storageinfo(::Hdfs::Internal::StorageInfoProto* storageinfo);
5065
5066 // required uint32 unused = 2;
5067 bool has_unused() const;
5068 void clear_unused();
5069 static const int kUnusedFieldNumber = 2;
5070 ::google::protobuf::uint32 unused() const;
5071 void set_unused(::google::protobuf::uint32 value);
5072
5073 // @@protoc_insertion_point(class_scope:Hdfs.Internal.NamespaceInfoProto)
5074 private:
5075 void set_has_buildversion();
5076 void clear_has_buildversion();
5077 void set_has_unused();
5078 void clear_has_unused();
5079 void set_has_blockpoolid();
5080 void clear_has_blockpoolid();
5081 void set_has_storageinfo();
5082 void clear_has_storageinfo();
5083 void set_has_softwareversion();
5084 void clear_has_softwareversion();
5085
5086 // helper for ByteSizeLong()
5087 size_t RequiredFieldsByteSizeFallback() const;
5088
5089 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
5090 ::google::protobuf::internal::HasBits<1> _has_bits_;
5091 mutable ::google::protobuf::internal::CachedSize _cached_size_;
5092 ::google::protobuf::internal::ArenaStringPtr buildversion_;
5093 ::google::protobuf::internal::ArenaStringPtr blockpoolid_;
5094 ::google::protobuf::internal::ArenaStringPtr softwareversion_;
5095 ::Hdfs::Internal::StorageInfoProto* storageinfo_;
5096 ::google::protobuf::uint32 unused_;
5097 friend struct ::protobuf_hdfs_2eproto::TableStruct;
5098};
5099// -------------------------------------------------------------------
5100
5101class BlockKeyProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.BlockKeyProto) */ {
5102 public:
5103 BlockKeyProto();
5104 virtual ~BlockKeyProto();
5105
5106 BlockKeyProto(const BlockKeyProto& from);
5107
5108 inline BlockKeyProto& operator=(const BlockKeyProto& from) {
5109 CopyFrom(from);
5110 return *this;
5111 }
5112 #if LANG_CXX11
5113 BlockKeyProto(BlockKeyProto&& from) noexcept
5114 : BlockKeyProto() {
5115 *this = ::std::move(from);
5116 }
5117
5118 inline BlockKeyProto& operator=(BlockKeyProto&& from) noexcept {
5119 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
5120 if (this != &from) InternalSwap(&from);
5121 } else {
5122 CopyFrom(from);
5123 }
5124 return *this;
5125 }
5126 #endif
5127 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
5128 return _internal_metadata_.unknown_fields();
5129 }
5130 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
5131 return _internal_metadata_.mutable_unknown_fields();
5132 }
5133
5134 static const ::google::protobuf::Descriptor* descriptor();
5135 static const BlockKeyProto& default_instance();
5136
5137 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5138 static inline const BlockKeyProto* internal_default_instance() {
5139 return reinterpret_cast<const BlockKeyProto*>(
5140 &_BlockKeyProto_default_instance_);
5141 }
5142 static constexpr int kIndexInFileMessages =
5143 29;
5144
5145 void Swap(BlockKeyProto* other);
5146 friend void swap(BlockKeyProto& a, BlockKeyProto& b) {
5147 a.Swap(&b);
5148 }
5149
5150 // implements Message ----------------------------------------------
5151
5152 inline BlockKeyProto* New() const final {
5153 return CreateMaybeMessage<BlockKeyProto>(NULL);
5154 }
5155
5156 BlockKeyProto* New(::google::protobuf::Arena* arena) const final {
5157 return CreateMaybeMessage<BlockKeyProto>(arena);
5158 }
5159 void CopyFrom(const ::google::protobuf::Message& from) final;
5160 void MergeFrom(const ::google::protobuf::Message& from) final;
5161 void CopyFrom(const BlockKeyProto& from);
5162 void MergeFrom(const BlockKeyProto& from);
5163 void Clear() final;
5164 bool IsInitialized() const final;
5165
5166 size_t ByteSizeLong() const final;
5167 bool MergePartialFromCodedStream(
5168 ::google::protobuf::io::CodedInputStream* input) final;
5169 void SerializeWithCachedSizes(
5170 ::google::protobuf::io::CodedOutputStream* output) const final;
5171 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
5172 bool deterministic, ::google::protobuf::uint8* target) const final;
5173 int GetCachedSize() const final { return _cached_size_.Get(); }
5174
5175 private:
5176 void SharedCtor();
5177 void SharedDtor();
5178 void SetCachedSize(int size) const final;
5179 void InternalSwap(BlockKeyProto* other);
5180 private:
5181 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
5182 return NULL;
5183 }
5184 inline void* MaybeArenaPtr() const {
5185 return NULL;
5186 }
5187 public:
5188
5189 ::google::protobuf::Metadata GetMetadata() const final;
5190
5191 // nested types ----------------------------------------------------
5192
5193 // accessors -------------------------------------------------------
5194
5195 // optional bytes keyBytes = 3;
5196 bool has_keybytes() const;
5197 void clear_keybytes();
5198 static const int kKeyBytesFieldNumber = 3;
5199 const ::std::string& keybytes() const;
5200 void set_keybytes(const ::std::string& value);
5201 #if LANG_CXX11
5202 void set_keybytes(::std::string&& value);
5203 #endif
5204 void set_keybytes(const char* value);
5205 void set_keybytes(const void* value, size_t size);
5206 ::std::string* mutable_keybytes();
5207 ::std::string* release_keybytes();
5208 void set_allocated_keybytes(::std::string* keybytes);
5209
5210 // required uint64 expiryDate = 2;
5211 bool has_expirydate() const;
5212 void clear_expirydate();
5213 static const int kExpiryDateFieldNumber = 2;
5214 ::google::protobuf::uint64 expirydate() const;
5215 void set_expirydate(::google::protobuf::uint64 value);
5216
5217 // required uint32 keyId = 1;
5218 bool has_keyid() const;
5219 void clear_keyid();
5220 static const int kKeyIdFieldNumber = 1;
5221 ::google::protobuf::uint32 keyid() const;
5222 void set_keyid(::google::protobuf::uint32 value);
5223
5224 // @@protoc_insertion_point(class_scope:Hdfs.Internal.BlockKeyProto)
5225 private:
5226 void set_has_keyid();
5227 void clear_has_keyid();
5228 void set_has_expirydate();
5229 void clear_has_expirydate();
5230 void set_has_keybytes();
5231 void clear_has_keybytes();
5232
5233 // helper for ByteSizeLong()
5234 size_t RequiredFieldsByteSizeFallback() const;
5235
5236 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
5237 ::google::protobuf::internal::HasBits<1> _has_bits_;
5238 mutable ::google::protobuf::internal::CachedSize _cached_size_;
5239 ::google::protobuf::internal::ArenaStringPtr keybytes_;
5240 ::google::protobuf::uint64 expirydate_;
5241 ::google::protobuf::uint32 keyid_;
5242 friend struct ::protobuf_hdfs_2eproto::TableStruct;
5243};
5244// -------------------------------------------------------------------
5245
5246class ExportedBlockKeysProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.ExportedBlockKeysProto) */ {
5247 public:
5248 ExportedBlockKeysProto();
5249 virtual ~ExportedBlockKeysProto();
5250
5251 ExportedBlockKeysProto(const ExportedBlockKeysProto& from);
5252
5253 inline ExportedBlockKeysProto& operator=(const ExportedBlockKeysProto& from) {
5254 CopyFrom(from);
5255 return *this;
5256 }
5257 #if LANG_CXX11
5258 ExportedBlockKeysProto(ExportedBlockKeysProto&& from) noexcept
5259 : ExportedBlockKeysProto() {
5260 *this = ::std::move(from);
5261 }
5262
5263 inline ExportedBlockKeysProto& operator=(ExportedBlockKeysProto&& from) noexcept {
5264 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
5265 if (this != &from) InternalSwap(&from);
5266 } else {
5267 CopyFrom(from);
5268 }
5269 return *this;
5270 }
5271 #endif
5272 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
5273 return _internal_metadata_.unknown_fields();
5274 }
5275 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
5276 return _internal_metadata_.mutable_unknown_fields();
5277 }
5278
5279 static const ::google::protobuf::Descriptor* descriptor();
5280 static const ExportedBlockKeysProto& default_instance();
5281
5282 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5283 static inline const ExportedBlockKeysProto* internal_default_instance() {
5284 return reinterpret_cast<const ExportedBlockKeysProto*>(
5285 &_ExportedBlockKeysProto_default_instance_);
5286 }
5287 static constexpr int kIndexInFileMessages =
5288 30;
5289
5290 void Swap(ExportedBlockKeysProto* other);
5291 friend void swap(ExportedBlockKeysProto& a, ExportedBlockKeysProto& b) {
5292 a.Swap(&b);
5293 }
5294
5295 // implements Message ----------------------------------------------
5296
5297 inline ExportedBlockKeysProto* New() const final {
5298 return CreateMaybeMessage<ExportedBlockKeysProto>(NULL);
5299 }
5300
5301 ExportedBlockKeysProto* New(::google::protobuf::Arena* arena) const final {
5302 return CreateMaybeMessage<ExportedBlockKeysProto>(arena);
5303 }
5304 void CopyFrom(const ::google::protobuf::Message& from) final;
5305 void MergeFrom(const ::google::protobuf::Message& from) final;
5306 void CopyFrom(const ExportedBlockKeysProto& from);
5307 void MergeFrom(const ExportedBlockKeysProto& from);
5308 void Clear() final;
5309 bool IsInitialized() const final;
5310
5311 size_t ByteSizeLong() const final;
5312 bool MergePartialFromCodedStream(
5313 ::google::protobuf::io::CodedInputStream* input) final;
5314 void SerializeWithCachedSizes(
5315 ::google::protobuf::io::CodedOutputStream* output) const final;
5316 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
5317 bool deterministic, ::google::protobuf::uint8* target) const final;
5318 int GetCachedSize() const final { return _cached_size_.Get(); }
5319
5320 private:
5321 void SharedCtor();
5322 void SharedDtor();
5323 void SetCachedSize(int size) const final;
5324 void InternalSwap(ExportedBlockKeysProto* other);
5325 private:
5326 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
5327 return NULL;
5328 }
5329 inline void* MaybeArenaPtr() const {
5330 return NULL;
5331 }
5332 public:
5333
5334 ::google::protobuf::Metadata GetMetadata() const final;
5335
5336 // nested types ----------------------------------------------------
5337
5338 // accessors -------------------------------------------------------
5339
5340 // repeated .Hdfs.Internal.BlockKeyProto allKeys = 5;
5341 int allkeys_size() const;
5342 void clear_allkeys();
5343 static const int kAllKeysFieldNumber = 5;
5344 ::Hdfs::Internal::BlockKeyProto* mutable_allkeys(int index);
5345 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockKeyProto >*
5346 mutable_allkeys();
5347 const ::Hdfs::Internal::BlockKeyProto& allkeys(int index) const;
5348 ::Hdfs::Internal::BlockKeyProto* add_allkeys();
5349 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockKeyProto >&
5350 allkeys() const;
5351
5352 // required .Hdfs.Internal.BlockKeyProto currentKey = 4;
5353 bool has_currentkey() const;
5354 void clear_currentkey();
5355 static const int kCurrentKeyFieldNumber = 4;
5356 private:
5357 const ::Hdfs::Internal::BlockKeyProto& _internal_currentkey() const;
5358 public:
5359 const ::Hdfs::Internal::BlockKeyProto& currentkey() const;
5360 ::Hdfs::Internal::BlockKeyProto* release_currentkey();
5361 ::Hdfs::Internal::BlockKeyProto* mutable_currentkey();
5362 void set_allocated_currentkey(::Hdfs::Internal::BlockKeyProto* currentkey);
5363
5364 // required uint64 keyUpdateInterval = 2;
5365 bool has_keyupdateinterval() const;
5366 void clear_keyupdateinterval();
5367 static const int kKeyUpdateIntervalFieldNumber = 2;
5368 ::google::protobuf::uint64 keyupdateinterval() const;
5369 void set_keyupdateinterval(::google::protobuf::uint64 value);
5370
5371 // required uint64 tokenLifeTime = 3;
5372 bool has_tokenlifetime() const;
5373 void clear_tokenlifetime();
5374 static const int kTokenLifeTimeFieldNumber = 3;
5375 ::google::protobuf::uint64 tokenlifetime() const;
5376 void set_tokenlifetime(::google::protobuf::uint64 value);
5377
5378 // required bool isBlockTokenEnabled = 1;
5379 bool has_isblocktokenenabled() const;
5380 void clear_isblocktokenenabled();
5381 static const int kIsBlockTokenEnabledFieldNumber = 1;
5382 bool isblocktokenenabled() const;
5383 void set_isblocktokenenabled(bool value);
5384
5385 // @@protoc_insertion_point(class_scope:Hdfs.Internal.ExportedBlockKeysProto)
5386 private:
5387 void set_has_isblocktokenenabled();
5388 void clear_has_isblocktokenenabled();
5389 void set_has_keyupdateinterval();
5390 void clear_has_keyupdateinterval();
5391 void set_has_tokenlifetime();
5392 void clear_has_tokenlifetime();
5393 void set_has_currentkey();
5394 void clear_has_currentkey();
5395
5396 // helper for ByteSizeLong()
5397 size_t RequiredFieldsByteSizeFallback() const;
5398
5399 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
5400 ::google::protobuf::internal::HasBits<1> _has_bits_;
5401 mutable ::google::protobuf::internal::CachedSize _cached_size_;
5402 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockKeyProto > allkeys_;
5403 ::Hdfs::Internal::BlockKeyProto* currentkey_;
5404 ::google::protobuf::uint64 keyupdateinterval_;
5405 ::google::protobuf::uint64 tokenlifetime_;
5406 bool isblocktokenenabled_;
5407 friend struct ::protobuf_hdfs_2eproto::TableStruct;
5408};
5409// -------------------------------------------------------------------
5410
5411class RecoveringBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RecoveringBlockProto) */ {
5412 public:
5413 RecoveringBlockProto();
5414 virtual ~RecoveringBlockProto();
5415
5416 RecoveringBlockProto(const RecoveringBlockProto& from);
5417
5418 inline RecoveringBlockProto& operator=(const RecoveringBlockProto& from) {
5419 CopyFrom(from);
5420 return *this;
5421 }
5422 #if LANG_CXX11
5423 RecoveringBlockProto(RecoveringBlockProto&& from) noexcept
5424 : RecoveringBlockProto() {
5425 *this = ::std::move(from);
5426 }
5427
5428 inline RecoveringBlockProto& operator=(RecoveringBlockProto&& from) noexcept {
5429 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
5430 if (this != &from) InternalSwap(&from);
5431 } else {
5432 CopyFrom(from);
5433 }
5434 return *this;
5435 }
5436 #endif
5437 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
5438 return _internal_metadata_.unknown_fields();
5439 }
5440 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
5441 return _internal_metadata_.mutable_unknown_fields();
5442 }
5443
5444 static const ::google::protobuf::Descriptor* descriptor();
5445 static const RecoveringBlockProto& default_instance();
5446
5447 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5448 static inline const RecoveringBlockProto* internal_default_instance() {
5449 return reinterpret_cast<const RecoveringBlockProto*>(
5450 &_RecoveringBlockProto_default_instance_);
5451 }
5452 static constexpr int kIndexInFileMessages =
5453 31;
5454
5455 void Swap(RecoveringBlockProto* other);
5456 friend void swap(RecoveringBlockProto& a, RecoveringBlockProto& b) {
5457 a.Swap(&b);
5458 }
5459
5460 // implements Message ----------------------------------------------
5461
5462 inline RecoveringBlockProto* New() const final {
5463 return CreateMaybeMessage<RecoveringBlockProto>(NULL);
5464 }
5465
5466 RecoveringBlockProto* New(::google::protobuf::Arena* arena) const final {
5467 return CreateMaybeMessage<RecoveringBlockProto>(arena);
5468 }
5469 void CopyFrom(const ::google::protobuf::Message& from) final;
5470 void MergeFrom(const ::google::protobuf::Message& from) final;
5471 void CopyFrom(const RecoveringBlockProto& from);
5472 void MergeFrom(const RecoveringBlockProto& from);
5473 void Clear() final;
5474 bool IsInitialized() const final;
5475
5476 size_t ByteSizeLong() const final;
5477 bool MergePartialFromCodedStream(
5478 ::google::protobuf::io::CodedInputStream* input) final;
5479 void SerializeWithCachedSizes(
5480 ::google::protobuf::io::CodedOutputStream* output) const final;
5481 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
5482 bool deterministic, ::google::protobuf::uint8* target) const final;
5483 int GetCachedSize() const final { return _cached_size_.Get(); }
5484
5485 private:
5486 void SharedCtor();
5487 void SharedDtor();
5488 void SetCachedSize(int size) const final;
5489 void InternalSwap(RecoveringBlockProto* other);
5490 private:
5491 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
5492 return NULL;
5493 }
5494 inline void* MaybeArenaPtr() const {
5495 return NULL;
5496 }
5497 public:
5498
5499 ::google::protobuf::Metadata GetMetadata() const final;
5500
5501 // nested types ----------------------------------------------------
5502
5503 // accessors -------------------------------------------------------
5504
5505 // required .Hdfs.Internal.LocatedBlockProto block = 2;
5506 bool has_block() const;
5507 void clear_block();
5508 static const int kBlockFieldNumber = 2;
5509 private:
5510 const ::Hdfs::Internal::LocatedBlockProto& _internal_block() const;
5511 public:
5512 const ::Hdfs::Internal::LocatedBlockProto& block() const;
5513 ::Hdfs::Internal::LocatedBlockProto* release_block();
5514 ::Hdfs::Internal::LocatedBlockProto* mutable_block();
5515 void set_allocated_block(::Hdfs::Internal::LocatedBlockProto* block);
5516
5517 // required uint64 newGenStamp = 1;
5518 bool has_newgenstamp() const;
5519 void clear_newgenstamp();
5520 static const int kNewGenStampFieldNumber = 1;
5521 ::google::protobuf::uint64 newgenstamp() const;
5522 void set_newgenstamp(::google::protobuf::uint64 value);
5523
5524 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RecoveringBlockProto)
5525 private:
5526 void set_has_newgenstamp();
5527 void clear_has_newgenstamp();
5528 void set_has_block();
5529 void clear_has_block();
5530
5531 // helper for ByteSizeLong()
5532 size_t RequiredFieldsByteSizeFallback() const;
5533
5534 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
5535 ::google::protobuf::internal::HasBits<1> _has_bits_;
5536 mutable ::google::protobuf::internal::CachedSize _cached_size_;
5537 ::Hdfs::Internal::LocatedBlockProto* block_;
5538 ::google::protobuf::uint64 newgenstamp_;
5539 friend struct ::protobuf_hdfs_2eproto::TableStruct;
5540};
5541// -------------------------------------------------------------------
5542
5543class VersionRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.VersionRequestProto) */ {
5544 public:
5545 VersionRequestProto();
5546 virtual ~VersionRequestProto();
5547
5548 VersionRequestProto(const VersionRequestProto& from);
5549
5550 inline VersionRequestProto& operator=(const VersionRequestProto& from) {
5551 CopyFrom(from);
5552 return *this;
5553 }
5554 #if LANG_CXX11
5555 VersionRequestProto(VersionRequestProto&& from) noexcept
5556 : VersionRequestProto() {
5557 *this = ::std::move(from);
5558 }
5559
5560 inline VersionRequestProto& operator=(VersionRequestProto&& from) noexcept {
5561 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
5562 if (this != &from) InternalSwap(&from);
5563 } else {
5564 CopyFrom(from);
5565 }
5566 return *this;
5567 }
5568 #endif
5569 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
5570 return _internal_metadata_.unknown_fields();
5571 }
5572 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
5573 return _internal_metadata_.mutable_unknown_fields();
5574 }
5575
5576 static const ::google::protobuf::Descriptor* descriptor();
5577 static const VersionRequestProto& default_instance();
5578
5579 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5580 static inline const VersionRequestProto* internal_default_instance() {
5581 return reinterpret_cast<const VersionRequestProto*>(
5582 &_VersionRequestProto_default_instance_);
5583 }
5584 static constexpr int kIndexInFileMessages =
5585 32;
5586
5587 void Swap(VersionRequestProto* other);
5588 friend void swap(VersionRequestProto& a, VersionRequestProto& b) {
5589 a.Swap(&b);
5590 }
5591
5592 // implements Message ----------------------------------------------
5593
5594 inline VersionRequestProto* New() const final {
5595 return CreateMaybeMessage<VersionRequestProto>(NULL);
5596 }
5597
5598 VersionRequestProto* New(::google::protobuf::Arena* arena) const final {
5599 return CreateMaybeMessage<VersionRequestProto>(arena);
5600 }
5601 void CopyFrom(const ::google::protobuf::Message& from) final;
5602 void MergeFrom(const ::google::protobuf::Message& from) final;
5603 void CopyFrom(const VersionRequestProto& from);
5604 void MergeFrom(const VersionRequestProto& from);
5605 void Clear() final;
5606 bool IsInitialized() const final;
5607
5608 size_t ByteSizeLong() const final;
5609 bool MergePartialFromCodedStream(
5610 ::google::protobuf::io::CodedInputStream* input) final;
5611 void SerializeWithCachedSizes(
5612 ::google::protobuf::io::CodedOutputStream* output) const final;
5613 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
5614 bool deterministic, ::google::protobuf::uint8* target) const final;
5615 int GetCachedSize() const final { return _cached_size_.Get(); }
5616
5617 private:
5618 void SharedCtor();
5619 void SharedDtor();
5620 void SetCachedSize(int size) const final;
5621 void InternalSwap(VersionRequestProto* other);
5622 private:
5623 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
5624 return NULL;
5625 }
5626 inline void* MaybeArenaPtr() const {
5627 return NULL;
5628 }
5629 public:
5630
5631 ::google::protobuf::Metadata GetMetadata() const final;
5632
5633 // nested types ----------------------------------------------------
5634
5635 // accessors -------------------------------------------------------
5636
5637 // @@protoc_insertion_point(class_scope:Hdfs.Internal.VersionRequestProto)
5638 private:
5639
5640 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
5641 ::google::protobuf::internal::HasBits<1> _has_bits_;
5642 mutable ::google::protobuf::internal::CachedSize _cached_size_;
5643 friend struct ::protobuf_hdfs_2eproto::TableStruct;
5644};
5645// -------------------------------------------------------------------
5646
5647class VersionResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.VersionResponseProto) */ {
5648 public:
5649 VersionResponseProto();
5650 virtual ~VersionResponseProto();
5651
5652 VersionResponseProto(const VersionResponseProto& from);
5653
5654 inline VersionResponseProto& operator=(const VersionResponseProto& from) {
5655 CopyFrom(from);
5656 return *this;
5657 }
5658 #if LANG_CXX11
5659 VersionResponseProto(VersionResponseProto&& from) noexcept
5660 : VersionResponseProto() {
5661 *this = ::std::move(from);
5662 }
5663
5664 inline VersionResponseProto& operator=(VersionResponseProto&& from) noexcept {
5665 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
5666 if (this != &from) InternalSwap(&from);
5667 } else {
5668 CopyFrom(from);
5669 }
5670 return *this;
5671 }
5672 #endif
5673 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
5674 return _internal_metadata_.unknown_fields();
5675 }
5676 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
5677 return _internal_metadata_.mutable_unknown_fields();
5678 }
5679
5680 static const ::google::protobuf::Descriptor* descriptor();
5681 static const VersionResponseProto& default_instance();
5682
5683 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5684 static inline const VersionResponseProto* internal_default_instance() {
5685 return reinterpret_cast<const VersionResponseProto*>(
5686 &_VersionResponseProto_default_instance_);
5687 }
5688 static constexpr int kIndexInFileMessages =
5689 33;
5690
5691 void Swap(VersionResponseProto* other);
5692 friend void swap(VersionResponseProto& a, VersionResponseProto& b) {
5693 a.Swap(&b);
5694 }
5695
5696 // implements Message ----------------------------------------------
5697
5698 inline VersionResponseProto* New() const final {
5699 return CreateMaybeMessage<VersionResponseProto>(NULL);
5700 }
5701
5702 VersionResponseProto* New(::google::protobuf::Arena* arena) const final {
5703 return CreateMaybeMessage<VersionResponseProto>(arena);
5704 }
5705 void CopyFrom(const ::google::protobuf::Message& from) final;
5706 void MergeFrom(const ::google::protobuf::Message& from) final;
5707 void CopyFrom(const VersionResponseProto& from);
5708 void MergeFrom(const VersionResponseProto& from);
5709 void Clear() final;
5710 bool IsInitialized() const final;
5711
5712 size_t ByteSizeLong() const final;
5713 bool MergePartialFromCodedStream(
5714 ::google::protobuf::io::CodedInputStream* input) final;
5715 void SerializeWithCachedSizes(
5716 ::google::protobuf::io::CodedOutputStream* output) const final;
5717 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
5718 bool deterministic, ::google::protobuf::uint8* target) const final;
5719 int GetCachedSize() const final { return _cached_size_.Get(); }
5720
5721 private:
5722 void SharedCtor();
5723 void SharedDtor();
5724 void SetCachedSize(int size) const final;
5725 void InternalSwap(VersionResponseProto* other);
5726 private:
5727 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
5728 return NULL;
5729 }
5730 inline void* MaybeArenaPtr() const {
5731 return NULL;
5732 }
5733 public:
5734
5735 ::google::protobuf::Metadata GetMetadata() const final;
5736
5737 // nested types ----------------------------------------------------
5738
5739 // accessors -------------------------------------------------------
5740
5741 // required .Hdfs.Internal.NamespaceInfoProto info = 1;
5742 bool has_info() const;
5743 void clear_info();
5744 static const int kInfoFieldNumber = 1;
5745 private:
5746 const ::Hdfs::Internal::NamespaceInfoProto& _internal_info() const;
5747 public:
5748 const ::Hdfs::Internal::NamespaceInfoProto& info() const;
5749 ::Hdfs::Internal::NamespaceInfoProto* release_info();
5750 ::Hdfs::Internal::NamespaceInfoProto* mutable_info();
5751 void set_allocated_info(::Hdfs::Internal::NamespaceInfoProto* info);
5752
5753 // @@protoc_insertion_point(class_scope:Hdfs.Internal.VersionResponseProto)
5754 private:
5755 void set_has_info();
5756 void clear_has_info();
5757
5758 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
5759 ::google::protobuf::internal::HasBits<1> _has_bits_;
5760 mutable ::google::protobuf::internal::CachedSize _cached_size_;
5761 ::Hdfs::Internal::NamespaceInfoProto* info_;
5762 friend struct ::protobuf_hdfs_2eproto::TableStruct;
5763};
5764// -------------------------------------------------------------------
5765
5766class SnapshotInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.SnapshotInfoProto) */ {
5767 public:
5768 SnapshotInfoProto();
5769 virtual ~SnapshotInfoProto();
5770
5771 SnapshotInfoProto(const SnapshotInfoProto& from);
5772
5773 inline SnapshotInfoProto& operator=(const SnapshotInfoProto& from) {
5774 CopyFrom(from);
5775 return *this;
5776 }
5777 #if LANG_CXX11
5778 SnapshotInfoProto(SnapshotInfoProto&& from) noexcept
5779 : SnapshotInfoProto() {
5780 *this = ::std::move(from);
5781 }
5782
5783 inline SnapshotInfoProto& operator=(SnapshotInfoProto&& from) noexcept {
5784 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
5785 if (this != &from) InternalSwap(&from);
5786 } else {
5787 CopyFrom(from);
5788 }
5789 return *this;
5790 }
5791 #endif
5792 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
5793 return _internal_metadata_.unknown_fields();
5794 }
5795 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
5796 return _internal_metadata_.mutable_unknown_fields();
5797 }
5798
5799 static const ::google::protobuf::Descriptor* descriptor();
5800 static const SnapshotInfoProto& default_instance();
5801
5802 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5803 static inline const SnapshotInfoProto* internal_default_instance() {
5804 return reinterpret_cast<const SnapshotInfoProto*>(
5805 &_SnapshotInfoProto_default_instance_);
5806 }
5807 static constexpr int kIndexInFileMessages =
5808 34;
5809
5810 void Swap(SnapshotInfoProto* other);
5811 friend void swap(SnapshotInfoProto& a, SnapshotInfoProto& b) {
5812 a.Swap(&b);
5813 }
5814
5815 // implements Message ----------------------------------------------
5816
5817 inline SnapshotInfoProto* New() const final {
5818 return CreateMaybeMessage<SnapshotInfoProto>(NULL);
5819 }
5820
5821 SnapshotInfoProto* New(::google::protobuf::Arena* arena) const final {
5822 return CreateMaybeMessage<SnapshotInfoProto>(arena);
5823 }
5824 void CopyFrom(const ::google::protobuf::Message& from) final;
5825 void MergeFrom(const ::google::protobuf::Message& from) final;
5826 void CopyFrom(const SnapshotInfoProto& from);
5827 void MergeFrom(const SnapshotInfoProto& from);
5828 void Clear() final;
5829 bool IsInitialized() const final;
5830
5831 size_t ByteSizeLong() const final;
5832 bool MergePartialFromCodedStream(
5833 ::google::protobuf::io::CodedInputStream* input) final;
5834 void SerializeWithCachedSizes(
5835 ::google::protobuf::io::CodedOutputStream* output) const final;
5836 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
5837 bool deterministic, ::google::protobuf::uint8* target) const final;
5838 int GetCachedSize() const final { return _cached_size_.Get(); }
5839
5840 private:
5841 void SharedCtor();
5842 void SharedDtor();
5843 void SetCachedSize(int size) const final;
5844 void InternalSwap(SnapshotInfoProto* other);
5845 private:
5846 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
5847 return NULL;
5848 }
5849 inline void* MaybeArenaPtr() const {
5850 return NULL;
5851 }
5852 public:
5853
5854 ::google::protobuf::Metadata GetMetadata() const final;
5855
5856 // nested types ----------------------------------------------------
5857
5858 // accessors -------------------------------------------------------
5859
5860 // required string snapshotName = 1;
5861 bool has_snapshotname() const;
5862 void clear_snapshotname();
5863 static const int kSnapshotNameFieldNumber = 1;
5864 const ::std::string& snapshotname() const;
5865 void set_snapshotname(const ::std::string& value);
5866 #if LANG_CXX11
5867 void set_snapshotname(::std::string&& value);
5868 #endif
5869 void set_snapshotname(const char* value);
5870 void set_snapshotname(const char* value, size_t size);
5871 ::std::string* mutable_snapshotname();
5872 ::std::string* release_snapshotname();
5873 void set_allocated_snapshotname(::std::string* snapshotname);
5874
5875 // required string snapshotRoot = 2;
5876 bool has_snapshotroot() const;
5877 void clear_snapshotroot();
5878 static const int kSnapshotRootFieldNumber = 2;
5879 const ::std::string& snapshotroot() const;
5880 void set_snapshotroot(const ::std::string& value);
5881 #if LANG_CXX11
5882 void set_snapshotroot(::std::string&& value);
5883 #endif
5884 void set_snapshotroot(const char* value);
5885 void set_snapshotroot(const char* value, size_t size);
5886 ::std::string* mutable_snapshotroot();
5887 ::std::string* release_snapshotroot();
5888 void set_allocated_snapshotroot(::std::string* snapshotroot);
5889
5890 // required string owner = 4;
5891 bool has_owner() const;
5892 void clear_owner();
5893 static const int kOwnerFieldNumber = 4;
5894 const ::std::string& owner() const;
5895 void set_owner(const ::std::string& value);
5896 #if LANG_CXX11
5897 void set_owner(::std::string&& value);
5898 #endif
5899 void set_owner(const char* value);
5900 void set_owner(const char* value, size_t size);
5901 ::std::string* mutable_owner();
5902 ::std::string* release_owner();
5903 void set_allocated_owner(::std::string* owner);
5904
5905 // required string group = 5;
5906 bool has_group() const;
5907 void clear_group();
5908 static const int kGroupFieldNumber = 5;
5909 const ::std::string& group() const;
5910 void set_group(const ::std::string& value);
5911 #if LANG_CXX11
5912 void set_group(::std::string&& value);
5913 #endif
5914 void set_group(const char* value);
5915 void set_group(const char* value, size_t size);
5916 ::std::string* mutable_group();
5917 ::std::string* release_group();
5918 void set_allocated_group(::std::string* group);
5919
5920 // required string createTime = 6;
5921 bool has_createtime() const;
5922 void clear_createtime();
5923 static const int kCreateTimeFieldNumber = 6;
5924 const ::std::string& createtime() const;
5925 void set_createtime(const ::std::string& value);
5926 #if LANG_CXX11
5927 void set_createtime(::std::string&& value);
5928 #endif
5929 void set_createtime(const char* value);
5930 void set_createtime(const char* value, size_t size);
5931 ::std::string* mutable_createtime();
5932 ::std::string* release_createtime();
5933 void set_allocated_createtime(::std::string* createtime);
5934
5935 // required .Hdfs.Internal.FsPermissionProto permission = 3;
5936 bool has_permission() const;
5937 void clear_permission();
5938 static const int kPermissionFieldNumber = 3;
5939 private:
5940 const ::Hdfs::Internal::FsPermissionProto& _internal_permission() const;
5941 public:
5942 const ::Hdfs::Internal::FsPermissionProto& permission() const;
5943 ::Hdfs::Internal::FsPermissionProto* release_permission();
5944 ::Hdfs::Internal::FsPermissionProto* mutable_permission();
5945 void set_allocated_permission(::Hdfs::Internal::FsPermissionProto* permission);
5946
5947 // @@protoc_insertion_point(class_scope:Hdfs.Internal.SnapshotInfoProto)
5948 private:
5949 void set_has_snapshotname();
5950 void clear_has_snapshotname();
5951 void set_has_snapshotroot();
5952 void clear_has_snapshotroot();
5953 void set_has_permission();
5954 void clear_has_permission();
5955 void set_has_owner();
5956 void clear_has_owner();
5957 void set_has_group();
5958 void clear_has_group();
5959 void set_has_createtime();
5960 void clear_has_createtime();
5961
5962 // helper for ByteSizeLong()
5963 size_t RequiredFieldsByteSizeFallback() const;
5964
5965 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
5966 ::google::protobuf::internal::HasBits<1> _has_bits_;
5967 mutable ::google::protobuf::internal::CachedSize _cached_size_;
5968 ::google::protobuf::internal::ArenaStringPtr snapshotname_;
5969 ::google::protobuf::internal::ArenaStringPtr snapshotroot_;
5970 ::google::protobuf::internal::ArenaStringPtr owner_;
5971 ::google::protobuf::internal::ArenaStringPtr group_;
5972 ::google::protobuf::internal::ArenaStringPtr createtime_;
5973 ::Hdfs::Internal::FsPermissionProto* permission_;
5974 friend struct ::protobuf_hdfs_2eproto::TableStruct;
5975};
5976// ===================================================================
5977
5978
5979// ===================================================================
5980
5981#ifdef __GNUC__
5982 #pragma GCC diagnostic push
5983 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
5984#endif // __GNUC__
5985// ExtendedBlockProto
5986
5987// required string poolId = 1;
5988inline bool ExtendedBlockProto::has_poolid() const {
5989 return (_has_bits_[0] & 0x00000001u) != 0;
5990}
5991inline void ExtendedBlockProto::set_has_poolid() {
5992 _has_bits_[0] |= 0x00000001u;
5993}
5994inline void ExtendedBlockProto::clear_has_poolid() {
5995 _has_bits_[0] &= ~0x00000001u;
5996}
5997inline void ExtendedBlockProto::clear_poolid() {
5998 poolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5999 clear_has_poolid();
6000}
6001inline const ::std::string& ExtendedBlockProto::poolid() const {
6002 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExtendedBlockProto.poolId)
6003 return poolid_.GetNoArena();
6004}
6005inline void ExtendedBlockProto::set_poolid(const ::std::string& value) {
6006 set_has_poolid();
6007 poolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
6008 // @@protoc_insertion_point(field_set:Hdfs.Internal.ExtendedBlockProto.poolId)
6009}
6010#if LANG_CXX11
6011inline void ExtendedBlockProto::set_poolid(::std::string&& value) {
6012 set_has_poolid();
6013 poolid_.SetNoArena(
6014 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6015 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.ExtendedBlockProto.poolId)
6016}
6017#endif
6018inline void ExtendedBlockProto::set_poolid(const char* value) {
6019 GOOGLE_DCHECK(value != NULL);
6020 set_has_poolid();
6021 poolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6022 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.ExtendedBlockProto.poolId)
6023}
6024inline void ExtendedBlockProto::set_poolid(const char* value, size_t size) {
6025 set_has_poolid();
6026 poolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
6027 ::std::string(reinterpret_cast<const char*>(value), size));
6028 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.ExtendedBlockProto.poolId)
6029}
6030inline ::std::string* ExtendedBlockProto::mutable_poolid() {
6031 set_has_poolid();
6032 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.ExtendedBlockProto.poolId)
6033 return poolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6034}
6035inline ::std::string* ExtendedBlockProto::release_poolid() {
6036 // @@protoc_insertion_point(field_release:Hdfs.Internal.ExtendedBlockProto.poolId)
6037 if (!has_poolid()) {
6038 return NULL;
6039 }
6040 clear_has_poolid();
6041 return poolid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6042}
6043inline void ExtendedBlockProto::set_allocated_poolid(::std::string* poolid) {
6044 if (poolid != NULL) {
6045 set_has_poolid();
6046 } else {
6047 clear_has_poolid();
6048 }
6049 poolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), poolid);
6050 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.ExtendedBlockProto.poolId)
6051}
6052
6053// required uint64 blockId = 2;
6054inline bool ExtendedBlockProto::has_blockid() const {
6055 return (_has_bits_[0] & 0x00000002u) != 0;
6056}
6057inline void ExtendedBlockProto::set_has_blockid() {
6058 _has_bits_[0] |= 0x00000002u;
6059}
6060inline void ExtendedBlockProto::clear_has_blockid() {
6061 _has_bits_[0] &= ~0x00000002u;
6062}
6063inline void ExtendedBlockProto::clear_blockid() {
6064 blockid_ = GOOGLE_ULONGLONG(0);
6065 clear_has_blockid();
6066}
6067inline ::google::protobuf::uint64 ExtendedBlockProto::blockid() const {
6068 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExtendedBlockProto.blockId)
6069 return blockid_;
6070}
6071inline void ExtendedBlockProto::set_blockid(::google::protobuf::uint64 value) {
6072 set_has_blockid();
6073 blockid_ = value;
6074 // @@protoc_insertion_point(field_set:Hdfs.Internal.ExtendedBlockProto.blockId)
6075}
6076
6077// required uint64 generationStamp = 3;
6078inline bool ExtendedBlockProto::has_generationstamp() const {
6079 return (_has_bits_[0] & 0x00000004u) != 0;
6080}
6081inline void ExtendedBlockProto::set_has_generationstamp() {
6082 _has_bits_[0] |= 0x00000004u;
6083}
6084inline void ExtendedBlockProto::clear_has_generationstamp() {
6085 _has_bits_[0] &= ~0x00000004u;
6086}
6087inline void ExtendedBlockProto::clear_generationstamp() {
6088 generationstamp_ = GOOGLE_ULONGLONG(0);
6089 clear_has_generationstamp();
6090}
6091inline ::google::protobuf::uint64 ExtendedBlockProto::generationstamp() const {
6092 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExtendedBlockProto.generationStamp)
6093 return generationstamp_;
6094}
6095inline void ExtendedBlockProto::set_generationstamp(::google::protobuf::uint64 value) {
6096 set_has_generationstamp();
6097 generationstamp_ = value;
6098 // @@protoc_insertion_point(field_set:Hdfs.Internal.ExtendedBlockProto.generationStamp)
6099}
6100
6101// optional uint64 numBytes = 4 [default = 0];
6102inline bool ExtendedBlockProto::has_numbytes() const {
6103 return (_has_bits_[0] & 0x00000008u) != 0;
6104}
6105inline void ExtendedBlockProto::set_has_numbytes() {
6106 _has_bits_[0] |= 0x00000008u;
6107}
6108inline void ExtendedBlockProto::clear_has_numbytes() {
6109 _has_bits_[0] &= ~0x00000008u;
6110}
6111inline void ExtendedBlockProto::clear_numbytes() {
6112 numbytes_ = GOOGLE_ULONGLONG(0);
6113 clear_has_numbytes();
6114}
6115inline ::google::protobuf::uint64 ExtendedBlockProto::numbytes() const {
6116 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExtendedBlockProto.numBytes)
6117 return numbytes_;
6118}
6119inline void ExtendedBlockProto::set_numbytes(::google::protobuf::uint64 value) {
6120 set_has_numbytes();
6121 numbytes_ = value;
6122 // @@protoc_insertion_point(field_set:Hdfs.Internal.ExtendedBlockProto.numBytes)
6123}
6124
6125// -------------------------------------------------------------------
6126
6127// DatanodeIDProto
6128
6129// required string ipAddr = 1;
6130inline bool DatanodeIDProto::has_ipaddr() const {
6131 return (_has_bits_[0] & 0x00000001u) != 0;
6132}
6133inline void DatanodeIDProto::set_has_ipaddr() {
6134 _has_bits_[0] |= 0x00000001u;
6135}
6136inline void DatanodeIDProto::clear_has_ipaddr() {
6137 _has_bits_[0] &= ~0x00000001u;
6138}
6139inline void DatanodeIDProto::clear_ipaddr() {
6140 ipaddr_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6141 clear_has_ipaddr();
6142}
6143inline const ::std::string& DatanodeIDProto::ipaddr() const {
6144 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeIDProto.ipAddr)
6145 return ipaddr_.GetNoArena();
6146}
6147inline void DatanodeIDProto::set_ipaddr(const ::std::string& value) {
6148 set_has_ipaddr();
6149 ipaddr_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
6150 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeIDProto.ipAddr)
6151}
6152#if LANG_CXX11
6153inline void DatanodeIDProto::set_ipaddr(::std::string&& value) {
6154 set_has_ipaddr();
6155 ipaddr_.SetNoArena(
6156 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6157 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DatanodeIDProto.ipAddr)
6158}
6159#endif
6160inline void DatanodeIDProto::set_ipaddr(const char* value) {
6161 GOOGLE_DCHECK(value != NULL);
6162 set_has_ipaddr();
6163 ipaddr_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6164 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DatanodeIDProto.ipAddr)
6165}
6166inline void DatanodeIDProto::set_ipaddr(const char* value, size_t size) {
6167 set_has_ipaddr();
6168 ipaddr_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
6169 ::std::string(reinterpret_cast<const char*>(value), size));
6170 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DatanodeIDProto.ipAddr)
6171}
6172inline ::std::string* DatanodeIDProto::mutable_ipaddr() {
6173 set_has_ipaddr();
6174 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DatanodeIDProto.ipAddr)
6175 return ipaddr_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6176}
6177inline ::std::string* DatanodeIDProto::release_ipaddr() {
6178 // @@protoc_insertion_point(field_release:Hdfs.Internal.DatanodeIDProto.ipAddr)
6179 if (!has_ipaddr()) {
6180 return NULL;
6181 }
6182 clear_has_ipaddr();
6183 return ipaddr_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6184}
6185inline void DatanodeIDProto::set_allocated_ipaddr(::std::string* ipaddr) {
6186 if (ipaddr != NULL) {
6187 set_has_ipaddr();
6188 } else {
6189 clear_has_ipaddr();
6190 }
6191 ipaddr_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ipaddr);
6192 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DatanodeIDProto.ipAddr)
6193}
6194
6195// required string hostName = 2;
6196inline bool DatanodeIDProto::has_hostname() const {
6197 return (_has_bits_[0] & 0x00000002u) != 0;
6198}
6199inline void DatanodeIDProto::set_has_hostname() {
6200 _has_bits_[0] |= 0x00000002u;
6201}
6202inline void DatanodeIDProto::clear_has_hostname() {
6203 _has_bits_[0] &= ~0x00000002u;
6204}
6205inline void DatanodeIDProto::clear_hostname() {
6206 hostname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6207 clear_has_hostname();
6208}
6209inline const ::std::string& DatanodeIDProto::hostname() const {
6210 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeIDProto.hostName)
6211 return hostname_.GetNoArena();
6212}
6213inline void DatanodeIDProto::set_hostname(const ::std::string& value) {
6214 set_has_hostname();
6215 hostname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
6216 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeIDProto.hostName)
6217}
6218#if LANG_CXX11
6219inline void DatanodeIDProto::set_hostname(::std::string&& value) {
6220 set_has_hostname();
6221 hostname_.SetNoArena(
6222 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6223 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DatanodeIDProto.hostName)
6224}
6225#endif
6226inline void DatanodeIDProto::set_hostname(const char* value) {
6227 GOOGLE_DCHECK(value != NULL);
6228 set_has_hostname();
6229 hostname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6230 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DatanodeIDProto.hostName)
6231}
6232inline void DatanodeIDProto::set_hostname(const char* value, size_t size) {
6233 set_has_hostname();
6234 hostname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
6235 ::std::string(reinterpret_cast<const char*>(value), size));
6236 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DatanodeIDProto.hostName)
6237}
6238inline ::std::string* DatanodeIDProto::mutable_hostname() {
6239 set_has_hostname();
6240 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DatanodeIDProto.hostName)
6241 return hostname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6242}
6243inline ::std::string* DatanodeIDProto::release_hostname() {
6244 // @@protoc_insertion_point(field_release:Hdfs.Internal.DatanodeIDProto.hostName)
6245 if (!has_hostname()) {
6246 return NULL;
6247 }
6248 clear_has_hostname();
6249 return hostname_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6250}
6251inline void DatanodeIDProto::set_allocated_hostname(::std::string* hostname) {
6252 if (hostname != NULL) {
6253 set_has_hostname();
6254 } else {
6255 clear_has_hostname();
6256 }
6257 hostname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), hostname);
6258 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DatanodeIDProto.hostName)
6259}
6260
6261// required string datanodeUuid = 3;
6262inline bool DatanodeIDProto::has_datanodeuuid() const {
6263 return (_has_bits_[0] & 0x00000004u) != 0;
6264}
6265inline void DatanodeIDProto::set_has_datanodeuuid() {
6266 _has_bits_[0] |= 0x00000004u;
6267}
6268inline void DatanodeIDProto::clear_has_datanodeuuid() {
6269 _has_bits_[0] &= ~0x00000004u;
6270}
6271inline void DatanodeIDProto::clear_datanodeuuid() {
6272 datanodeuuid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6273 clear_has_datanodeuuid();
6274}
6275inline const ::std::string& DatanodeIDProto::datanodeuuid() const {
6276 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeIDProto.datanodeUuid)
6277 return datanodeuuid_.GetNoArena();
6278}
6279inline void DatanodeIDProto::set_datanodeuuid(const ::std::string& value) {
6280 set_has_datanodeuuid();
6281 datanodeuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
6282 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeIDProto.datanodeUuid)
6283}
6284#if LANG_CXX11
6285inline void DatanodeIDProto::set_datanodeuuid(::std::string&& value) {
6286 set_has_datanodeuuid();
6287 datanodeuuid_.SetNoArena(
6288 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6289 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DatanodeIDProto.datanodeUuid)
6290}
6291#endif
6292inline void DatanodeIDProto::set_datanodeuuid(const char* value) {
6293 GOOGLE_DCHECK(value != NULL);
6294 set_has_datanodeuuid();
6295 datanodeuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6296 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DatanodeIDProto.datanodeUuid)
6297}
6298inline void DatanodeIDProto::set_datanodeuuid(const char* value, size_t size) {
6299 set_has_datanodeuuid();
6300 datanodeuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
6301 ::std::string(reinterpret_cast<const char*>(value), size));
6302 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DatanodeIDProto.datanodeUuid)
6303}
6304inline ::std::string* DatanodeIDProto::mutable_datanodeuuid() {
6305 set_has_datanodeuuid();
6306 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DatanodeIDProto.datanodeUuid)
6307 return datanodeuuid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6308}
6309inline ::std::string* DatanodeIDProto::release_datanodeuuid() {
6310 // @@protoc_insertion_point(field_release:Hdfs.Internal.DatanodeIDProto.datanodeUuid)
6311 if (!has_datanodeuuid()) {
6312 return NULL;
6313 }
6314 clear_has_datanodeuuid();
6315 return datanodeuuid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6316}
6317inline void DatanodeIDProto::set_allocated_datanodeuuid(::std::string* datanodeuuid) {
6318 if (datanodeuuid != NULL) {
6319 set_has_datanodeuuid();
6320 } else {
6321 clear_has_datanodeuuid();
6322 }
6323 datanodeuuid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), datanodeuuid);
6324 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DatanodeIDProto.datanodeUuid)
6325}
6326
6327// required uint32 xferPort = 4;
6328inline bool DatanodeIDProto::has_xferport() const {
6329 return (_has_bits_[0] & 0x00000008u) != 0;
6330}
6331inline void DatanodeIDProto::set_has_xferport() {
6332 _has_bits_[0] |= 0x00000008u;
6333}
6334inline void DatanodeIDProto::clear_has_xferport() {
6335 _has_bits_[0] &= ~0x00000008u;
6336}
6337inline void DatanodeIDProto::clear_xferport() {
6338 xferport_ = 0u;
6339 clear_has_xferport();
6340}
6341inline ::google::protobuf::uint32 DatanodeIDProto::xferport() const {
6342 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeIDProto.xferPort)
6343 return xferport_;
6344}
6345inline void DatanodeIDProto::set_xferport(::google::protobuf::uint32 value) {
6346 set_has_xferport();
6347 xferport_ = value;
6348 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeIDProto.xferPort)
6349}
6350
6351// required uint32 infoPort = 5;
6352inline bool DatanodeIDProto::has_infoport() const {
6353 return (_has_bits_[0] & 0x00000010u) != 0;
6354}
6355inline void DatanodeIDProto::set_has_infoport() {
6356 _has_bits_[0] |= 0x00000010u;
6357}
6358inline void DatanodeIDProto::clear_has_infoport() {
6359 _has_bits_[0] &= ~0x00000010u;
6360}
6361inline void DatanodeIDProto::clear_infoport() {
6362 infoport_ = 0u;
6363 clear_has_infoport();
6364}
6365inline ::google::protobuf::uint32 DatanodeIDProto::infoport() const {
6366 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeIDProto.infoPort)
6367 return infoport_;
6368}
6369inline void DatanodeIDProto::set_infoport(::google::protobuf::uint32 value) {
6370 set_has_infoport();
6371 infoport_ = value;
6372 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeIDProto.infoPort)
6373}
6374
6375// required uint32 ipcPort = 6;
6376inline bool DatanodeIDProto::has_ipcport() const {
6377 return (_has_bits_[0] & 0x00000020u) != 0;
6378}
6379inline void DatanodeIDProto::set_has_ipcport() {
6380 _has_bits_[0] |= 0x00000020u;
6381}
6382inline void DatanodeIDProto::clear_has_ipcport() {
6383 _has_bits_[0] &= ~0x00000020u;
6384}
6385inline void DatanodeIDProto::clear_ipcport() {
6386 ipcport_ = 0u;
6387 clear_has_ipcport();
6388}
6389inline ::google::protobuf::uint32 DatanodeIDProto::ipcport() const {
6390 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeIDProto.ipcPort)
6391 return ipcport_;
6392}
6393inline void DatanodeIDProto::set_ipcport(::google::protobuf::uint32 value) {
6394 set_has_ipcport();
6395 ipcport_ = value;
6396 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeIDProto.ipcPort)
6397}
6398
6399// optional uint32 infoSecurePort = 7 [default = 0];
6400inline bool DatanodeIDProto::has_infosecureport() const {
6401 return (_has_bits_[0] & 0x00000040u) != 0;
6402}
6403inline void DatanodeIDProto::set_has_infosecureport() {
6404 _has_bits_[0] |= 0x00000040u;
6405}
6406inline void DatanodeIDProto::clear_has_infosecureport() {
6407 _has_bits_[0] &= ~0x00000040u;
6408}
6409inline void DatanodeIDProto::clear_infosecureport() {
6410 infosecureport_ = 0u;
6411 clear_has_infosecureport();
6412}
6413inline ::google::protobuf::uint32 DatanodeIDProto::infosecureport() const {
6414 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeIDProto.infoSecurePort)
6415 return infosecureport_;
6416}
6417inline void DatanodeIDProto::set_infosecureport(::google::protobuf::uint32 value) {
6418 set_has_infosecureport();
6419 infosecureport_ = value;
6420 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeIDProto.infoSecurePort)
6421}
6422
6423// -------------------------------------------------------------------
6424
6425// DatanodeInfosProto
6426
6427// repeated .Hdfs.Internal.DatanodeInfoProto datanodes = 1;
6428inline int DatanodeInfosProto::datanodes_size() const {
6429 return datanodes_.size();
6430}
6431inline void DatanodeInfosProto::clear_datanodes() {
6432 datanodes_.Clear();
6433}
6434inline ::Hdfs::Internal::DatanodeInfoProto* DatanodeInfosProto::mutable_datanodes(int index) {
6435 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DatanodeInfosProto.datanodes)
6436 return datanodes_.Mutable(index);
6437}
6438inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >*
6439DatanodeInfosProto::mutable_datanodes() {
6440 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.DatanodeInfosProto.datanodes)
6441 return &datanodes_;
6442}
6443inline const ::Hdfs::Internal::DatanodeInfoProto& DatanodeInfosProto::datanodes(int index) const {
6444 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfosProto.datanodes)
6445 return datanodes_.Get(index);
6446}
6447inline ::Hdfs::Internal::DatanodeInfoProto* DatanodeInfosProto::add_datanodes() {
6448 // @@protoc_insertion_point(field_add:Hdfs.Internal.DatanodeInfosProto.datanodes)
6449 return datanodes_.Add();
6450}
6451inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >&
6452DatanodeInfosProto::datanodes() const {
6453 // @@protoc_insertion_point(field_list:Hdfs.Internal.DatanodeInfosProto.datanodes)
6454 return datanodes_;
6455}
6456
6457// -------------------------------------------------------------------
6458
6459// DatanodeInfoProto
6460
6461// required .Hdfs.Internal.DatanodeIDProto id = 1;
6462inline bool DatanodeInfoProto::has_id() const {
6463 return (_has_bits_[0] & 0x00000002u) != 0;
6464}
6465inline void DatanodeInfoProto::set_has_id() {
6466 _has_bits_[0] |= 0x00000002u;
6467}
6468inline void DatanodeInfoProto::clear_has_id() {
6469 _has_bits_[0] &= ~0x00000002u;
6470}
6471inline void DatanodeInfoProto::clear_id() {
6472 if (id_ != NULL) id_->Clear();
6473 clear_has_id();
6474}
6475inline const ::Hdfs::Internal::DatanodeIDProto& DatanodeInfoProto::_internal_id() const {
6476 return *id_;
6477}
6478inline const ::Hdfs::Internal::DatanodeIDProto& DatanodeInfoProto::id() const {
6479 const ::Hdfs::Internal::DatanodeIDProto* p = id_;
6480 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.id)
6481 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::DatanodeIDProto*>(
6482 &::Hdfs::Internal::_DatanodeIDProto_default_instance_);
6483}
6484inline ::Hdfs::Internal::DatanodeIDProto* DatanodeInfoProto::release_id() {
6485 // @@protoc_insertion_point(field_release:Hdfs.Internal.DatanodeInfoProto.id)
6486 clear_has_id();
6487 ::Hdfs::Internal::DatanodeIDProto* temp = id_;
6488 id_ = NULL;
6489 return temp;
6490}
6491inline ::Hdfs::Internal::DatanodeIDProto* DatanodeInfoProto::mutable_id() {
6492 set_has_id();
6493 if (id_ == NULL) {
6494 auto* p = CreateMaybeMessage<::Hdfs::Internal::DatanodeIDProto>(GetArenaNoVirtual());
6495 id_ = p;
6496 }
6497 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DatanodeInfoProto.id)
6498 return id_;
6499}
6500inline void DatanodeInfoProto::set_allocated_id(::Hdfs::Internal::DatanodeIDProto* id) {
6501 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
6502 if (message_arena == NULL) {
6503 delete id_;
6504 }
6505 if (id) {
6506 ::google::protobuf::Arena* submessage_arena = NULL;
6507 if (message_arena != submessage_arena) {
6508 id = ::google::protobuf::internal::GetOwnedMessage(
6509 message_arena, id, submessage_arena);
6510 }
6511 set_has_id();
6512 } else {
6513 clear_has_id();
6514 }
6515 id_ = id;
6516 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DatanodeInfoProto.id)
6517}
6518
6519// optional uint64 capacity = 2 [default = 0];
6520inline bool DatanodeInfoProto::has_capacity() const {
6521 return (_has_bits_[0] & 0x00000004u) != 0;
6522}
6523inline void DatanodeInfoProto::set_has_capacity() {
6524 _has_bits_[0] |= 0x00000004u;
6525}
6526inline void DatanodeInfoProto::clear_has_capacity() {
6527 _has_bits_[0] &= ~0x00000004u;
6528}
6529inline void DatanodeInfoProto::clear_capacity() {
6530 capacity_ = GOOGLE_ULONGLONG(0);
6531 clear_has_capacity();
6532}
6533inline ::google::protobuf::uint64 DatanodeInfoProto::capacity() const {
6534 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.capacity)
6535 return capacity_;
6536}
6537inline void DatanodeInfoProto::set_capacity(::google::protobuf::uint64 value) {
6538 set_has_capacity();
6539 capacity_ = value;
6540 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.capacity)
6541}
6542
6543// optional uint64 dfsUsed = 3 [default = 0];
6544inline bool DatanodeInfoProto::has_dfsused() const {
6545 return (_has_bits_[0] & 0x00000008u) != 0;
6546}
6547inline void DatanodeInfoProto::set_has_dfsused() {
6548 _has_bits_[0] |= 0x00000008u;
6549}
6550inline void DatanodeInfoProto::clear_has_dfsused() {
6551 _has_bits_[0] &= ~0x00000008u;
6552}
6553inline void DatanodeInfoProto::clear_dfsused() {
6554 dfsused_ = GOOGLE_ULONGLONG(0);
6555 clear_has_dfsused();
6556}
6557inline ::google::protobuf::uint64 DatanodeInfoProto::dfsused() const {
6558 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.dfsUsed)
6559 return dfsused_;
6560}
6561inline void DatanodeInfoProto::set_dfsused(::google::protobuf::uint64 value) {
6562 set_has_dfsused();
6563 dfsused_ = value;
6564 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.dfsUsed)
6565}
6566
6567// optional uint64 remaining = 4 [default = 0];
6568inline bool DatanodeInfoProto::has_remaining() const {
6569 return (_has_bits_[0] & 0x00000010u) != 0;
6570}
6571inline void DatanodeInfoProto::set_has_remaining() {
6572 _has_bits_[0] |= 0x00000010u;
6573}
6574inline void DatanodeInfoProto::clear_has_remaining() {
6575 _has_bits_[0] &= ~0x00000010u;
6576}
6577inline void DatanodeInfoProto::clear_remaining() {
6578 remaining_ = GOOGLE_ULONGLONG(0);
6579 clear_has_remaining();
6580}
6581inline ::google::protobuf::uint64 DatanodeInfoProto::remaining() const {
6582 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.remaining)
6583 return remaining_;
6584}
6585inline void DatanodeInfoProto::set_remaining(::google::protobuf::uint64 value) {
6586 set_has_remaining();
6587 remaining_ = value;
6588 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.remaining)
6589}
6590
6591// optional uint64 blockPoolUsed = 5 [default = 0];
6592inline bool DatanodeInfoProto::has_blockpoolused() const {
6593 return (_has_bits_[0] & 0x00000020u) != 0;
6594}
6595inline void DatanodeInfoProto::set_has_blockpoolused() {
6596 _has_bits_[0] |= 0x00000020u;
6597}
6598inline void DatanodeInfoProto::clear_has_blockpoolused() {
6599 _has_bits_[0] &= ~0x00000020u;
6600}
6601inline void DatanodeInfoProto::clear_blockpoolused() {
6602 blockpoolused_ = GOOGLE_ULONGLONG(0);
6603 clear_has_blockpoolused();
6604}
6605inline ::google::protobuf::uint64 DatanodeInfoProto::blockpoolused() const {
6606 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.blockPoolUsed)
6607 return blockpoolused_;
6608}
6609inline void DatanodeInfoProto::set_blockpoolused(::google::protobuf::uint64 value) {
6610 set_has_blockpoolused();
6611 blockpoolused_ = value;
6612 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.blockPoolUsed)
6613}
6614
6615// optional uint64 lastUpdate = 6 [default = 0];
6616inline bool DatanodeInfoProto::has_lastupdate() const {
6617 return (_has_bits_[0] & 0x00000040u) != 0;
6618}
6619inline void DatanodeInfoProto::set_has_lastupdate() {
6620 _has_bits_[0] |= 0x00000040u;
6621}
6622inline void DatanodeInfoProto::clear_has_lastupdate() {
6623 _has_bits_[0] &= ~0x00000040u;
6624}
6625inline void DatanodeInfoProto::clear_lastupdate() {
6626 lastupdate_ = GOOGLE_ULONGLONG(0);
6627 clear_has_lastupdate();
6628}
6629inline ::google::protobuf::uint64 DatanodeInfoProto::lastupdate() const {
6630 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.lastUpdate)
6631 return lastupdate_;
6632}
6633inline void DatanodeInfoProto::set_lastupdate(::google::protobuf::uint64 value) {
6634 set_has_lastupdate();
6635 lastupdate_ = value;
6636 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.lastUpdate)
6637}
6638
6639// optional uint32 xceiverCount = 7 [default = 0];
6640inline bool DatanodeInfoProto::has_xceivercount() const {
6641 return (_has_bits_[0] & 0x00000080u) != 0;
6642}
6643inline void DatanodeInfoProto::set_has_xceivercount() {
6644 _has_bits_[0] |= 0x00000080u;
6645}
6646inline void DatanodeInfoProto::clear_has_xceivercount() {
6647 _has_bits_[0] &= ~0x00000080u;
6648}
6649inline void DatanodeInfoProto::clear_xceivercount() {
6650 xceivercount_ = 0u;
6651 clear_has_xceivercount();
6652}
6653inline ::google::protobuf::uint32 DatanodeInfoProto::xceivercount() const {
6654 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.xceiverCount)
6655 return xceivercount_;
6656}
6657inline void DatanodeInfoProto::set_xceivercount(::google::protobuf::uint32 value) {
6658 set_has_xceivercount();
6659 xceivercount_ = value;
6660 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.xceiverCount)
6661}
6662
6663// optional string location = 8;
6664inline bool DatanodeInfoProto::has_location() const {
6665 return (_has_bits_[0] & 0x00000001u) != 0;
6666}
6667inline void DatanodeInfoProto::set_has_location() {
6668 _has_bits_[0] |= 0x00000001u;
6669}
6670inline void DatanodeInfoProto::clear_has_location() {
6671 _has_bits_[0] &= ~0x00000001u;
6672}
6673inline void DatanodeInfoProto::clear_location() {
6674 location_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6675 clear_has_location();
6676}
6677inline const ::std::string& DatanodeInfoProto::location() const {
6678 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.location)
6679 return location_.GetNoArena();
6680}
6681inline void DatanodeInfoProto::set_location(const ::std::string& value) {
6682 set_has_location();
6683 location_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
6684 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.location)
6685}
6686#if LANG_CXX11
6687inline void DatanodeInfoProto::set_location(::std::string&& value) {
6688 set_has_location();
6689 location_.SetNoArena(
6690 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6691 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DatanodeInfoProto.location)
6692}
6693#endif
6694inline void DatanodeInfoProto::set_location(const char* value) {
6695 GOOGLE_DCHECK(value != NULL);
6696 set_has_location();
6697 location_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6698 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DatanodeInfoProto.location)
6699}
6700inline void DatanodeInfoProto::set_location(const char* value, size_t size) {
6701 set_has_location();
6702 location_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
6703 ::std::string(reinterpret_cast<const char*>(value), size));
6704 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DatanodeInfoProto.location)
6705}
6706inline ::std::string* DatanodeInfoProto::mutable_location() {
6707 set_has_location();
6708 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DatanodeInfoProto.location)
6709 return location_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6710}
6711inline ::std::string* DatanodeInfoProto::release_location() {
6712 // @@protoc_insertion_point(field_release:Hdfs.Internal.DatanodeInfoProto.location)
6713 if (!has_location()) {
6714 return NULL;
6715 }
6716 clear_has_location();
6717 return location_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6718}
6719inline void DatanodeInfoProto::set_allocated_location(::std::string* location) {
6720 if (location != NULL) {
6721 set_has_location();
6722 } else {
6723 clear_has_location();
6724 }
6725 location_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), location);
6726 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DatanodeInfoProto.location)
6727}
6728
6729// optional .Hdfs.Internal.DatanodeInfoProto.AdminState adminState = 10 [default = NORMAL];
6730inline bool DatanodeInfoProto::has_adminstate() const {
6731 return (_has_bits_[0] & 0x00000100u) != 0;
6732}
6733inline void DatanodeInfoProto::set_has_adminstate() {
6734 _has_bits_[0] |= 0x00000100u;
6735}
6736inline void DatanodeInfoProto::clear_has_adminstate() {
6737 _has_bits_[0] &= ~0x00000100u;
6738}
6739inline void DatanodeInfoProto::clear_adminstate() {
6740 adminstate_ = 0;
6741 clear_has_adminstate();
6742}
6743inline ::Hdfs::Internal::DatanodeInfoProto_AdminState DatanodeInfoProto::adminstate() const {
6744 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.adminState)
6745 return static_cast< ::Hdfs::Internal::DatanodeInfoProto_AdminState >(adminstate_);
6746}
6747inline void DatanodeInfoProto::set_adminstate(::Hdfs::Internal::DatanodeInfoProto_AdminState value) {
6748 assert(::Hdfs::Internal::DatanodeInfoProto_AdminState_IsValid(value));
6749 set_has_adminstate();
6750 adminstate_ = value;
6751 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.adminState)
6752}
6753
6754// optional uint64 cacheCapacity = 11 [default = 0];
6755inline bool DatanodeInfoProto::has_cachecapacity() const {
6756 return (_has_bits_[0] & 0x00000200u) != 0;
6757}
6758inline void DatanodeInfoProto::set_has_cachecapacity() {
6759 _has_bits_[0] |= 0x00000200u;
6760}
6761inline void DatanodeInfoProto::clear_has_cachecapacity() {
6762 _has_bits_[0] &= ~0x00000200u;
6763}
6764inline void DatanodeInfoProto::clear_cachecapacity() {
6765 cachecapacity_ = GOOGLE_ULONGLONG(0);
6766 clear_has_cachecapacity();
6767}
6768inline ::google::protobuf::uint64 DatanodeInfoProto::cachecapacity() const {
6769 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.cacheCapacity)
6770 return cachecapacity_;
6771}
6772inline void DatanodeInfoProto::set_cachecapacity(::google::protobuf::uint64 value) {
6773 set_has_cachecapacity();
6774 cachecapacity_ = value;
6775 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.cacheCapacity)
6776}
6777
6778// optional uint64 cacheUsed = 12 [default = 0];
6779inline bool DatanodeInfoProto::has_cacheused() const {
6780 return (_has_bits_[0] & 0x00000400u) != 0;
6781}
6782inline void DatanodeInfoProto::set_has_cacheused() {
6783 _has_bits_[0] |= 0x00000400u;
6784}
6785inline void DatanodeInfoProto::clear_has_cacheused() {
6786 _has_bits_[0] &= ~0x00000400u;
6787}
6788inline void DatanodeInfoProto::clear_cacheused() {
6789 cacheused_ = GOOGLE_ULONGLONG(0);
6790 clear_has_cacheused();
6791}
6792inline ::google::protobuf::uint64 DatanodeInfoProto::cacheused() const {
6793 // @@protoc_insertion_point(field_get:Hdfs.Internal.DatanodeInfoProto.cacheUsed)
6794 return cacheused_;
6795}
6796inline void DatanodeInfoProto::set_cacheused(::google::protobuf::uint64 value) {
6797 set_has_cacheused();
6798 cacheused_ = value;
6799 // @@protoc_insertion_point(field_set:Hdfs.Internal.DatanodeInfoProto.cacheUsed)
6800}
6801
6802// -------------------------------------------------------------------
6803
6804// ContentSummaryProto
6805
6806// required uint64 length = 1;
6807inline bool ContentSummaryProto::has_length() const {
6808 return (_has_bits_[0] & 0x00000001u) != 0;
6809}
6810inline void ContentSummaryProto::set_has_length() {
6811 _has_bits_[0] |= 0x00000001u;
6812}
6813inline void ContentSummaryProto::clear_has_length() {
6814 _has_bits_[0] &= ~0x00000001u;
6815}
6816inline void ContentSummaryProto::clear_length() {
6817 length_ = GOOGLE_ULONGLONG(0);
6818 clear_has_length();
6819}
6820inline ::google::protobuf::uint64 ContentSummaryProto::length() const {
6821 // @@protoc_insertion_point(field_get:Hdfs.Internal.ContentSummaryProto.length)
6822 return length_;
6823}
6824inline void ContentSummaryProto::set_length(::google::protobuf::uint64 value) {
6825 set_has_length();
6826 length_ = value;
6827 // @@protoc_insertion_point(field_set:Hdfs.Internal.ContentSummaryProto.length)
6828}
6829
6830// required uint64 fileCount = 2;
6831inline bool ContentSummaryProto::has_filecount() const {
6832 return (_has_bits_[0] & 0x00000002u) != 0;
6833}
6834inline void ContentSummaryProto::set_has_filecount() {
6835 _has_bits_[0] |= 0x00000002u;
6836}
6837inline void ContentSummaryProto::clear_has_filecount() {
6838 _has_bits_[0] &= ~0x00000002u;
6839}
6840inline void ContentSummaryProto::clear_filecount() {
6841 filecount_ = GOOGLE_ULONGLONG(0);
6842 clear_has_filecount();
6843}
6844inline ::google::protobuf::uint64 ContentSummaryProto::filecount() const {
6845 // @@protoc_insertion_point(field_get:Hdfs.Internal.ContentSummaryProto.fileCount)
6846 return filecount_;
6847}
6848inline void ContentSummaryProto::set_filecount(::google::protobuf::uint64 value) {
6849 set_has_filecount();
6850 filecount_ = value;
6851 // @@protoc_insertion_point(field_set:Hdfs.Internal.ContentSummaryProto.fileCount)
6852}
6853
6854// required uint64 directoryCount = 3;
6855inline bool ContentSummaryProto::has_directorycount() const {
6856 return (_has_bits_[0] & 0x00000004u) != 0;
6857}
6858inline void ContentSummaryProto::set_has_directorycount() {
6859 _has_bits_[0] |= 0x00000004u;
6860}
6861inline void ContentSummaryProto::clear_has_directorycount() {
6862 _has_bits_[0] &= ~0x00000004u;
6863}
6864inline void ContentSummaryProto::clear_directorycount() {
6865 directorycount_ = GOOGLE_ULONGLONG(0);
6866 clear_has_directorycount();
6867}
6868inline ::google::protobuf::uint64 ContentSummaryProto::directorycount() const {
6869 // @@protoc_insertion_point(field_get:Hdfs.Internal.ContentSummaryProto.directoryCount)
6870 return directorycount_;
6871}
6872inline void ContentSummaryProto::set_directorycount(::google::protobuf::uint64 value) {
6873 set_has_directorycount();
6874 directorycount_ = value;
6875 // @@protoc_insertion_point(field_set:Hdfs.Internal.ContentSummaryProto.directoryCount)
6876}
6877
6878// required uint64 quota = 4;
6879inline bool ContentSummaryProto::has_quota() const {
6880 return (_has_bits_[0] & 0x00000008u) != 0;
6881}
6882inline void ContentSummaryProto::set_has_quota() {
6883 _has_bits_[0] |= 0x00000008u;
6884}
6885inline void ContentSummaryProto::clear_has_quota() {
6886 _has_bits_[0] &= ~0x00000008u;
6887}
6888inline void ContentSummaryProto::clear_quota() {
6889 quota_ = GOOGLE_ULONGLONG(0);
6890 clear_has_quota();
6891}
6892inline ::google::protobuf::uint64 ContentSummaryProto::quota() const {
6893 // @@protoc_insertion_point(field_get:Hdfs.Internal.ContentSummaryProto.quota)
6894 return quota_;
6895}
6896inline void ContentSummaryProto::set_quota(::google::protobuf::uint64 value) {
6897 set_has_quota();
6898 quota_ = value;
6899 // @@protoc_insertion_point(field_set:Hdfs.Internal.ContentSummaryProto.quota)
6900}
6901
6902// required uint64 spaceConsumed = 5;
6903inline bool ContentSummaryProto::has_spaceconsumed() const {
6904 return (_has_bits_[0] & 0x00000010u) != 0;
6905}
6906inline void ContentSummaryProto::set_has_spaceconsumed() {
6907 _has_bits_[0] |= 0x00000010u;
6908}
6909inline void ContentSummaryProto::clear_has_spaceconsumed() {
6910 _has_bits_[0] &= ~0x00000010u;
6911}
6912inline void ContentSummaryProto::clear_spaceconsumed() {
6913 spaceconsumed_ = GOOGLE_ULONGLONG(0);
6914 clear_has_spaceconsumed();
6915}
6916inline ::google::protobuf::uint64 ContentSummaryProto::spaceconsumed() const {
6917 // @@protoc_insertion_point(field_get:Hdfs.Internal.ContentSummaryProto.spaceConsumed)
6918 return spaceconsumed_;
6919}
6920inline void ContentSummaryProto::set_spaceconsumed(::google::protobuf::uint64 value) {
6921 set_has_spaceconsumed();
6922 spaceconsumed_ = value;
6923 // @@protoc_insertion_point(field_set:Hdfs.Internal.ContentSummaryProto.spaceConsumed)
6924}
6925
6926// required uint64 spaceQuota = 6;
6927inline bool ContentSummaryProto::has_spacequota() const {
6928 return (_has_bits_[0] & 0x00000020u) != 0;
6929}
6930inline void ContentSummaryProto::set_has_spacequota() {
6931 _has_bits_[0] |= 0x00000020u;
6932}
6933inline void ContentSummaryProto::clear_has_spacequota() {
6934 _has_bits_[0] &= ~0x00000020u;
6935}
6936inline void ContentSummaryProto::clear_spacequota() {
6937 spacequota_ = GOOGLE_ULONGLONG(0);
6938 clear_has_spacequota();
6939}
6940inline ::google::protobuf::uint64 ContentSummaryProto::spacequota() const {
6941 // @@protoc_insertion_point(field_get:Hdfs.Internal.ContentSummaryProto.spaceQuota)
6942 return spacequota_;
6943}
6944inline void ContentSummaryProto::set_spacequota(::google::protobuf::uint64 value) {
6945 set_has_spacequota();
6946 spacequota_ = value;
6947 // @@protoc_insertion_point(field_set:Hdfs.Internal.ContentSummaryProto.spaceQuota)
6948}
6949
6950// -------------------------------------------------------------------
6951
6952// CorruptFileBlocksProto
6953
6954// repeated string files = 1;
6955inline int CorruptFileBlocksProto::files_size() const {
6956 return files_.size();
6957}
6958inline void CorruptFileBlocksProto::clear_files() {
6959 files_.Clear();
6960}
6961inline const ::std::string& CorruptFileBlocksProto::files(int index) const {
6962 // @@protoc_insertion_point(field_get:Hdfs.Internal.CorruptFileBlocksProto.files)
6963 return files_.Get(index);
6964}
6965inline ::std::string* CorruptFileBlocksProto::mutable_files(int index) {
6966 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.CorruptFileBlocksProto.files)
6967 return files_.Mutable(index);
6968}
6969inline void CorruptFileBlocksProto::set_files(int index, const ::std::string& value) {
6970 // @@protoc_insertion_point(field_set:Hdfs.Internal.CorruptFileBlocksProto.files)
6971 files_.Mutable(index)->assign(value);
6972}
6973#if LANG_CXX11
6974inline void CorruptFileBlocksProto::set_files(int index, ::std::string&& value) {
6975 // @@protoc_insertion_point(field_set:Hdfs.Internal.CorruptFileBlocksProto.files)
6976 files_.Mutable(index)->assign(std::move(value));
6977}
6978#endif
6979inline void CorruptFileBlocksProto::set_files(int index, const char* value) {
6980 GOOGLE_DCHECK(value != NULL);
6981 files_.Mutable(index)->assign(value);
6982 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.CorruptFileBlocksProto.files)
6983}
6984inline void CorruptFileBlocksProto::set_files(int index, const char* value, size_t size) {
6985 files_.Mutable(index)->assign(
6986 reinterpret_cast<const char*>(value), size);
6987 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.CorruptFileBlocksProto.files)
6988}
6989inline ::std::string* CorruptFileBlocksProto::add_files() {
6990 // @@protoc_insertion_point(field_add_mutable:Hdfs.Internal.CorruptFileBlocksProto.files)
6991 return files_.Add();
6992}
6993inline void CorruptFileBlocksProto::add_files(const ::std::string& value) {
6994 files_.Add()->assign(value);
6995 // @@protoc_insertion_point(field_add:Hdfs.Internal.CorruptFileBlocksProto.files)
6996}
6997#if LANG_CXX11
6998inline void CorruptFileBlocksProto::add_files(::std::string&& value) {
6999 files_.Add(std::move(value));
7000 // @@protoc_insertion_point(field_add:Hdfs.Internal.CorruptFileBlocksProto.files)
7001}
7002#endif
7003inline void CorruptFileBlocksProto::add_files(const char* value) {
7004 GOOGLE_DCHECK(value != NULL);
7005 files_.Add()->assign(value);
7006 // @@protoc_insertion_point(field_add_char:Hdfs.Internal.CorruptFileBlocksProto.files)
7007}
7008inline void CorruptFileBlocksProto::add_files(const char* value, size_t size) {
7009 files_.Add()->assign(reinterpret_cast<const char*>(value), size);
7010 // @@protoc_insertion_point(field_add_pointer:Hdfs.Internal.CorruptFileBlocksProto.files)
7011}
7012inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
7013CorruptFileBlocksProto::files() const {
7014 // @@protoc_insertion_point(field_list:Hdfs.Internal.CorruptFileBlocksProto.files)
7015 return files_;
7016}
7017inline ::google::protobuf::RepeatedPtrField< ::std::string>*
7018CorruptFileBlocksProto::mutable_files() {
7019 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.CorruptFileBlocksProto.files)
7020 return &files_;
7021}
7022
7023// required string cookie = 2;
7024inline bool CorruptFileBlocksProto::has_cookie() const {
7025 return (_has_bits_[0] & 0x00000001u) != 0;
7026}
7027inline void CorruptFileBlocksProto::set_has_cookie() {
7028 _has_bits_[0] |= 0x00000001u;
7029}
7030inline void CorruptFileBlocksProto::clear_has_cookie() {
7031 _has_bits_[0] &= ~0x00000001u;
7032}
7033inline void CorruptFileBlocksProto::clear_cookie() {
7034 cookie_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7035 clear_has_cookie();
7036}
7037inline const ::std::string& CorruptFileBlocksProto::cookie() const {
7038 // @@protoc_insertion_point(field_get:Hdfs.Internal.CorruptFileBlocksProto.cookie)
7039 return cookie_.GetNoArena();
7040}
7041inline void CorruptFileBlocksProto::set_cookie(const ::std::string& value) {
7042 set_has_cookie();
7043 cookie_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
7044 // @@protoc_insertion_point(field_set:Hdfs.Internal.CorruptFileBlocksProto.cookie)
7045}
7046#if LANG_CXX11
7047inline void CorruptFileBlocksProto::set_cookie(::std::string&& value) {
7048 set_has_cookie();
7049 cookie_.SetNoArena(
7050 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7051 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.CorruptFileBlocksProto.cookie)
7052}
7053#endif
7054inline void CorruptFileBlocksProto::set_cookie(const char* value) {
7055 GOOGLE_DCHECK(value != NULL);
7056 set_has_cookie();
7057 cookie_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7058 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.CorruptFileBlocksProto.cookie)
7059}
7060inline void CorruptFileBlocksProto::set_cookie(const char* value, size_t size) {
7061 set_has_cookie();
7062 cookie_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
7063 ::std::string(reinterpret_cast<const char*>(value), size));
7064 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.CorruptFileBlocksProto.cookie)
7065}
7066inline ::std::string* CorruptFileBlocksProto::mutable_cookie() {
7067 set_has_cookie();
7068 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.CorruptFileBlocksProto.cookie)
7069 return cookie_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7070}
7071inline ::std::string* CorruptFileBlocksProto::release_cookie() {
7072 // @@protoc_insertion_point(field_release:Hdfs.Internal.CorruptFileBlocksProto.cookie)
7073 if (!has_cookie()) {
7074 return NULL;
7075 }
7076 clear_has_cookie();
7077 return cookie_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7078}
7079inline void CorruptFileBlocksProto::set_allocated_cookie(::std::string* cookie) {
7080 if (cookie != NULL) {
7081 set_has_cookie();
7082 } else {
7083 clear_has_cookie();
7084 }
7085 cookie_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), cookie);
7086 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.CorruptFileBlocksProto.cookie)
7087}
7088
7089// -------------------------------------------------------------------
7090
7091// FsPermissionProto
7092
7093// required uint32 perm = 1;
7094inline bool FsPermissionProto::has_perm() const {
7095 return (_has_bits_[0] & 0x00000001u) != 0;
7096}
7097inline void FsPermissionProto::set_has_perm() {
7098 _has_bits_[0] |= 0x00000001u;
7099}
7100inline void FsPermissionProto::clear_has_perm() {
7101 _has_bits_[0] &= ~0x00000001u;
7102}
7103inline void FsPermissionProto::clear_perm() {
7104 perm_ = 0u;
7105 clear_has_perm();
7106}
7107inline ::google::protobuf::uint32 FsPermissionProto::perm() const {
7108 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsPermissionProto.perm)
7109 return perm_;
7110}
7111inline void FsPermissionProto::set_perm(::google::protobuf::uint32 value) {
7112 set_has_perm();
7113 perm_ = value;
7114 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsPermissionProto.perm)
7115}
7116
7117// -------------------------------------------------------------------
7118
7119// StorageUuidsProto
7120
7121// repeated string storageUuids = 1;
7122inline int StorageUuidsProto::storageuuids_size() const {
7123 return storageuuids_.size();
7124}
7125inline void StorageUuidsProto::clear_storageuuids() {
7126 storageuuids_.Clear();
7127}
7128inline const ::std::string& StorageUuidsProto::storageuuids(int index) const {
7129 // @@protoc_insertion_point(field_get:Hdfs.Internal.StorageUuidsProto.storageUuids)
7130 return storageuuids_.Get(index);
7131}
7132inline ::std::string* StorageUuidsProto::mutable_storageuuids(int index) {
7133 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.StorageUuidsProto.storageUuids)
7134 return storageuuids_.Mutable(index);
7135}
7136inline void StorageUuidsProto::set_storageuuids(int index, const ::std::string& value) {
7137 // @@protoc_insertion_point(field_set:Hdfs.Internal.StorageUuidsProto.storageUuids)
7138 storageuuids_.Mutable(index)->assign(value);
7139}
7140#if LANG_CXX11
7141inline void StorageUuidsProto::set_storageuuids(int index, ::std::string&& value) {
7142 // @@protoc_insertion_point(field_set:Hdfs.Internal.StorageUuidsProto.storageUuids)
7143 storageuuids_.Mutable(index)->assign(std::move(value));
7144}
7145#endif
7146inline void StorageUuidsProto::set_storageuuids(int index, const char* value) {
7147 GOOGLE_DCHECK(value != NULL);
7148 storageuuids_.Mutable(index)->assign(value);
7149 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.StorageUuidsProto.storageUuids)
7150}
7151inline void StorageUuidsProto::set_storageuuids(int index, const char* value, size_t size) {
7152 storageuuids_.Mutable(index)->assign(
7153 reinterpret_cast<const char*>(value), size);
7154 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.StorageUuidsProto.storageUuids)
7155}
7156inline ::std::string* StorageUuidsProto::add_storageuuids() {
7157 // @@protoc_insertion_point(field_add_mutable:Hdfs.Internal.StorageUuidsProto.storageUuids)
7158 return storageuuids_.Add();
7159}
7160inline void StorageUuidsProto::add_storageuuids(const ::std::string& value) {
7161 storageuuids_.Add()->assign(value);
7162 // @@protoc_insertion_point(field_add:Hdfs.Internal.StorageUuidsProto.storageUuids)
7163}
7164#if LANG_CXX11
7165inline void StorageUuidsProto::add_storageuuids(::std::string&& value) {
7166 storageuuids_.Add(std::move(value));
7167 // @@protoc_insertion_point(field_add:Hdfs.Internal.StorageUuidsProto.storageUuids)
7168}
7169#endif
7170inline void StorageUuidsProto::add_storageuuids(const char* value) {
7171 GOOGLE_DCHECK(value != NULL);
7172 storageuuids_.Add()->assign(value);
7173 // @@protoc_insertion_point(field_add_char:Hdfs.Internal.StorageUuidsProto.storageUuids)
7174}
7175inline void StorageUuidsProto::add_storageuuids(const char* value, size_t size) {
7176 storageuuids_.Add()->assign(reinterpret_cast<const char*>(value), size);
7177 // @@protoc_insertion_point(field_add_pointer:Hdfs.Internal.StorageUuidsProto.storageUuids)
7178}
7179inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
7180StorageUuidsProto::storageuuids() const {
7181 // @@protoc_insertion_point(field_list:Hdfs.Internal.StorageUuidsProto.storageUuids)
7182 return storageuuids_;
7183}
7184inline ::google::protobuf::RepeatedPtrField< ::std::string>*
7185StorageUuidsProto::mutable_storageuuids() {
7186 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.StorageUuidsProto.storageUuids)
7187 return &storageuuids_;
7188}
7189
7190// -------------------------------------------------------------------
7191
7192// LocatedBlockProto
7193
7194// required .Hdfs.Internal.ExtendedBlockProto b = 1;
7195inline bool LocatedBlockProto::has_b() const {
7196 return (_has_bits_[0] & 0x00000001u) != 0;
7197}
7198inline void LocatedBlockProto::set_has_b() {
7199 _has_bits_[0] |= 0x00000001u;
7200}
7201inline void LocatedBlockProto::clear_has_b() {
7202 _has_bits_[0] &= ~0x00000001u;
7203}
7204inline void LocatedBlockProto::clear_b() {
7205 if (b_ != NULL) b_->Clear();
7206 clear_has_b();
7207}
7208inline const ::Hdfs::Internal::ExtendedBlockProto& LocatedBlockProto::_internal_b() const {
7209 return *b_;
7210}
7211inline const ::Hdfs::Internal::ExtendedBlockProto& LocatedBlockProto::b() const {
7212 const ::Hdfs::Internal::ExtendedBlockProto* p = b_;
7213 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlockProto.b)
7214 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ExtendedBlockProto*>(
7215 &::Hdfs::Internal::_ExtendedBlockProto_default_instance_);
7216}
7217inline ::Hdfs::Internal::ExtendedBlockProto* LocatedBlockProto::release_b() {
7218 // @@protoc_insertion_point(field_release:Hdfs.Internal.LocatedBlockProto.b)
7219 clear_has_b();
7220 ::Hdfs::Internal::ExtendedBlockProto* temp = b_;
7221 b_ = NULL;
7222 return temp;
7223}
7224inline ::Hdfs::Internal::ExtendedBlockProto* LocatedBlockProto::mutable_b() {
7225 set_has_b();
7226 if (b_ == NULL) {
7227 auto* p = CreateMaybeMessage<::Hdfs::Internal::ExtendedBlockProto>(GetArenaNoVirtual());
7228 b_ = p;
7229 }
7230 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.LocatedBlockProto.b)
7231 return b_;
7232}
7233inline void LocatedBlockProto::set_allocated_b(::Hdfs::Internal::ExtendedBlockProto* b) {
7234 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
7235 if (message_arena == NULL) {
7236 delete b_;
7237 }
7238 if (b) {
7239 ::google::protobuf::Arena* submessage_arena = NULL;
7240 if (message_arena != submessage_arena) {
7241 b = ::google::protobuf::internal::GetOwnedMessage(
7242 message_arena, b, submessage_arena);
7243 }
7244 set_has_b();
7245 } else {
7246 clear_has_b();
7247 }
7248 b_ = b;
7249 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.LocatedBlockProto.b)
7250}
7251
7252// required uint64 offset = 2;
7253inline bool LocatedBlockProto::has_offset() const {
7254 return (_has_bits_[0] & 0x00000004u) != 0;
7255}
7256inline void LocatedBlockProto::set_has_offset() {
7257 _has_bits_[0] |= 0x00000004u;
7258}
7259inline void LocatedBlockProto::clear_has_offset() {
7260 _has_bits_[0] &= ~0x00000004u;
7261}
7262inline void LocatedBlockProto::clear_offset() {
7263 offset_ = GOOGLE_ULONGLONG(0);
7264 clear_has_offset();
7265}
7266inline ::google::protobuf::uint64 LocatedBlockProto::offset() const {
7267 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlockProto.offset)
7268 return offset_;
7269}
7270inline void LocatedBlockProto::set_offset(::google::protobuf::uint64 value) {
7271 set_has_offset();
7272 offset_ = value;
7273 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlockProto.offset)
7274}
7275
7276// repeated .Hdfs.Internal.DatanodeInfoProto locs = 3;
7277inline int LocatedBlockProto::locs_size() const {
7278 return locs_.size();
7279}
7280inline void LocatedBlockProto::clear_locs() {
7281 locs_.Clear();
7282}
7283inline ::Hdfs::Internal::DatanodeInfoProto* LocatedBlockProto::mutable_locs(int index) {
7284 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.LocatedBlockProto.locs)
7285 return locs_.Mutable(index);
7286}
7287inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >*
7288LocatedBlockProto::mutable_locs() {
7289 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.LocatedBlockProto.locs)
7290 return &locs_;
7291}
7292inline const ::Hdfs::Internal::DatanodeInfoProto& LocatedBlockProto::locs(int index) const {
7293 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlockProto.locs)
7294 return locs_.Get(index);
7295}
7296inline ::Hdfs::Internal::DatanodeInfoProto* LocatedBlockProto::add_locs() {
7297 // @@protoc_insertion_point(field_add:Hdfs.Internal.LocatedBlockProto.locs)
7298 return locs_.Add();
7299}
7300inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >&
7301LocatedBlockProto::locs() const {
7302 // @@protoc_insertion_point(field_list:Hdfs.Internal.LocatedBlockProto.locs)
7303 return locs_;
7304}
7305
7306// required bool corrupt = 4;
7307inline bool LocatedBlockProto::has_corrupt() const {
7308 return (_has_bits_[0] & 0x00000008u) != 0;
7309}
7310inline void LocatedBlockProto::set_has_corrupt() {
7311 _has_bits_[0] |= 0x00000008u;
7312}
7313inline void LocatedBlockProto::clear_has_corrupt() {
7314 _has_bits_[0] &= ~0x00000008u;
7315}
7316inline void LocatedBlockProto::clear_corrupt() {
7317 corrupt_ = false;
7318 clear_has_corrupt();
7319}
7320inline bool LocatedBlockProto::corrupt() const {
7321 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlockProto.corrupt)
7322 return corrupt_;
7323}
7324inline void LocatedBlockProto::set_corrupt(bool value) {
7325 set_has_corrupt();
7326 corrupt_ = value;
7327 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlockProto.corrupt)
7328}
7329
7330// required .Hdfs.Internal.TokenProto blockToken = 5;
7331inline bool LocatedBlockProto::has_blocktoken() const {
7332 return (_has_bits_[0] & 0x00000002u) != 0;
7333}
7334inline void LocatedBlockProto::set_has_blocktoken() {
7335 _has_bits_[0] |= 0x00000002u;
7336}
7337inline void LocatedBlockProto::clear_has_blocktoken() {
7338 _has_bits_[0] &= ~0x00000002u;
7339}
7340inline const ::Hdfs::Internal::TokenProto& LocatedBlockProto::_internal_blocktoken() const {
7341 return *blocktoken_;
7342}
7343inline const ::Hdfs::Internal::TokenProto& LocatedBlockProto::blocktoken() const {
7344 const ::Hdfs::Internal::TokenProto* p = blocktoken_;
7345 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlockProto.blockToken)
7346 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::TokenProto*>(
7347 &::Hdfs::Internal::_TokenProto_default_instance_);
7348}
7349inline ::Hdfs::Internal::TokenProto* LocatedBlockProto::release_blocktoken() {
7350 // @@protoc_insertion_point(field_release:Hdfs.Internal.LocatedBlockProto.blockToken)
7351 clear_has_blocktoken();
7352 ::Hdfs::Internal::TokenProto* temp = blocktoken_;
7353 blocktoken_ = NULL;
7354 return temp;
7355}
7356inline ::Hdfs::Internal::TokenProto* LocatedBlockProto::mutable_blocktoken() {
7357 set_has_blocktoken();
7358 if (blocktoken_ == NULL) {
7359 auto* p = CreateMaybeMessage<::Hdfs::Internal::TokenProto>(GetArenaNoVirtual());
7360 blocktoken_ = p;
7361 }
7362 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.LocatedBlockProto.blockToken)
7363 return blocktoken_;
7364}
7365inline void LocatedBlockProto::set_allocated_blocktoken(::Hdfs::Internal::TokenProto* blocktoken) {
7366 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
7367 if (message_arena == NULL) {
7368 delete reinterpret_cast< ::google::protobuf::MessageLite*>(blocktoken_);
7369 }
7370 if (blocktoken) {
7371 ::google::protobuf::Arena* submessage_arena = NULL;
7372 if (message_arena != submessage_arena) {
7373 blocktoken = ::google::protobuf::internal::GetOwnedMessage(
7374 message_arena, blocktoken, submessage_arena);
7375 }
7376 set_has_blocktoken();
7377 } else {
7378 clear_has_blocktoken();
7379 }
7380 blocktoken_ = blocktoken;
7381 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.LocatedBlockProto.blockToken)
7382}
7383
7384// repeated bool isCached = 6 [packed = true];
7385inline int LocatedBlockProto::iscached_size() const {
7386 return iscached_.size();
7387}
7388inline void LocatedBlockProto::clear_iscached() {
7389 iscached_.Clear();
7390}
7391inline bool LocatedBlockProto::iscached(int index) const {
7392 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlockProto.isCached)
7393 return iscached_.Get(index);
7394}
7395inline void LocatedBlockProto::set_iscached(int index, bool value) {
7396 iscached_.Set(index, value);
7397 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlockProto.isCached)
7398}
7399inline void LocatedBlockProto::add_iscached(bool value) {
7400 iscached_.Add(value);
7401 // @@protoc_insertion_point(field_add:Hdfs.Internal.LocatedBlockProto.isCached)
7402}
7403inline const ::google::protobuf::RepeatedField< bool >&
7404LocatedBlockProto::iscached() const {
7405 // @@protoc_insertion_point(field_list:Hdfs.Internal.LocatedBlockProto.isCached)
7406 return iscached_;
7407}
7408inline ::google::protobuf::RepeatedField< bool >*
7409LocatedBlockProto::mutable_iscached() {
7410 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.LocatedBlockProto.isCached)
7411 return &iscached_;
7412}
7413
7414// repeated .Hdfs.Internal.StorageTypeProto storageTypes = 7;
7415inline int LocatedBlockProto::storagetypes_size() const {
7416 return storagetypes_.size();
7417}
7418inline void LocatedBlockProto::clear_storagetypes() {
7419 storagetypes_.Clear();
7420}
7421inline ::Hdfs::Internal::StorageTypeProto LocatedBlockProto::storagetypes(int index) const {
7422 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlockProto.storageTypes)
7423 return static_cast< ::Hdfs::Internal::StorageTypeProto >(storagetypes_.Get(index));
7424}
7425inline void LocatedBlockProto::set_storagetypes(int index, ::Hdfs::Internal::StorageTypeProto value) {
7426 assert(::Hdfs::Internal::StorageTypeProto_IsValid(value));
7427 storagetypes_.Set(index, value);
7428 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlockProto.storageTypes)
7429}
7430inline void LocatedBlockProto::add_storagetypes(::Hdfs::Internal::StorageTypeProto value) {
7431 assert(::Hdfs::Internal::StorageTypeProto_IsValid(value));
7432 storagetypes_.Add(value);
7433 // @@protoc_insertion_point(field_add:Hdfs.Internal.LocatedBlockProto.storageTypes)
7434}
7435inline const ::google::protobuf::RepeatedField<int>&
7436LocatedBlockProto::storagetypes() const {
7437 // @@protoc_insertion_point(field_list:Hdfs.Internal.LocatedBlockProto.storageTypes)
7438 return storagetypes_;
7439}
7440inline ::google::protobuf::RepeatedField<int>*
7441LocatedBlockProto::mutable_storagetypes() {
7442 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.LocatedBlockProto.storageTypes)
7443 return &storagetypes_;
7444}
7445
7446// repeated string storageIDs = 8;
7447inline int LocatedBlockProto::storageids_size() const {
7448 return storageids_.size();
7449}
7450inline void LocatedBlockProto::clear_storageids() {
7451 storageids_.Clear();
7452}
7453inline const ::std::string& LocatedBlockProto::storageids(int index) const {
7454 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlockProto.storageIDs)
7455 return storageids_.Get(index);
7456}
7457inline ::std::string* LocatedBlockProto::mutable_storageids(int index) {
7458 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.LocatedBlockProto.storageIDs)
7459 return storageids_.Mutable(index);
7460}
7461inline void LocatedBlockProto::set_storageids(int index, const ::std::string& value) {
7462 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlockProto.storageIDs)
7463 storageids_.Mutable(index)->assign(value);
7464}
7465#if LANG_CXX11
7466inline void LocatedBlockProto::set_storageids(int index, ::std::string&& value) {
7467 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlockProto.storageIDs)
7468 storageids_.Mutable(index)->assign(std::move(value));
7469}
7470#endif
7471inline void LocatedBlockProto::set_storageids(int index, const char* value) {
7472 GOOGLE_DCHECK(value != NULL);
7473 storageids_.Mutable(index)->assign(value);
7474 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.LocatedBlockProto.storageIDs)
7475}
7476inline void LocatedBlockProto::set_storageids(int index, const char* value, size_t size) {
7477 storageids_.Mutable(index)->assign(
7478 reinterpret_cast<const char*>(value), size);
7479 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.LocatedBlockProto.storageIDs)
7480}
7481inline ::std::string* LocatedBlockProto::add_storageids() {
7482 // @@protoc_insertion_point(field_add_mutable:Hdfs.Internal.LocatedBlockProto.storageIDs)
7483 return storageids_.Add();
7484}
7485inline void LocatedBlockProto::add_storageids(const ::std::string& value) {
7486 storageids_.Add()->assign(value);
7487 // @@protoc_insertion_point(field_add:Hdfs.Internal.LocatedBlockProto.storageIDs)
7488}
7489#if LANG_CXX11
7490inline void LocatedBlockProto::add_storageids(::std::string&& value) {
7491 storageids_.Add(std::move(value));
7492 // @@protoc_insertion_point(field_add:Hdfs.Internal.LocatedBlockProto.storageIDs)
7493}
7494#endif
7495inline void LocatedBlockProto::add_storageids(const char* value) {
7496 GOOGLE_DCHECK(value != NULL);
7497 storageids_.Add()->assign(value);
7498 // @@protoc_insertion_point(field_add_char:Hdfs.Internal.LocatedBlockProto.storageIDs)
7499}
7500inline void LocatedBlockProto::add_storageids(const char* value, size_t size) {
7501 storageids_.Add()->assign(reinterpret_cast<const char*>(value), size);
7502 // @@protoc_insertion_point(field_add_pointer:Hdfs.Internal.LocatedBlockProto.storageIDs)
7503}
7504inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
7505LocatedBlockProto::storageids() const {
7506 // @@protoc_insertion_point(field_list:Hdfs.Internal.LocatedBlockProto.storageIDs)
7507 return storageids_;
7508}
7509inline ::google::protobuf::RepeatedPtrField< ::std::string>*
7510LocatedBlockProto::mutable_storageids() {
7511 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.LocatedBlockProto.storageIDs)
7512 return &storageids_;
7513}
7514
7515// -------------------------------------------------------------------
7516
7517// DataEncryptionKeyProto
7518
7519// required uint32 keyId = 1;
7520inline bool DataEncryptionKeyProto::has_keyid() const {
7521 return (_has_bits_[0] & 0x00000020u) != 0;
7522}
7523inline void DataEncryptionKeyProto::set_has_keyid() {
7524 _has_bits_[0] |= 0x00000020u;
7525}
7526inline void DataEncryptionKeyProto::clear_has_keyid() {
7527 _has_bits_[0] &= ~0x00000020u;
7528}
7529inline void DataEncryptionKeyProto::clear_keyid() {
7530 keyid_ = 0u;
7531 clear_has_keyid();
7532}
7533inline ::google::protobuf::uint32 DataEncryptionKeyProto::keyid() const {
7534 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataEncryptionKeyProto.keyId)
7535 return keyid_;
7536}
7537inline void DataEncryptionKeyProto::set_keyid(::google::protobuf::uint32 value) {
7538 set_has_keyid();
7539 keyid_ = value;
7540 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataEncryptionKeyProto.keyId)
7541}
7542
7543// required string blockPoolId = 2;
7544inline bool DataEncryptionKeyProto::has_blockpoolid() const {
7545 return (_has_bits_[0] & 0x00000001u) != 0;
7546}
7547inline void DataEncryptionKeyProto::set_has_blockpoolid() {
7548 _has_bits_[0] |= 0x00000001u;
7549}
7550inline void DataEncryptionKeyProto::clear_has_blockpoolid() {
7551 _has_bits_[0] &= ~0x00000001u;
7552}
7553inline void DataEncryptionKeyProto::clear_blockpoolid() {
7554 blockpoolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7555 clear_has_blockpoolid();
7556}
7557inline const ::std::string& DataEncryptionKeyProto::blockpoolid() const {
7558 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataEncryptionKeyProto.blockPoolId)
7559 return blockpoolid_.GetNoArena();
7560}
7561inline void DataEncryptionKeyProto::set_blockpoolid(const ::std::string& value) {
7562 set_has_blockpoolid();
7563 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
7564 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataEncryptionKeyProto.blockPoolId)
7565}
7566#if LANG_CXX11
7567inline void DataEncryptionKeyProto::set_blockpoolid(::std::string&& value) {
7568 set_has_blockpoolid();
7569 blockpoolid_.SetNoArena(
7570 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7571 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DataEncryptionKeyProto.blockPoolId)
7572}
7573#endif
7574inline void DataEncryptionKeyProto::set_blockpoolid(const char* value) {
7575 GOOGLE_DCHECK(value != NULL);
7576 set_has_blockpoolid();
7577 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7578 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DataEncryptionKeyProto.blockPoolId)
7579}
7580inline void DataEncryptionKeyProto::set_blockpoolid(const char* value, size_t size) {
7581 set_has_blockpoolid();
7582 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
7583 ::std::string(reinterpret_cast<const char*>(value), size));
7584 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DataEncryptionKeyProto.blockPoolId)
7585}
7586inline ::std::string* DataEncryptionKeyProto::mutable_blockpoolid() {
7587 set_has_blockpoolid();
7588 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DataEncryptionKeyProto.blockPoolId)
7589 return blockpoolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7590}
7591inline ::std::string* DataEncryptionKeyProto::release_blockpoolid() {
7592 // @@protoc_insertion_point(field_release:Hdfs.Internal.DataEncryptionKeyProto.blockPoolId)
7593 if (!has_blockpoolid()) {
7594 return NULL;
7595 }
7596 clear_has_blockpoolid();
7597 return blockpoolid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7598}
7599inline void DataEncryptionKeyProto::set_allocated_blockpoolid(::std::string* blockpoolid) {
7600 if (blockpoolid != NULL) {
7601 set_has_blockpoolid();
7602 } else {
7603 clear_has_blockpoolid();
7604 }
7605 blockpoolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockpoolid);
7606 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DataEncryptionKeyProto.blockPoolId)
7607}
7608
7609// required bytes nonce = 3;
7610inline bool DataEncryptionKeyProto::has_nonce() const {
7611 return (_has_bits_[0] & 0x00000002u) != 0;
7612}
7613inline void DataEncryptionKeyProto::set_has_nonce() {
7614 _has_bits_[0] |= 0x00000002u;
7615}
7616inline void DataEncryptionKeyProto::clear_has_nonce() {
7617 _has_bits_[0] &= ~0x00000002u;
7618}
7619inline void DataEncryptionKeyProto::clear_nonce() {
7620 nonce_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7621 clear_has_nonce();
7622}
7623inline const ::std::string& DataEncryptionKeyProto::nonce() const {
7624 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataEncryptionKeyProto.nonce)
7625 return nonce_.GetNoArena();
7626}
7627inline void DataEncryptionKeyProto::set_nonce(const ::std::string& value) {
7628 set_has_nonce();
7629 nonce_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
7630 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataEncryptionKeyProto.nonce)
7631}
7632#if LANG_CXX11
7633inline void DataEncryptionKeyProto::set_nonce(::std::string&& value) {
7634 set_has_nonce();
7635 nonce_.SetNoArena(
7636 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7637 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DataEncryptionKeyProto.nonce)
7638}
7639#endif
7640inline void DataEncryptionKeyProto::set_nonce(const char* value) {
7641 GOOGLE_DCHECK(value != NULL);
7642 set_has_nonce();
7643 nonce_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7644 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DataEncryptionKeyProto.nonce)
7645}
7646inline void DataEncryptionKeyProto::set_nonce(const void* value, size_t size) {
7647 set_has_nonce();
7648 nonce_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
7649 ::std::string(reinterpret_cast<const char*>(value), size));
7650 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DataEncryptionKeyProto.nonce)
7651}
7652inline ::std::string* DataEncryptionKeyProto::mutable_nonce() {
7653 set_has_nonce();
7654 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DataEncryptionKeyProto.nonce)
7655 return nonce_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7656}
7657inline ::std::string* DataEncryptionKeyProto::release_nonce() {
7658 // @@protoc_insertion_point(field_release:Hdfs.Internal.DataEncryptionKeyProto.nonce)
7659 if (!has_nonce()) {
7660 return NULL;
7661 }
7662 clear_has_nonce();
7663 return nonce_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7664}
7665inline void DataEncryptionKeyProto::set_allocated_nonce(::std::string* nonce) {
7666 if (nonce != NULL) {
7667 set_has_nonce();
7668 } else {
7669 clear_has_nonce();
7670 }
7671 nonce_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), nonce);
7672 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DataEncryptionKeyProto.nonce)
7673}
7674
7675// required bytes encryptionKey = 4;
7676inline bool DataEncryptionKeyProto::has_encryptionkey() const {
7677 return (_has_bits_[0] & 0x00000004u) != 0;
7678}
7679inline void DataEncryptionKeyProto::set_has_encryptionkey() {
7680 _has_bits_[0] |= 0x00000004u;
7681}
7682inline void DataEncryptionKeyProto::clear_has_encryptionkey() {
7683 _has_bits_[0] &= ~0x00000004u;
7684}
7685inline void DataEncryptionKeyProto::clear_encryptionkey() {
7686 encryptionkey_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7687 clear_has_encryptionkey();
7688}
7689inline const ::std::string& DataEncryptionKeyProto::encryptionkey() const {
7690 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataEncryptionKeyProto.encryptionKey)
7691 return encryptionkey_.GetNoArena();
7692}
7693inline void DataEncryptionKeyProto::set_encryptionkey(const ::std::string& value) {
7694 set_has_encryptionkey();
7695 encryptionkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
7696 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataEncryptionKeyProto.encryptionKey)
7697}
7698#if LANG_CXX11
7699inline void DataEncryptionKeyProto::set_encryptionkey(::std::string&& value) {
7700 set_has_encryptionkey();
7701 encryptionkey_.SetNoArena(
7702 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7703 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DataEncryptionKeyProto.encryptionKey)
7704}
7705#endif
7706inline void DataEncryptionKeyProto::set_encryptionkey(const char* value) {
7707 GOOGLE_DCHECK(value != NULL);
7708 set_has_encryptionkey();
7709 encryptionkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7710 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DataEncryptionKeyProto.encryptionKey)
7711}
7712inline void DataEncryptionKeyProto::set_encryptionkey(const void* value, size_t size) {
7713 set_has_encryptionkey();
7714 encryptionkey_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
7715 ::std::string(reinterpret_cast<const char*>(value), size));
7716 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DataEncryptionKeyProto.encryptionKey)
7717}
7718inline ::std::string* DataEncryptionKeyProto::mutable_encryptionkey() {
7719 set_has_encryptionkey();
7720 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DataEncryptionKeyProto.encryptionKey)
7721 return encryptionkey_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7722}
7723inline ::std::string* DataEncryptionKeyProto::release_encryptionkey() {
7724 // @@protoc_insertion_point(field_release:Hdfs.Internal.DataEncryptionKeyProto.encryptionKey)
7725 if (!has_encryptionkey()) {
7726 return NULL;
7727 }
7728 clear_has_encryptionkey();
7729 return encryptionkey_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7730}
7731inline void DataEncryptionKeyProto::set_allocated_encryptionkey(::std::string* encryptionkey) {
7732 if (encryptionkey != NULL) {
7733 set_has_encryptionkey();
7734 } else {
7735 clear_has_encryptionkey();
7736 }
7737 encryptionkey_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), encryptionkey);
7738 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DataEncryptionKeyProto.encryptionKey)
7739}
7740
7741// required uint64 expiryDate = 5;
7742inline bool DataEncryptionKeyProto::has_expirydate() const {
7743 return (_has_bits_[0] & 0x00000010u) != 0;
7744}
7745inline void DataEncryptionKeyProto::set_has_expirydate() {
7746 _has_bits_[0] |= 0x00000010u;
7747}
7748inline void DataEncryptionKeyProto::clear_has_expirydate() {
7749 _has_bits_[0] &= ~0x00000010u;
7750}
7751inline void DataEncryptionKeyProto::clear_expirydate() {
7752 expirydate_ = GOOGLE_ULONGLONG(0);
7753 clear_has_expirydate();
7754}
7755inline ::google::protobuf::uint64 DataEncryptionKeyProto::expirydate() const {
7756 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataEncryptionKeyProto.expiryDate)
7757 return expirydate_;
7758}
7759inline void DataEncryptionKeyProto::set_expirydate(::google::protobuf::uint64 value) {
7760 set_has_expirydate();
7761 expirydate_ = value;
7762 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataEncryptionKeyProto.expiryDate)
7763}
7764
7765// optional string encryptionAlgorithm = 6;
7766inline bool DataEncryptionKeyProto::has_encryptionalgorithm() const {
7767 return (_has_bits_[0] & 0x00000008u) != 0;
7768}
7769inline void DataEncryptionKeyProto::set_has_encryptionalgorithm() {
7770 _has_bits_[0] |= 0x00000008u;
7771}
7772inline void DataEncryptionKeyProto::clear_has_encryptionalgorithm() {
7773 _has_bits_[0] &= ~0x00000008u;
7774}
7775inline void DataEncryptionKeyProto::clear_encryptionalgorithm() {
7776 encryptionalgorithm_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7777 clear_has_encryptionalgorithm();
7778}
7779inline const ::std::string& DataEncryptionKeyProto::encryptionalgorithm() const {
7780 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataEncryptionKeyProto.encryptionAlgorithm)
7781 return encryptionalgorithm_.GetNoArena();
7782}
7783inline void DataEncryptionKeyProto::set_encryptionalgorithm(const ::std::string& value) {
7784 set_has_encryptionalgorithm();
7785 encryptionalgorithm_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
7786 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataEncryptionKeyProto.encryptionAlgorithm)
7787}
7788#if LANG_CXX11
7789inline void DataEncryptionKeyProto::set_encryptionalgorithm(::std::string&& value) {
7790 set_has_encryptionalgorithm();
7791 encryptionalgorithm_.SetNoArena(
7792 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
7793 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DataEncryptionKeyProto.encryptionAlgorithm)
7794}
7795#endif
7796inline void DataEncryptionKeyProto::set_encryptionalgorithm(const char* value) {
7797 GOOGLE_DCHECK(value != NULL);
7798 set_has_encryptionalgorithm();
7799 encryptionalgorithm_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
7800 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DataEncryptionKeyProto.encryptionAlgorithm)
7801}
7802inline void DataEncryptionKeyProto::set_encryptionalgorithm(const char* value, size_t size) {
7803 set_has_encryptionalgorithm();
7804 encryptionalgorithm_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
7805 ::std::string(reinterpret_cast<const char*>(value), size));
7806 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DataEncryptionKeyProto.encryptionAlgorithm)
7807}
7808inline ::std::string* DataEncryptionKeyProto::mutable_encryptionalgorithm() {
7809 set_has_encryptionalgorithm();
7810 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DataEncryptionKeyProto.encryptionAlgorithm)
7811 return encryptionalgorithm_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7812}
7813inline ::std::string* DataEncryptionKeyProto::release_encryptionalgorithm() {
7814 // @@protoc_insertion_point(field_release:Hdfs.Internal.DataEncryptionKeyProto.encryptionAlgorithm)
7815 if (!has_encryptionalgorithm()) {
7816 return NULL;
7817 }
7818 clear_has_encryptionalgorithm();
7819 return encryptionalgorithm_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7820}
7821inline void DataEncryptionKeyProto::set_allocated_encryptionalgorithm(::std::string* encryptionalgorithm) {
7822 if (encryptionalgorithm != NULL) {
7823 set_has_encryptionalgorithm();
7824 } else {
7825 clear_has_encryptionalgorithm();
7826 }
7827 encryptionalgorithm_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), encryptionalgorithm);
7828 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DataEncryptionKeyProto.encryptionAlgorithm)
7829}
7830
7831// -------------------------------------------------------------------
7832
7833// LocatedBlocksProto
7834
7835// required uint64 fileLength = 1;
7836inline bool LocatedBlocksProto::has_filelength() const {
7837 return (_has_bits_[0] & 0x00000002u) != 0;
7838}
7839inline void LocatedBlocksProto::set_has_filelength() {
7840 _has_bits_[0] |= 0x00000002u;
7841}
7842inline void LocatedBlocksProto::clear_has_filelength() {
7843 _has_bits_[0] &= ~0x00000002u;
7844}
7845inline void LocatedBlocksProto::clear_filelength() {
7846 filelength_ = GOOGLE_ULONGLONG(0);
7847 clear_has_filelength();
7848}
7849inline ::google::protobuf::uint64 LocatedBlocksProto::filelength() const {
7850 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlocksProto.fileLength)
7851 return filelength_;
7852}
7853inline void LocatedBlocksProto::set_filelength(::google::protobuf::uint64 value) {
7854 set_has_filelength();
7855 filelength_ = value;
7856 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlocksProto.fileLength)
7857}
7858
7859// repeated .Hdfs.Internal.LocatedBlockProto blocks = 2;
7860inline int LocatedBlocksProto::blocks_size() const {
7861 return blocks_.size();
7862}
7863inline void LocatedBlocksProto::clear_blocks() {
7864 blocks_.Clear();
7865}
7866inline ::Hdfs::Internal::LocatedBlockProto* LocatedBlocksProto::mutable_blocks(int index) {
7867 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.LocatedBlocksProto.blocks)
7868 return blocks_.Mutable(index);
7869}
7870inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::LocatedBlockProto >*
7871LocatedBlocksProto::mutable_blocks() {
7872 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.LocatedBlocksProto.blocks)
7873 return &blocks_;
7874}
7875inline const ::Hdfs::Internal::LocatedBlockProto& LocatedBlocksProto::blocks(int index) const {
7876 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlocksProto.blocks)
7877 return blocks_.Get(index);
7878}
7879inline ::Hdfs::Internal::LocatedBlockProto* LocatedBlocksProto::add_blocks() {
7880 // @@protoc_insertion_point(field_add:Hdfs.Internal.LocatedBlocksProto.blocks)
7881 return blocks_.Add();
7882}
7883inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::LocatedBlockProto >&
7884LocatedBlocksProto::blocks() const {
7885 // @@protoc_insertion_point(field_list:Hdfs.Internal.LocatedBlocksProto.blocks)
7886 return blocks_;
7887}
7888
7889// required bool underConstruction = 3;
7890inline bool LocatedBlocksProto::has_underconstruction() const {
7891 return (_has_bits_[0] & 0x00000004u) != 0;
7892}
7893inline void LocatedBlocksProto::set_has_underconstruction() {
7894 _has_bits_[0] |= 0x00000004u;
7895}
7896inline void LocatedBlocksProto::clear_has_underconstruction() {
7897 _has_bits_[0] &= ~0x00000004u;
7898}
7899inline void LocatedBlocksProto::clear_underconstruction() {
7900 underconstruction_ = false;
7901 clear_has_underconstruction();
7902}
7903inline bool LocatedBlocksProto::underconstruction() const {
7904 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlocksProto.underConstruction)
7905 return underconstruction_;
7906}
7907inline void LocatedBlocksProto::set_underconstruction(bool value) {
7908 set_has_underconstruction();
7909 underconstruction_ = value;
7910 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlocksProto.underConstruction)
7911}
7912
7913// optional .Hdfs.Internal.LocatedBlockProto lastBlock = 4;
7914inline bool LocatedBlocksProto::has_lastblock() const {
7915 return (_has_bits_[0] & 0x00000001u) != 0;
7916}
7917inline void LocatedBlocksProto::set_has_lastblock() {
7918 _has_bits_[0] |= 0x00000001u;
7919}
7920inline void LocatedBlocksProto::clear_has_lastblock() {
7921 _has_bits_[0] &= ~0x00000001u;
7922}
7923inline void LocatedBlocksProto::clear_lastblock() {
7924 if (lastblock_ != NULL) lastblock_->Clear();
7925 clear_has_lastblock();
7926}
7927inline const ::Hdfs::Internal::LocatedBlockProto& LocatedBlocksProto::_internal_lastblock() const {
7928 return *lastblock_;
7929}
7930inline const ::Hdfs::Internal::LocatedBlockProto& LocatedBlocksProto::lastblock() const {
7931 const ::Hdfs::Internal::LocatedBlockProto* p = lastblock_;
7932 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlocksProto.lastBlock)
7933 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::LocatedBlockProto*>(
7934 &::Hdfs::Internal::_LocatedBlockProto_default_instance_);
7935}
7936inline ::Hdfs::Internal::LocatedBlockProto* LocatedBlocksProto::release_lastblock() {
7937 // @@protoc_insertion_point(field_release:Hdfs.Internal.LocatedBlocksProto.lastBlock)
7938 clear_has_lastblock();
7939 ::Hdfs::Internal::LocatedBlockProto* temp = lastblock_;
7940 lastblock_ = NULL;
7941 return temp;
7942}
7943inline ::Hdfs::Internal::LocatedBlockProto* LocatedBlocksProto::mutable_lastblock() {
7944 set_has_lastblock();
7945 if (lastblock_ == NULL) {
7946 auto* p = CreateMaybeMessage<::Hdfs::Internal::LocatedBlockProto>(GetArenaNoVirtual());
7947 lastblock_ = p;
7948 }
7949 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.LocatedBlocksProto.lastBlock)
7950 return lastblock_;
7951}
7952inline void LocatedBlocksProto::set_allocated_lastblock(::Hdfs::Internal::LocatedBlockProto* lastblock) {
7953 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
7954 if (message_arena == NULL) {
7955 delete lastblock_;
7956 }
7957 if (lastblock) {
7958 ::google::protobuf::Arena* submessage_arena = NULL;
7959 if (message_arena != submessage_arena) {
7960 lastblock = ::google::protobuf::internal::GetOwnedMessage(
7961 message_arena, lastblock, submessage_arena);
7962 }
7963 set_has_lastblock();
7964 } else {
7965 clear_has_lastblock();
7966 }
7967 lastblock_ = lastblock;
7968 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.LocatedBlocksProto.lastBlock)
7969}
7970
7971// required bool isLastBlockComplete = 5;
7972inline bool LocatedBlocksProto::has_islastblockcomplete() const {
7973 return (_has_bits_[0] & 0x00000008u) != 0;
7974}
7975inline void LocatedBlocksProto::set_has_islastblockcomplete() {
7976 _has_bits_[0] |= 0x00000008u;
7977}
7978inline void LocatedBlocksProto::clear_has_islastblockcomplete() {
7979 _has_bits_[0] &= ~0x00000008u;
7980}
7981inline void LocatedBlocksProto::clear_islastblockcomplete() {
7982 islastblockcomplete_ = false;
7983 clear_has_islastblockcomplete();
7984}
7985inline bool LocatedBlocksProto::islastblockcomplete() const {
7986 // @@protoc_insertion_point(field_get:Hdfs.Internal.LocatedBlocksProto.isLastBlockComplete)
7987 return islastblockcomplete_;
7988}
7989inline void LocatedBlocksProto::set_islastblockcomplete(bool value) {
7990 set_has_islastblockcomplete();
7991 islastblockcomplete_ = value;
7992 // @@protoc_insertion_point(field_set:Hdfs.Internal.LocatedBlocksProto.isLastBlockComplete)
7993}
7994
7995// -------------------------------------------------------------------
7996
7997// HdfsFileStatusProto
7998
7999// required .Hdfs.Internal.HdfsFileStatusProto.FileType fileType = 1;
8000inline bool HdfsFileStatusProto::has_filetype() const {
8001 return (_has_bits_[0] & 0x00001000u) != 0;
8002}
8003inline void HdfsFileStatusProto::set_has_filetype() {
8004 _has_bits_[0] |= 0x00001000u;
8005}
8006inline void HdfsFileStatusProto::clear_has_filetype() {
8007 _has_bits_[0] &= ~0x00001000u;
8008}
8009inline void HdfsFileStatusProto::clear_filetype() {
8010 filetype_ = 1;
8011 clear_has_filetype();
8012}
8013inline ::Hdfs::Internal::HdfsFileStatusProto_FileType HdfsFileStatusProto::filetype() const {
8014 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.fileType)
8015 return static_cast< ::Hdfs::Internal::HdfsFileStatusProto_FileType >(filetype_);
8016}
8017inline void HdfsFileStatusProto::set_filetype(::Hdfs::Internal::HdfsFileStatusProto_FileType value) {
8018 assert(::Hdfs::Internal::HdfsFileStatusProto_FileType_IsValid(value));
8019 set_has_filetype();
8020 filetype_ = value;
8021 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.fileType)
8022}
8023
8024// required bytes path = 2;
8025inline bool HdfsFileStatusProto::has_path() const {
8026 return (_has_bits_[0] & 0x00000001u) != 0;
8027}
8028inline void HdfsFileStatusProto::set_has_path() {
8029 _has_bits_[0] |= 0x00000001u;
8030}
8031inline void HdfsFileStatusProto::clear_has_path() {
8032 _has_bits_[0] &= ~0x00000001u;
8033}
8034inline void HdfsFileStatusProto::clear_path() {
8035 path_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8036 clear_has_path();
8037}
8038inline const ::std::string& HdfsFileStatusProto::path() const {
8039 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.path)
8040 return path_.GetNoArena();
8041}
8042inline void HdfsFileStatusProto::set_path(const ::std::string& value) {
8043 set_has_path();
8044 path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
8045 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.path)
8046}
8047#if LANG_CXX11
8048inline void HdfsFileStatusProto::set_path(::std::string&& value) {
8049 set_has_path();
8050 path_.SetNoArena(
8051 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8052 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.HdfsFileStatusProto.path)
8053}
8054#endif
8055inline void HdfsFileStatusProto::set_path(const char* value) {
8056 GOOGLE_DCHECK(value != NULL);
8057 set_has_path();
8058 path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8059 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.HdfsFileStatusProto.path)
8060}
8061inline void HdfsFileStatusProto::set_path(const void* value, size_t size) {
8062 set_has_path();
8063 path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
8064 ::std::string(reinterpret_cast<const char*>(value), size));
8065 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.HdfsFileStatusProto.path)
8066}
8067inline ::std::string* HdfsFileStatusProto::mutable_path() {
8068 set_has_path();
8069 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.HdfsFileStatusProto.path)
8070 return path_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8071}
8072inline ::std::string* HdfsFileStatusProto::release_path() {
8073 // @@protoc_insertion_point(field_release:Hdfs.Internal.HdfsFileStatusProto.path)
8074 if (!has_path()) {
8075 return NULL;
8076 }
8077 clear_has_path();
8078 return path_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8079}
8080inline void HdfsFileStatusProto::set_allocated_path(::std::string* path) {
8081 if (path != NULL) {
8082 set_has_path();
8083 } else {
8084 clear_has_path();
8085 }
8086 path_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), path);
8087 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.HdfsFileStatusProto.path)
8088}
8089
8090// required uint64 length = 3;
8091inline bool HdfsFileStatusProto::has_length() const {
8092 return (_has_bits_[0] & 0x00000040u) != 0;
8093}
8094inline void HdfsFileStatusProto::set_has_length() {
8095 _has_bits_[0] |= 0x00000040u;
8096}
8097inline void HdfsFileStatusProto::clear_has_length() {
8098 _has_bits_[0] &= ~0x00000040u;
8099}
8100inline void HdfsFileStatusProto::clear_length() {
8101 length_ = GOOGLE_ULONGLONG(0);
8102 clear_has_length();
8103}
8104inline ::google::protobuf::uint64 HdfsFileStatusProto::length() const {
8105 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.length)
8106 return length_;
8107}
8108inline void HdfsFileStatusProto::set_length(::google::protobuf::uint64 value) {
8109 set_has_length();
8110 length_ = value;
8111 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.length)
8112}
8113
8114// required .Hdfs.Internal.FsPermissionProto permission = 4;
8115inline bool HdfsFileStatusProto::has_permission() const {
8116 return (_has_bits_[0] & 0x00000010u) != 0;
8117}
8118inline void HdfsFileStatusProto::set_has_permission() {
8119 _has_bits_[0] |= 0x00000010u;
8120}
8121inline void HdfsFileStatusProto::clear_has_permission() {
8122 _has_bits_[0] &= ~0x00000010u;
8123}
8124inline void HdfsFileStatusProto::clear_permission() {
8125 if (permission_ != NULL) permission_->Clear();
8126 clear_has_permission();
8127}
8128inline const ::Hdfs::Internal::FsPermissionProto& HdfsFileStatusProto::_internal_permission() const {
8129 return *permission_;
8130}
8131inline const ::Hdfs::Internal::FsPermissionProto& HdfsFileStatusProto::permission() const {
8132 const ::Hdfs::Internal::FsPermissionProto* p = permission_;
8133 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.permission)
8134 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::FsPermissionProto*>(
8135 &::Hdfs::Internal::_FsPermissionProto_default_instance_);
8136}
8137inline ::Hdfs::Internal::FsPermissionProto* HdfsFileStatusProto::release_permission() {
8138 // @@protoc_insertion_point(field_release:Hdfs.Internal.HdfsFileStatusProto.permission)
8139 clear_has_permission();
8140 ::Hdfs::Internal::FsPermissionProto* temp = permission_;
8141 permission_ = NULL;
8142 return temp;
8143}
8144inline ::Hdfs::Internal::FsPermissionProto* HdfsFileStatusProto::mutable_permission() {
8145 set_has_permission();
8146 if (permission_ == NULL) {
8147 auto* p = CreateMaybeMessage<::Hdfs::Internal::FsPermissionProto>(GetArenaNoVirtual());
8148 permission_ = p;
8149 }
8150 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.HdfsFileStatusProto.permission)
8151 return permission_;
8152}
8153inline void HdfsFileStatusProto::set_allocated_permission(::Hdfs::Internal::FsPermissionProto* permission) {
8154 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
8155 if (message_arena == NULL) {
8156 delete permission_;
8157 }
8158 if (permission) {
8159 ::google::protobuf::Arena* submessage_arena = NULL;
8160 if (message_arena != submessage_arena) {
8161 permission = ::google::protobuf::internal::GetOwnedMessage(
8162 message_arena, permission, submessage_arena);
8163 }
8164 set_has_permission();
8165 } else {
8166 clear_has_permission();
8167 }
8168 permission_ = permission;
8169 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.HdfsFileStatusProto.permission)
8170}
8171
8172// required string owner = 5;
8173inline bool HdfsFileStatusProto::has_owner() const {
8174 return (_has_bits_[0] & 0x00000002u) != 0;
8175}
8176inline void HdfsFileStatusProto::set_has_owner() {
8177 _has_bits_[0] |= 0x00000002u;
8178}
8179inline void HdfsFileStatusProto::clear_has_owner() {
8180 _has_bits_[0] &= ~0x00000002u;
8181}
8182inline void HdfsFileStatusProto::clear_owner() {
8183 owner_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8184 clear_has_owner();
8185}
8186inline const ::std::string& HdfsFileStatusProto::owner() const {
8187 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.owner)
8188 return owner_.GetNoArena();
8189}
8190inline void HdfsFileStatusProto::set_owner(const ::std::string& value) {
8191 set_has_owner();
8192 owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
8193 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.owner)
8194}
8195#if LANG_CXX11
8196inline void HdfsFileStatusProto::set_owner(::std::string&& value) {
8197 set_has_owner();
8198 owner_.SetNoArena(
8199 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8200 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.HdfsFileStatusProto.owner)
8201}
8202#endif
8203inline void HdfsFileStatusProto::set_owner(const char* value) {
8204 GOOGLE_DCHECK(value != NULL);
8205 set_has_owner();
8206 owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8207 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.HdfsFileStatusProto.owner)
8208}
8209inline void HdfsFileStatusProto::set_owner(const char* value, size_t size) {
8210 set_has_owner();
8211 owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
8212 ::std::string(reinterpret_cast<const char*>(value), size));
8213 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.HdfsFileStatusProto.owner)
8214}
8215inline ::std::string* HdfsFileStatusProto::mutable_owner() {
8216 set_has_owner();
8217 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.HdfsFileStatusProto.owner)
8218 return owner_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8219}
8220inline ::std::string* HdfsFileStatusProto::release_owner() {
8221 // @@protoc_insertion_point(field_release:Hdfs.Internal.HdfsFileStatusProto.owner)
8222 if (!has_owner()) {
8223 return NULL;
8224 }
8225 clear_has_owner();
8226 return owner_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8227}
8228inline void HdfsFileStatusProto::set_allocated_owner(::std::string* owner) {
8229 if (owner != NULL) {
8230 set_has_owner();
8231 } else {
8232 clear_has_owner();
8233 }
8234 owner_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), owner);
8235 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.HdfsFileStatusProto.owner)
8236}
8237
8238// required string group = 6;
8239inline bool HdfsFileStatusProto::has_group() const {
8240 return (_has_bits_[0] & 0x00000004u) != 0;
8241}
8242inline void HdfsFileStatusProto::set_has_group() {
8243 _has_bits_[0] |= 0x00000004u;
8244}
8245inline void HdfsFileStatusProto::clear_has_group() {
8246 _has_bits_[0] &= ~0x00000004u;
8247}
8248inline void HdfsFileStatusProto::clear_group() {
8249 group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8250 clear_has_group();
8251}
8252inline const ::std::string& HdfsFileStatusProto::group() const {
8253 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.group)
8254 return group_.GetNoArena();
8255}
8256inline void HdfsFileStatusProto::set_group(const ::std::string& value) {
8257 set_has_group();
8258 group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
8259 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.group)
8260}
8261#if LANG_CXX11
8262inline void HdfsFileStatusProto::set_group(::std::string&& value) {
8263 set_has_group();
8264 group_.SetNoArena(
8265 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8266 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.HdfsFileStatusProto.group)
8267}
8268#endif
8269inline void HdfsFileStatusProto::set_group(const char* value) {
8270 GOOGLE_DCHECK(value != NULL);
8271 set_has_group();
8272 group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8273 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.HdfsFileStatusProto.group)
8274}
8275inline void HdfsFileStatusProto::set_group(const char* value, size_t size) {
8276 set_has_group();
8277 group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
8278 ::std::string(reinterpret_cast<const char*>(value), size));
8279 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.HdfsFileStatusProto.group)
8280}
8281inline ::std::string* HdfsFileStatusProto::mutable_group() {
8282 set_has_group();
8283 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.HdfsFileStatusProto.group)
8284 return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8285}
8286inline ::std::string* HdfsFileStatusProto::release_group() {
8287 // @@protoc_insertion_point(field_release:Hdfs.Internal.HdfsFileStatusProto.group)
8288 if (!has_group()) {
8289 return NULL;
8290 }
8291 clear_has_group();
8292 return group_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8293}
8294inline void HdfsFileStatusProto::set_allocated_group(::std::string* group) {
8295 if (group != NULL) {
8296 set_has_group();
8297 } else {
8298 clear_has_group();
8299 }
8300 group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
8301 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.HdfsFileStatusProto.group)
8302}
8303
8304// required uint64 modification_time = 7;
8305inline bool HdfsFileStatusProto::has_modification_time() const {
8306 return (_has_bits_[0] & 0x00000080u) != 0;
8307}
8308inline void HdfsFileStatusProto::set_has_modification_time() {
8309 _has_bits_[0] |= 0x00000080u;
8310}
8311inline void HdfsFileStatusProto::clear_has_modification_time() {
8312 _has_bits_[0] &= ~0x00000080u;
8313}
8314inline void HdfsFileStatusProto::clear_modification_time() {
8315 modification_time_ = GOOGLE_ULONGLONG(0);
8316 clear_has_modification_time();
8317}
8318inline ::google::protobuf::uint64 HdfsFileStatusProto::modification_time() const {
8319 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.modification_time)
8320 return modification_time_;
8321}
8322inline void HdfsFileStatusProto::set_modification_time(::google::protobuf::uint64 value) {
8323 set_has_modification_time();
8324 modification_time_ = value;
8325 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.modification_time)
8326}
8327
8328// required uint64 access_time = 8;
8329inline bool HdfsFileStatusProto::has_access_time() const {
8330 return (_has_bits_[0] & 0x00000100u) != 0;
8331}
8332inline void HdfsFileStatusProto::set_has_access_time() {
8333 _has_bits_[0] |= 0x00000100u;
8334}
8335inline void HdfsFileStatusProto::clear_has_access_time() {
8336 _has_bits_[0] &= ~0x00000100u;
8337}
8338inline void HdfsFileStatusProto::clear_access_time() {
8339 access_time_ = GOOGLE_ULONGLONG(0);
8340 clear_has_access_time();
8341}
8342inline ::google::protobuf::uint64 HdfsFileStatusProto::access_time() const {
8343 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.access_time)
8344 return access_time_;
8345}
8346inline void HdfsFileStatusProto::set_access_time(::google::protobuf::uint64 value) {
8347 set_has_access_time();
8348 access_time_ = value;
8349 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.access_time)
8350}
8351
8352// optional bytes symlink = 9;
8353inline bool HdfsFileStatusProto::has_symlink() const {
8354 return (_has_bits_[0] & 0x00000008u) != 0;
8355}
8356inline void HdfsFileStatusProto::set_has_symlink() {
8357 _has_bits_[0] |= 0x00000008u;
8358}
8359inline void HdfsFileStatusProto::clear_has_symlink() {
8360 _has_bits_[0] &= ~0x00000008u;
8361}
8362inline void HdfsFileStatusProto::clear_symlink() {
8363 symlink_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8364 clear_has_symlink();
8365}
8366inline const ::std::string& HdfsFileStatusProto::symlink() const {
8367 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.symlink)
8368 return symlink_.GetNoArena();
8369}
8370inline void HdfsFileStatusProto::set_symlink(const ::std::string& value) {
8371 set_has_symlink();
8372 symlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
8373 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.symlink)
8374}
8375#if LANG_CXX11
8376inline void HdfsFileStatusProto::set_symlink(::std::string&& value) {
8377 set_has_symlink();
8378 symlink_.SetNoArena(
8379 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8380 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.HdfsFileStatusProto.symlink)
8381}
8382#endif
8383inline void HdfsFileStatusProto::set_symlink(const char* value) {
8384 GOOGLE_DCHECK(value != NULL);
8385 set_has_symlink();
8386 symlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8387 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.HdfsFileStatusProto.symlink)
8388}
8389inline void HdfsFileStatusProto::set_symlink(const void* value, size_t size) {
8390 set_has_symlink();
8391 symlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
8392 ::std::string(reinterpret_cast<const char*>(value), size));
8393 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.HdfsFileStatusProto.symlink)
8394}
8395inline ::std::string* HdfsFileStatusProto::mutable_symlink() {
8396 set_has_symlink();
8397 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.HdfsFileStatusProto.symlink)
8398 return symlink_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8399}
8400inline ::std::string* HdfsFileStatusProto::release_symlink() {
8401 // @@protoc_insertion_point(field_release:Hdfs.Internal.HdfsFileStatusProto.symlink)
8402 if (!has_symlink()) {
8403 return NULL;
8404 }
8405 clear_has_symlink();
8406 return symlink_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8407}
8408inline void HdfsFileStatusProto::set_allocated_symlink(::std::string* symlink) {
8409 if (symlink != NULL) {
8410 set_has_symlink();
8411 } else {
8412 clear_has_symlink();
8413 }
8414 symlink_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), symlink);
8415 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.HdfsFileStatusProto.symlink)
8416}
8417
8418// optional uint32 block_replication = 10 [default = 0];
8419inline bool HdfsFileStatusProto::has_block_replication() const {
8420 return (_has_bits_[0] & 0x00000800u) != 0;
8421}
8422inline void HdfsFileStatusProto::set_has_block_replication() {
8423 _has_bits_[0] |= 0x00000800u;
8424}
8425inline void HdfsFileStatusProto::clear_has_block_replication() {
8426 _has_bits_[0] &= ~0x00000800u;
8427}
8428inline void HdfsFileStatusProto::clear_block_replication() {
8429 block_replication_ = 0u;
8430 clear_has_block_replication();
8431}
8432inline ::google::protobuf::uint32 HdfsFileStatusProto::block_replication() const {
8433 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.block_replication)
8434 return block_replication_;
8435}
8436inline void HdfsFileStatusProto::set_block_replication(::google::protobuf::uint32 value) {
8437 set_has_block_replication();
8438 block_replication_ = value;
8439 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.block_replication)
8440}
8441
8442// optional uint64 blocksize = 11 [default = 0];
8443inline bool HdfsFileStatusProto::has_blocksize() const {
8444 return (_has_bits_[0] & 0x00000200u) != 0;
8445}
8446inline void HdfsFileStatusProto::set_has_blocksize() {
8447 _has_bits_[0] |= 0x00000200u;
8448}
8449inline void HdfsFileStatusProto::clear_has_blocksize() {
8450 _has_bits_[0] &= ~0x00000200u;
8451}
8452inline void HdfsFileStatusProto::clear_blocksize() {
8453 blocksize_ = GOOGLE_ULONGLONG(0);
8454 clear_has_blocksize();
8455}
8456inline ::google::protobuf::uint64 HdfsFileStatusProto::blocksize() const {
8457 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.blocksize)
8458 return blocksize_;
8459}
8460inline void HdfsFileStatusProto::set_blocksize(::google::protobuf::uint64 value) {
8461 set_has_blocksize();
8462 blocksize_ = value;
8463 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.blocksize)
8464}
8465
8466// optional .Hdfs.Internal.LocatedBlocksProto locations = 12;
8467inline bool HdfsFileStatusProto::has_locations() const {
8468 return (_has_bits_[0] & 0x00000020u) != 0;
8469}
8470inline void HdfsFileStatusProto::set_has_locations() {
8471 _has_bits_[0] |= 0x00000020u;
8472}
8473inline void HdfsFileStatusProto::clear_has_locations() {
8474 _has_bits_[0] &= ~0x00000020u;
8475}
8476inline void HdfsFileStatusProto::clear_locations() {
8477 if (locations_ != NULL) locations_->Clear();
8478 clear_has_locations();
8479}
8480inline const ::Hdfs::Internal::LocatedBlocksProto& HdfsFileStatusProto::_internal_locations() const {
8481 return *locations_;
8482}
8483inline const ::Hdfs::Internal::LocatedBlocksProto& HdfsFileStatusProto::locations() const {
8484 const ::Hdfs::Internal::LocatedBlocksProto* p = locations_;
8485 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.locations)
8486 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::LocatedBlocksProto*>(
8487 &::Hdfs::Internal::_LocatedBlocksProto_default_instance_);
8488}
8489inline ::Hdfs::Internal::LocatedBlocksProto* HdfsFileStatusProto::release_locations() {
8490 // @@protoc_insertion_point(field_release:Hdfs.Internal.HdfsFileStatusProto.locations)
8491 clear_has_locations();
8492 ::Hdfs::Internal::LocatedBlocksProto* temp = locations_;
8493 locations_ = NULL;
8494 return temp;
8495}
8496inline ::Hdfs::Internal::LocatedBlocksProto* HdfsFileStatusProto::mutable_locations() {
8497 set_has_locations();
8498 if (locations_ == NULL) {
8499 auto* p = CreateMaybeMessage<::Hdfs::Internal::LocatedBlocksProto>(GetArenaNoVirtual());
8500 locations_ = p;
8501 }
8502 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.HdfsFileStatusProto.locations)
8503 return locations_;
8504}
8505inline void HdfsFileStatusProto::set_allocated_locations(::Hdfs::Internal::LocatedBlocksProto* locations) {
8506 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
8507 if (message_arena == NULL) {
8508 delete locations_;
8509 }
8510 if (locations) {
8511 ::google::protobuf::Arena* submessage_arena = NULL;
8512 if (message_arena != submessage_arena) {
8513 locations = ::google::protobuf::internal::GetOwnedMessage(
8514 message_arena, locations, submessage_arena);
8515 }
8516 set_has_locations();
8517 } else {
8518 clear_has_locations();
8519 }
8520 locations_ = locations;
8521 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.HdfsFileStatusProto.locations)
8522}
8523
8524// optional uint64 fileId = 13 [default = 0];
8525inline bool HdfsFileStatusProto::has_fileid() const {
8526 return (_has_bits_[0] & 0x00000400u) != 0;
8527}
8528inline void HdfsFileStatusProto::set_has_fileid() {
8529 _has_bits_[0] |= 0x00000400u;
8530}
8531inline void HdfsFileStatusProto::clear_has_fileid() {
8532 _has_bits_[0] &= ~0x00000400u;
8533}
8534inline void HdfsFileStatusProto::clear_fileid() {
8535 fileid_ = GOOGLE_ULONGLONG(0);
8536 clear_has_fileid();
8537}
8538inline ::google::protobuf::uint64 HdfsFileStatusProto::fileid() const {
8539 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.fileId)
8540 return fileid_;
8541}
8542inline void HdfsFileStatusProto::set_fileid(::google::protobuf::uint64 value) {
8543 set_has_fileid();
8544 fileid_ = value;
8545 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.fileId)
8546}
8547
8548// optional int32 childrenNum = 14 [default = -1];
8549inline bool HdfsFileStatusProto::has_childrennum() const {
8550 return (_has_bits_[0] & 0x00002000u) != 0;
8551}
8552inline void HdfsFileStatusProto::set_has_childrennum() {
8553 _has_bits_[0] |= 0x00002000u;
8554}
8555inline void HdfsFileStatusProto::clear_has_childrennum() {
8556 _has_bits_[0] &= ~0x00002000u;
8557}
8558inline void HdfsFileStatusProto::clear_childrennum() {
8559 childrennum_ = -1;
8560 clear_has_childrennum();
8561}
8562inline ::google::protobuf::int32 HdfsFileStatusProto::childrennum() const {
8563 // @@protoc_insertion_point(field_get:Hdfs.Internal.HdfsFileStatusProto.childrenNum)
8564 return childrennum_;
8565}
8566inline void HdfsFileStatusProto::set_childrennum(::google::protobuf::int32 value) {
8567 set_has_childrennum();
8568 childrennum_ = value;
8569 // @@protoc_insertion_point(field_set:Hdfs.Internal.HdfsFileStatusProto.childrenNum)
8570}
8571
8572// -------------------------------------------------------------------
8573
8574// FsServerDefaultsProto
8575
8576// required uint64 blockSize = 1;
8577inline bool FsServerDefaultsProto::has_blocksize() const {
8578 return (_has_bits_[0] & 0x00000001u) != 0;
8579}
8580inline void FsServerDefaultsProto::set_has_blocksize() {
8581 _has_bits_[0] |= 0x00000001u;
8582}
8583inline void FsServerDefaultsProto::clear_has_blocksize() {
8584 _has_bits_[0] &= ~0x00000001u;
8585}
8586inline void FsServerDefaultsProto::clear_blocksize() {
8587 blocksize_ = GOOGLE_ULONGLONG(0);
8588 clear_has_blocksize();
8589}
8590inline ::google::protobuf::uint64 FsServerDefaultsProto::blocksize() const {
8591 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsServerDefaultsProto.blockSize)
8592 return blocksize_;
8593}
8594inline void FsServerDefaultsProto::set_blocksize(::google::protobuf::uint64 value) {
8595 set_has_blocksize();
8596 blocksize_ = value;
8597 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsServerDefaultsProto.blockSize)
8598}
8599
8600// required uint32 bytesPerChecksum = 2;
8601inline bool FsServerDefaultsProto::has_bytesperchecksum() const {
8602 return (_has_bits_[0] & 0x00000002u) != 0;
8603}
8604inline void FsServerDefaultsProto::set_has_bytesperchecksum() {
8605 _has_bits_[0] |= 0x00000002u;
8606}
8607inline void FsServerDefaultsProto::clear_has_bytesperchecksum() {
8608 _has_bits_[0] &= ~0x00000002u;
8609}
8610inline void FsServerDefaultsProto::clear_bytesperchecksum() {
8611 bytesperchecksum_ = 0u;
8612 clear_has_bytesperchecksum();
8613}
8614inline ::google::protobuf::uint32 FsServerDefaultsProto::bytesperchecksum() const {
8615 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsServerDefaultsProto.bytesPerChecksum)
8616 return bytesperchecksum_;
8617}
8618inline void FsServerDefaultsProto::set_bytesperchecksum(::google::protobuf::uint32 value) {
8619 set_has_bytesperchecksum();
8620 bytesperchecksum_ = value;
8621 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsServerDefaultsProto.bytesPerChecksum)
8622}
8623
8624// required uint32 writePacketSize = 3;
8625inline bool FsServerDefaultsProto::has_writepacketsize() const {
8626 return (_has_bits_[0] & 0x00000004u) != 0;
8627}
8628inline void FsServerDefaultsProto::set_has_writepacketsize() {
8629 _has_bits_[0] |= 0x00000004u;
8630}
8631inline void FsServerDefaultsProto::clear_has_writepacketsize() {
8632 _has_bits_[0] &= ~0x00000004u;
8633}
8634inline void FsServerDefaultsProto::clear_writepacketsize() {
8635 writepacketsize_ = 0u;
8636 clear_has_writepacketsize();
8637}
8638inline ::google::protobuf::uint32 FsServerDefaultsProto::writepacketsize() const {
8639 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsServerDefaultsProto.writePacketSize)
8640 return writepacketsize_;
8641}
8642inline void FsServerDefaultsProto::set_writepacketsize(::google::protobuf::uint32 value) {
8643 set_has_writepacketsize();
8644 writepacketsize_ = value;
8645 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsServerDefaultsProto.writePacketSize)
8646}
8647
8648// required uint32 replication = 4;
8649inline bool FsServerDefaultsProto::has_replication() const {
8650 return (_has_bits_[0] & 0x00000008u) != 0;
8651}
8652inline void FsServerDefaultsProto::set_has_replication() {
8653 _has_bits_[0] |= 0x00000008u;
8654}
8655inline void FsServerDefaultsProto::clear_has_replication() {
8656 _has_bits_[0] &= ~0x00000008u;
8657}
8658inline void FsServerDefaultsProto::clear_replication() {
8659 replication_ = 0u;
8660 clear_has_replication();
8661}
8662inline ::google::protobuf::uint32 FsServerDefaultsProto::replication() const {
8663 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsServerDefaultsProto.replication)
8664 return replication_;
8665}
8666inline void FsServerDefaultsProto::set_replication(::google::protobuf::uint32 value) {
8667 set_has_replication();
8668 replication_ = value;
8669 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsServerDefaultsProto.replication)
8670}
8671
8672// required uint32 fileBufferSize = 5;
8673inline bool FsServerDefaultsProto::has_filebuffersize() const {
8674 return (_has_bits_[0] & 0x00000010u) != 0;
8675}
8676inline void FsServerDefaultsProto::set_has_filebuffersize() {
8677 _has_bits_[0] |= 0x00000010u;
8678}
8679inline void FsServerDefaultsProto::clear_has_filebuffersize() {
8680 _has_bits_[0] &= ~0x00000010u;
8681}
8682inline void FsServerDefaultsProto::clear_filebuffersize() {
8683 filebuffersize_ = 0u;
8684 clear_has_filebuffersize();
8685}
8686inline ::google::protobuf::uint32 FsServerDefaultsProto::filebuffersize() const {
8687 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsServerDefaultsProto.fileBufferSize)
8688 return filebuffersize_;
8689}
8690inline void FsServerDefaultsProto::set_filebuffersize(::google::protobuf::uint32 value) {
8691 set_has_filebuffersize();
8692 filebuffersize_ = value;
8693 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsServerDefaultsProto.fileBufferSize)
8694}
8695
8696// optional bool encryptDataTransfer = 6 [default = false];
8697inline bool FsServerDefaultsProto::has_encryptdatatransfer() const {
8698 return (_has_bits_[0] & 0x00000040u) != 0;
8699}
8700inline void FsServerDefaultsProto::set_has_encryptdatatransfer() {
8701 _has_bits_[0] |= 0x00000040u;
8702}
8703inline void FsServerDefaultsProto::clear_has_encryptdatatransfer() {
8704 _has_bits_[0] &= ~0x00000040u;
8705}
8706inline void FsServerDefaultsProto::clear_encryptdatatransfer() {
8707 encryptdatatransfer_ = false;
8708 clear_has_encryptdatatransfer();
8709}
8710inline bool FsServerDefaultsProto::encryptdatatransfer() const {
8711 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsServerDefaultsProto.encryptDataTransfer)
8712 return encryptdatatransfer_;
8713}
8714inline void FsServerDefaultsProto::set_encryptdatatransfer(bool value) {
8715 set_has_encryptdatatransfer();
8716 encryptdatatransfer_ = value;
8717 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsServerDefaultsProto.encryptDataTransfer)
8718}
8719
8720// optional uint64 trashInterval = 7 [default = 0];
8721inline bool FsServerDefaultsProto::has_trashinterval() const {
8722 return (_has_bits_[0] & 0x00000020u) != 0;
8723}
8724inline void FsServerDefaultsProto::set_has_trashinterval() {
8725 _has_bits_[0] |= 0x00000020u;
8726}
8727inline void FsServerDefaultsProto::clear_has_trashinterval() {
8728 _has_bits_[0] &= ~0x00000020u;
8729}
8730inline void FsServerDefaultsProto::clear_trashinterval() {
8731 trashinterval_ = GOOGLE_ULONGLONG(0);
8732 clear_has_trashinterval();
8733}
8734inline ::google::protobuf::uint64 FsServerDefaultsProto::trashinterval() const {
8735 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsServerDefaultsProto.trashInterval)
8736 return trashinterval_;
8737}
8738inline void FsServerDefaultsProto::set_trashinterval(::google::protobuf::uint64 value) {
8739 set_has_trashinterval();
8740 trashinterval_ = value;
8741 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsServerDefaultsProto.trashInterval)
8742}
8743
8744// optional .Hdfs.Internal.ChecksumTypeProto checksumType = 8 [default = CHECKSUM_CRC32];
8745inline bool FsServerDefaultsProto::has_checksumtype() const {
8746 return (_has_bits_[0] & 0x00000080u) != 0;
8747}
8748inline void FsServerDefaultsProto::set_has_checksumtype() {
8749 _has_bits_[0] |= 0x00000080u;
8750}
8751inline void FsServerDefaultsProto::clear_has_checksumtype() {
8752 _has_bits_[0] &= ~0x00000080u;
8753}
8754inline void FsServerDefaultsProto::clear_checksumtype() {
8755 checksumtype_ = 1;
8756 clear_has_checksumtype();
8757}
8758inline ::Hdfs::Internal::ChecksumTypeProto FsServerDefaultsProto::checksumtype() const {
8759 // @@protoc_insertion_point(field_get:Hdfs.Internal.FsServerDefaultsProto.checksumType)
8760 return static_cast< ::Hdfs::Internal::ChecksumTypeProto >(checksumtype_);
8761}
8762inline void FsServerDefaultsProto::set_checksumtype(::Hdfs::Internal::ChecksumTypeProto value) {
8763 assert(::Hdfs::Internal::ChecksumTypeProto_IsValid(value));
8764 set_has_checksumtype();
8765 checksumtype_ = value;
8766 // @@protoc_insertion_point(field_set:Hdfs.Internal.FsServerDefaultsProto.checksumType)
8767}
8768
8769// -------------------------------------------------------------------
8770
8771// DirectoryListingProto
8772
8773// repeated .Hdfs.Internal.HdfsFileStatusProto partialListing = 1;
8774inline int DirectoryListingProto::partiallisting_size() const {
8775 return partiallisting_.size();
8776}
8777inline void DirectoryListingProto::clear_partiallisting() {
8778 partiallisting_.Clear();
8779}
8780inline ::Hdfs::Internal::HdfsFileStatusProto* DirectoryListingProto::mutable_partiallisting(int index) {
8781 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DirectoryListingProto.partialListing)
8782 return partiallisting_.Mutable(index);
8783}
8784inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::HdfsFileStatusProto >*
8785DirectoryListingProto::mutable_partiallisting() {
8786 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.DirectoryListingProto.partialListing)
8787 return &partiallisting_;
8788}
8789inline const ::Hdfs::Internal::HdfsFileStatusProto& DirectoryListingProto::partiallisting(int index) const {
8790 // @@protoc_insertion_point(field_get:Hdfs.Internal.DirectoryListingProto.partialListing)
8791 return partiallisting_.Get(index);
8792}
8793inline ::Hdfs::Internal::HdfsFileStatusProto* DirectoryListingProto::add_partiallisting() {
8794 // @@protoc_insertion_point(field_add:Hdfs.Internal.DirectoryListingProto.partialListing)
8795 return partiallisting_.Add();
8796}
8797inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::HdfsFileStatusProto >&
8798DirectoryListingProto::partiallisting() const {
8799 // @@protoc_insertion_point(field_list:Hdfs.Internal.DirectoryListingProto.partialListing)
8800 return partiallisting_;
8801}
8802
8803// required uint32 remainingEntries = 2;
8804inline bool DirectoryListingProto::has_remainingentries() const {
8805 return (_has_bits_[0] & 0x00000001u) != 0;
8806}
8807inline void DirectoryListingProto::set_has_remainingentries() {
8808 _has_bits_[0] |= 0x00000001u;
8809}
8810inline void DirectoryListingProto::clear_has_remainingentries() {
8811 _has_bits_[0] &= ~0x00000001u;
8812}
8813inline void DirectoryListingProto::clear_remainingentries() {
8814 remainingentries_ = 0u;
8815 clear_has_remainingentries();
8816}
8817inline ::google::protobuf::uint32 DirectoryListingProto::remainingentries() const {
8818 // @@protoc_insertion_point(field_get:Hdfs.Internal.DirectoryListingProto.remainingEntries)
8819 return remainingentries_;
8820}
8821inline void DirectoryListingProto::set_remainingentries(::google::protobuf::uint32 value) {
8822 set_has_remainingentries();
8823 remainingentries_ = value;
8824 // @@protoc_insertion_point(field_set:Hdfs.Internal.DirectoryListingProto.remainingEntries)
8825}
8826
8827// -------------------------------------------------------------------
8828
8829// SnapshottableDirectoryStatusProto
8830
8831// required .Hdfs.Internal.HdfsFileStatusProto dirStatus = 1;
8832inline bool SnapshottableDirectoryStatusProto::has_dirstatus() const {
8833 return (_has_bits_[0] & 0x00000002u) != 0;
8834}
8835inline void SnapshottableDirectoryStatusProto::set_has_dirstatus() {
8836 _has_bits_[0] |= 0x00000002u;
8837}
8838inline void SnapshottableDirectoryStatusProto::clear_has_dirstatus() {
8839 _has_bits_[0] &= ~0x00000002u;
8840}
8841inline void SnapshottableDirectoryStatusProto::clear_dirstatus() {
8842 if (dirstatus_ != NULL) dirstatus_->Clear();
8843 clear_has_dirstatus();
8844}
8845inline const ::Hdfs::Internal::HdfsFileStatusProto& SnapshottableDirectoryStatusProto::_internal_dirstatus() const {
8846 return *dirstatus_;
8847}
8848inline const ::Hdfs::Internal::HdfsFileStatusProto& SnapshottableDirectoryStatusProto::dirstatus() const {
8849 const ::Hdfs::Internal::HdfsFileStatusProto* p = dirstatus_;
8850 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshottableDirectoryStatusProto.dirStatus)
8851 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::HdfsFileStatusProto*>(
8852 &::Hdfs::Internal::_HdfsFileStatusProto_default_instance_);
8853}
8854inline ::Hdfs::Internal::HdfsFileStatusProto* SnapshottableDirectoryStatusProto::release_dirstatus() {
8855 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshottableDirectoryStatusProto.dirStatus)
8856 clear_has_dirstatus();
8857 ::Hdfs::Internal::HdfsFileStatusProto* temp = dirstatus_;
8858 dirstatus_ = NULL;
8859 return temp;
8860}
8861inline ::Hdfs::Internal::HdfsFileStatusProto* SnapshottableDirectoryStatusProto::mutable_dirstatus() {
8862 set_has_dirstatus();
8863 if (dirstatus_ == NULL) {
8864 auto* p = CreateMaybeMessage<::Hdfs::Internal::HdfsFileStatusProto>(GetArenaNoVirtual());
8865 dirstatus_ = p;
8866 }
8867 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshottableDirectoryStatusProto.dirStatus)
8868 return dirstatus_;
8869}
8870inline void SnapshottableDirectoryStatusProto::set_allocated_dirstatus(::Hdfs::Internal::HdfsFileStatusProto* dirstatus) {
8871 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
8872 if (message_arena == NULL) {
8873 delete dirstatus_;
8874 }
8875 if (dirstatus) {
8876 ::google::protobuf::Arena* submessage_arena = NULL;
8877 if (message_arena != submessage_arena) {
8878 dirstatus = ::google::protobuf::internal::GetOwnedMessage(
8879 message_arena, dirstatus, submessage_arena);
8880 }
8881 set_has_dirstatus();
8882 } else {
8883 clear_has_dirstatus();
8884 }
8885 dirstatus_ = dirstatus;
8886 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshottableDirectoryStatusProto.dirStatus)
8887}
8888
8889// required uint32 snapshot_quota = 2;
8890inline bool SnapshottableDirectoryStatusProto::has_snapshot_quota() const {
8891 return (_has_bits_[0] & 0x00000004u) != 0;
8892}
8893inline void SnapshottableDirectoryStatusProto::set_has_snapshot_quota() {
8894 _has_bits_[0] |= 0x00000004u;
8895}
8896inline void SnapshottableDirectoryStatusProto::clear_has_snapshot_quota() {
8897 _has_bits_[0] &= ~0x00000004u;
8898}
8899inline void SnapshottableDirectoryStatusProto::clear_snapshot_quota() {
8900 snapshot_quota_ = 0u;
8901 clear_has_snapshot_quota();
8902}
8903inline ::google::protobuf::uint32 SnapshottableDirectoryStatusProto::snapshot_quota() const {
8904 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshottableDirectoryStatusProto.snapshot_quota)
8905 return snapshot_quota_;
8906}
8907inline void SnapshottableDirectoryStatusProto::set_snapshot_quota(::google::protobuf::uint32 value) {
8908 set_has_snapshot_quota();
8909 snapshot_quota_ = value;
8910 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshottableDirectoryStatusProto.snapshot_quota)
8911}
8912
8913// required uint32 snapshot_number = 3;
8914inline bool SnapshottableDirectoryStatusProto::has_snapshot_number() const {
8915 return (_has_bits_[0] & 0x00000008u) != 0;
8916}
8917inline void SnapshottableDirectoryStatusProto::set_has_snapshot_number() {
8918 _has_bits_[0] |= 0x00000008u;
8919}
8920inline void SnapshottableDirectoryStatusProto::clear_has_snapshot_number() {
8921 _has_bits_[0] &= ~0x00000008u;
8922}
8923inline void SnapshottableDirectoryStatusProto::clear_snapshot_number() {
8924 snapshot_number_ = 0u;
8925 clear_has_snapshot_number();
8926}
8927inline ::google::protobuf::uint32 SnapshottableDirectoryStatusProto::snapshot_number() const {
8928 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshottableDirectoryStatusProto.snapshot_number)
8929 return snapshot_number_;
8930}
8931inline void SnapshottableDirectoryStatusProto::set_snapshot_number(::google::protobuf::uint32 value) {
8932 set_has_snapshot_number();
8933 snapshot_number_ = value;
8934 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshottableDirectoryStatusProto.snapshot_number)
8935}
8936
8937// required bytes parent_fullpath = 4;
8938inline bool SnapshottableDirectoryStatusProto::has_parent_fullpath() const {
8939 return (_has_bits_[0] & 0x00000001u) != 0;
8940}
8941inline void SnapshottableDirectoryStatusProto::set_has_parent_fullpath() {
8942 _has_bits_[0] |= 0x00000001u;
8943}
8944inline void SnapshottableDirectoryStatusProto::clear_has_parent_fullpath() {
8945 _has_bits_[0] &= ~0x00000001u;
8946}
8947inline void SnapshottableDirectoryStatusProto::clear_parent_fullpath() {
8948 parent_fullpath_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8949 clear_has_parent_fullpath();
8950}
8951inline const ::std::string& SnapshottableDirectoryStatusProto::parent_fullpath() const {
8952 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshottableDirectoryStatusProto.parent_fullpath)
8953 return parent_fullpath_.GetNoArena();
8954}
8955inline void SnapshottableDirectoryStatusProto::set_parent_fullpath(const ::std::string& value) {
8956 set_has_parent_fullpath();
8957 parent_fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
8958 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshottableDirectoryStatusProto.parent_fullpath)
8959}
8960#if LANG_CXX11
8961inline void SnapshottableDirectoryStatusProto::set_parent_fullpath(::std::string&& value) {
8962 set_has_parent_fullpath();
8963 parent_fullpath_.SetNoArena(
8964 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
8965 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshottableDirectoryStatusProto.parent_fullpath)
8966}
8967#endif
8968inline void SnapshottableDirectoryStatusProto::set_parent_fullpath(const char* value) {
8969 GOOGLE_DCHECK(value != NULL);
8970 set_has_parent_fullpath();
8971 parent_fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
8972 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshottableDirectoryStatusProto.parent_fullpath)
8973}
8974inline void SnapshottableDirectoryStatusProto::set_parent_fullpath(const void* value, size_t size) {
8975 set_has_parent_fullpath();
8976 parent_fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
8977 ::std::string(reinterpret_cast<const char*>(value), size));
8978 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshottableDirectoryStatusProto.parent_fullpath)
8979}
8980inline ::std::string* SnapshottableDirectoryStatusProto::mutable_parent_fullpath() {
8981 set_has_parent_fullpath();
8982 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshottableDirectoryStatusProto.parent_fullpath)
8983 return parent_fullpath_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8984}
8985inline ::std::string* SnapshottableDirectoryStatusProto::release_parent_fullpath() {
8986 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshottableDirectoryStatusProto.parent_fullpath)
8987 if (!has_parent_fullpath()) {
8988 return NULL;
8989 }
8990 clear_has_parent_fullpath();
8991 return parent_fullpath_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8992}
8993inline void SnapshottableDirectoryStatusProto::set_allocated_parent_fullpath(::std::string* parent_fullpath) {
8994 if (parent_fullpath != NULL) {
8995 set_has_parent_fullpath();
8996 } else {
8997 clear_has_parent_fullpath();
8998 }
8999 parent_fullpath_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), parent_fullpath);
9000 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshottableDirectoryStatusProto.parent_fullpath)
9001}
9002
9003// -------------------------------------------------------------------
9004
9005// SnapshottableDirectoryListingProto
9006
9007// repeated .Hdfs.Internal.SnapshottableDirectoryStatusProto snapshottableDirListing = 1;
9008inline int SnapshottableDirectoryListingProto::snapshottabledirlisting_size() const {
9009 return snapshottabledirlisting_.size();
9010}
9011inline void SnapshottableDirectoryListingProto::clear_snapshottabledirlisting() {
9012 snapshottabledirlisting_.Clear();
9013}
9014inline ::Hdfs::Internal::SnapshottableDirectoryStatusProto* SnapshottableDirectoryListingProto::mutable_snapshottabledirlisting(int index) {
9015 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshottableDirectoryListingProto.snapshottableDirListing)
9016 return snapshottabledirlisting_.Mutable(index);
9017}
9018inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshottableDirectoryStatusProto >*
9019SnapshottableDirectoryListingProto::mutable_snapshottabledirlisting() {
9020 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.SnapshottableDirectoryListingProto.snapshottableDirListing)
9021 return &snapshottabledirlisting_;
9022}
9023inline const ::Hdfs::Internal::SnapshottableDirectoryStatusProto& SnapshottableDirectoryListingProto::snapshottabledirlisting(int index) const {
9024 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshottableDirectoryListingProto.snapshottableDirListing)
9025 return snapshottabledirlisting_.Get(index);
9026}
9027inline ::Hdfs::Internal::SnapshottableDirectoryStatusProto* SnapshottableDirectoryListingProto::add_snapshottabledirlisting() {
9028 // @@protoc_insertion_point(field_add:Hdfs.Internal.SnapshottableDirectoryListingProto.snapshottableDirListing)
9029 return snapshottabledirlisting_.Add();
9030}
9031inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshottableDirectoryStatusProto >&
9032SnapshottableDirectoryListingProto::snapshottabledirlisting() const {
9033 // @@protoc_insertion_point(field_list:Hdfs.Internal.SnapshottableDirectoryListingProto.snapshottableDirListing)
9034 return snapshottabledirlisting_;
9035}
9036
9037// -------------------------------------------------------------------
9038
9039// SnapshotDiffReportEntryProto
9040
9041// required bytes fullpath = 1;
9042inline bool SnapshotDiffReportEntryProto::has_fullpath() const {
9043 return (_has_bits_[0] & 0x00000001u) != 0;
9044}
9045inline void SnapshotDiffReportEntryProto::set_has_fullpath() {
9046 _has_bits_[0] |= 0x00000001u;
9047}
9048inline void SnapshotDiffReportEntryProto::clear_has_fullpath() {
9049 _has_bits_[0] &= ~0x00000001u;
9050}
9051inline void SnapshotDiffReportEntryProto::clear_fullpath() {
9052 fullpath_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9053 clear_has_fullpath();
9054}
9055inline const ::std::string& SnapshotDiffReportEntryProto::fullpath() const {
9056 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotDiffReportEntryProto.fullpath)
9057 return fullpath_.GetNoArena();
9058}
9059inline void SnapshotDiffReportEntryProto::set_fullpath(const ::std::string& value) {
9060 set_has_fullpath();
9061 fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9062 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotDiffReportEntryProto.fullpath)
9063}
9064#if LANG_CXX11
9065inline void SnapshotDiffReportEntryProto::set_fullpath(::std::string&& value) {
9066 set_has_fullpath();
9067 fullpath_.SetNoArena(
9068 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9069 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotDiffReportEntryProto.fullpath)
9070}
9071#endif
9072inline void SnapshotDiffReportEntryProto::set_fullpath(const char* value) {
9073 GOOGLE_DCHECK(value != NULL);
9074 set_has_fullpath();
9075 fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9076 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotDiffReportEntryProto.fullpath)
9077}
9078inline void SnapshotDiffReportEntryProto::set_fullpath(const void* value, size_t size) {
9079 set_has_fullpath();
9080 fullpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9081 ::std::string(reinterpret_cast<const char*>(value), size));
9082 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotDiffReportEntryProto.fullpath)
9083}
9084inline ::std::string* SnapshotDiffReportEntryProto::mutable_fullpath() {
9085 set_has_fullpath();
9086 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotDiffReportEntryProto.fullpath)
9087 return fullpath_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9088}
9089inline ::std::string* SnapshotDiffReportEntryProto::release_fullpath() {
9090 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotDiffReportEntryProto.fullpath)
9091 if (!has_fullpath()) {
9092 return NULL;
9093 }
9094 clear_has_fullpath();
9095 return fullpath_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9096}
9097inline void SnapshotDiffReportEntryProto::set_allocated_fullpath(::std::string* fullpath) {
9098 if (fullpath != NULL) {
9099 set_has_fullpath();
9100 } else {
9101 clear_has_fullpath();
9102 }
9103 fullpath_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), fullpath);
9104 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotDiffReportEntryProto.fullpath)
9105}
9106
9107// required string modificationLabel = 2;
9108inline bool SnapshotDiffReportEntryProto::has_modificationlabel() const {
9109 return (_has_bits_[0] & 0x00000002u) != 0;
9110}
9111inline void SnapshotDiffReportEntryProto::set_has_modificationlabel() {
9112 _has_bits_[0] |= 0x00000002u;
9113}
9114inline void SnapshotDiffReportEntryProto::clear_has_modificationlabel() {
9115 _has_bits_[0] &= ~0x00000002u;
9116}
9117inline void SnapshotDiffReportEntryProto::clear_modificationlabel() {
9118 modificationlabel_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9119 clear_has_modificationlabel();
9120}
9121inline const ::std::string& SnapshotDiffReportEntryProto::modificationlabel() const {
9122 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotDiffReportEntryProto.modificationLabel)
9123 return modificationlabel_.GetNoArena();
9124}
9125inline void SnapshotDiffReportEntryProto::set_modificationlabel(const ::std::string& value) {
9126 set_has_modificationlabel();
9127 modificationlabel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9128 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotDiffReportEntryProto.modificationLabel)
9129}
9130#if LANG_CXX11
9131inline void SnapshotDiffReportEntryProto::set_modificationlabel(::std::string&& value) {
9132 set_has_modificationlabel();
9133 modificationlabel_.SetNoArena(
9134 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9135 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotDiffReportEntryProto.modificationLabel)
9136}
9137#endif
9138inline void SnapshotDiffReportEntryProto::set_modificationlabel(const char* value) {
9139 GOOGLE_DCHECK(value != NULL);
9140 set_has_modificationlabel();
9141 modificationlabel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9142 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotDiffReportEntryProto.modificationLabel)
9143}
9144inline void SnapshotDiffReportEntryProto::set_modificationlabel(const char* value, size_t size) {
9145 set_has_modificationlabel();
9146 modificationlabel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9147 ::std::string(reinterpret_cast<const char*>(value), size));
9148 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotDiffReportEntryProto.modificationLabel)
9149}
9150inline ::std::string* SnapshotDiffReportEntryProto::mutable_modificationlabel() {
9151 set_has_modificationlabel();
9152 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotDiffReportEntryProto.modificationLabel)
9153 return modificationlabel_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9154}
9155inline ::std::string* SnapshotDiffReportEntryProto::release_modificationlabel() {
9156 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotDiffReportEntryProto.modificationLabel)
9157 if (!has_modificationlabel()) {
9158 return NULL;
9159 }
9160 clear_has_modificationlabel();
9161 return modificationlabel_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9162}
9163inline void SnapshotDiffReportEntryProto::set_allocated_modificationlabel(::std::string* modificationlabel) {
9164 if (modificationlabel != NULL) {
9165 set_has_modificationlabel();
9166 } else {
9167 clear_has_modificationlabel();
9168 }
9169 modificationlabel_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), modificationlabel);
9170 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotDiffReportEntryProto.modificationLabel)
9171}
9172
9173// -------------------------------------------------------------------
9174
9175// SnapshotDiffReportProto
9176
9177// required string snapshotRoot = 1;
9178inline bool SnapshotDiffReportProto::has_snapshotroot() const {
9179 return (_has_bits_[0] & 0x00000001u) != 0;
9180}
9181inline void SnapshotDiffReportProto::set_has_snapshotroot() {
9182 _has_bits_[0] |= 0x00000001u;
9183}
9184inline void SnapshotDiffReportProto::clear_has_snapshotroot() {
9185 _has_bits_[0] &= ~0x00000001u;
9186}
9187inline void SnapshotDiffReportProto::clear_snapshotroot() {
9188 snapshotroot_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9189 clear_has_snapshotroot();
9190}
9191inline const ::std::string& SnapshotDiffReportProto::snapshotroot() const {
9192 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotDiffReportProto.snapshotRoot)
9193 return snapshotroot_.GetNoArena();
9194}
9195inline void SnapshotDiffReportProto::set_snapshotroot(const ::std::string& value) {
9196 set_has_snapshotroot();
9197 snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9198 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotDiffReportProto.snapshotRoot)
9199}
9200#if LANG_CXX11
9201inline void SnapshotDiffReportProto::set_snapshotroot(::std::string&& value) {
9202 set_has_snapshotroot();
9203 snapshotroot_.SetNoArena(
9204 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9205 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotDiffReportProto.snapshotRoot)
9206}
9207#endif
9208inline void SnapshotDiffReportProto::set_snapshotroot(const char* value) {
9209 GOOGLE_DCHECK(value != NULL);
9210 set_has_snapshotroot();
9211 snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9212 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotDiffReportProto.snapshotRoot)
9213}
9214inline void SnapshotDiffReportProto::set_snapshotroot(const char* value, size_t size) {
9215 set_has_snapshotroot();
9216 snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9217 ::std::string(reinterpret_cast<const char*>(value), size));
9218 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotDiffReportProto.snapshotRoot)
9219}
9220inline ::std::string* SnapshotDiffReportProto::mutable_snapshotroot() {
9221 set_has_snapshotroot();
9222 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotDiffReportProto.snapshotRoot)
9223 return snapshotroot_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9224}
9225inline ::std::string* SnapshotDiffReportProto::release_snapshotroot() {
9226 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotDiffReportProto.snapshotRoot)
9227 if (!has_snapshotroot()) {
9228 return NULL;
9229 }
9230 clear_has_snapshotroot();
9231 return snapshotroot_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9232}
9233inline void SnapshotDiffReportProto::set_allocated_snapshotroot(::std::string* snapshotroot) {
9234 if (snapshotroot != NULL) {
9235 set_has_snapshotroot();
9236 } else {
9237 clear_has_snapshotroot();
9238 }
9239 snapshotroot_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshotroot);
9240 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotDiffReportProto.snapshotRoot)
9241}
9242
9243// required string fromSnapshot = 2;
9244inline bool SnapshotDiffReportProto::has_fromsnapshot() const {
9245 return (_has_bits_[0] & 0x00000002u) != 0;
9246}
9247inline void SnapshotDiffReportProto::set_has_fromsnapshot() {
9248 _has_bits_[0] |= 0x00000002u;
9249}
9250inline void SnapshotDiffReportProto::clear_has_fromsnapshot() {
9251 _has_bits_[0] &= ~0x00000002u;
9252}
9253inline void SnapshotDiffReportProto::clear_fromsnapshot() {
9254 fromsnapshot_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9255 clear_has_fromsnapshot();
9256}
9257inline const ::std::string& SnapshotDiffReportProto::fromsnapshot() const {
9258 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotDiffReportProto.fromSnapshot)
9259 return fromsnapshot_.GetNoArena();
9260}
9261inline void SnapshotDiffReportProto::set_fromsnapshot(const ::std::string& value) {
9262 set_has_fromsnapshot();
9263 fromsnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9264 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotDiffReportProto.fromSnapshot)
9265}
9266#if LANG_CXX11
9267inline void SnapshotDiffReportProto::set_fromsnapshot(::std::string&& value) {
9268 set_has_fromsnapshot();
9269 fromsnapshot_.SetNoArena(
9270 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9271 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotDiffReportProto.fromSnapshot)
9272}
9273#endif
9274inline void SnapshotDiffReportProto::set_fromsnapshot(const char* value) {
9275 GOOGLE_DCHECK(value != NULL);
9276 set_has_fromsnapshot();
9277 fromsnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9278 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotDiffReportProto.fromSnapshot)
9279}
9280inline void SnapshotDiffReportProto::set_fromsnapshot(const char* value, size_t size) {
9281 set_has_fromsnapshot();
9282 fromsnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9283 ::std::string(reinterpret_cast<const char*>(value), size));
9284 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotDiffReportProto.fromSnapshot)
9285}
9286inline ::std::string* SnapshotDiffReportProto::mutable_fromsnapshot() {
9287 set_has_fromsnapshot();
9288 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotDiffReportProto.fromSnapshot)
9289 return fromsnapshot_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9290}
9291inline ::std::string* SnapshotDiffReportProto::release_fromsnapshot() {
9292 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotDiffReportProto.fromSnapshot)
9293 if (!has_fromsnapshot()) {
9294 return NULL;
9295 }
9296 clear_has_fromsnapshot();
9297 return fromsnapshot_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9298}
9299inline void SnapshotDiffReportProto::set_allocated_fromsnapshot(::std::string* fromsnapshot) {
9300 if (fromsnapshot != NULL) {
9301 set_has_fromsnapshot();
9302 } else {
9303 clear_has_fromsnapshot();
9304 }
9305 fromsnapshot_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), fromsnapshot);
9306 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotDiffReportProto.fromSnapshot)
9307}
9308
9309// required string toSnapshot = 3;
9310inline bool SnapshotDiffReportProto::has_tosnapshot() const {
9311 return (_has_bits_[0] & 0x00000004u) != 0;
9312}
9313inline void SnapshotDiffReportProto::set_has_tosnapshot() {
9314 _has_bits_[0] |= 0x00000004u;
9315}
9316inline void SnapshotDiffReportProto::clear_has_tosnapshot() {
9317 _has_bits_[0] &= ~0x00000004u;
9318}
9319inline void SnapshotDiffReportProto::clear_tosnapshot() {
9320 tosnapshot_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9321 clear_has_tosnapshot();
9322}
9323inline const ::std::string& SnapshotDiffReportProto::tosnapshot() const {
9324 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotDiffReportProto.toSnapshot)
9325 return tosnapshot_.GetNoArena();
9326}
9327inline void SnapshotDiffReportProto::set_tosnapshot(const ::std::string& value) {
9328 set_has_tosnapshot();
9329 tosnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9330 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotDiffReportProto.toSnapshot)
9331}
9332#if LANG_CXX11
9333inline void SnapshotDiffReportProto::set_tosnapshot(::std::string&& value) {
9334 set_has_tosnapshot();
9335 tosnapshot_.SetNoArena(
9336 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9337 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotDiffReportProto.toSnapshot)
9338}
9339#endif
9340inline void SnapshotDiffReportProto::set_tosnapshot(const char* value) {
9341 GOOGLE_DCHECK(value != NULL);
9342 set_has_tosnapshot();
9343 tosnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9344 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotDiffReportProto.toSnapshot)
9345}
9346inline void SnapshotDiffReportProto::set_tosnapshot(const char* value, size_t size) {
9347 set_has_tosnapshot();
9348 tosnapshot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9349 ::std::string(reinterpret_cast<const char*>(value), size));
9350 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotDiffReportProto.toSnapshot)
9351}
9352inline ::std::string* SnapshotDiffReportProto::mutable_tosnapshot() {
9353 set_has_tosnapshot();
9354 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotDiffReportProto.toSnapshot)
9355 return tosnapshot_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9356}
9357inline ::std::string* SnapshotDiffReportProto::release_tosnapshot() {
9358 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotDiffReportProto.toSnapshot)
9359 if (!has_tosnapshot()) {
9360 return NULL;
9361 }
9362 clear_has_tosnapshot();
9363 return tosnapshot_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9364}
9365inline void SnapshotDiffReportProto::set_allocated_tosnapshot(::std::string* tosnapshot) {
9366 if (tosnapshot != NULL) {
9367 set_has_tosnapshot();
9368 } else {
9369 clear_has_tosnapshot();
9370 }
9371 tosnapshot_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), tosnapshot);
9372 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotDiffReportProto.toSnapshot)
9373}
9374
9375// repeated .Hdfs.Internal.SnapshotDiffReportEntryProto diffReportEntries = 4;
9376inline int SnapshotDiffReportProto::diffreportentries_size() const {
9377 return diffreportentries_.size();
9378}
9379inline void SnapshotDiffReportProto::clear_diffreportentries() {
9380 diffreportentries_.Clear();
9381}
9382inline ::Hdfs::Internal::SnapshotDiffReportEntryProto* SnapshotDiffReportProto::mutable_diffreportentries(int index) {
9383 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotDiffReportProto.diffReportEntries)
9384 return diffreportentries_.Mutable(index);
9385}
9386inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshotDiffReportEntryProto >*
9387SnapshotDiffReportProto::mutable_diffreportentries() {
9388 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.SnapshotDiffReportProto.diffReportEntries)
9389 return &diffreportentries_;
9390}
9391inline const ::Hdfs::Internal::SnapshotDiffReportEntryProto& SnapshotDiffReportProto::diffreportentries(int index) const {
9392 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotDiffReportProto.diffReportEntries)
9393 return diffreportentries_.Get(index);
9394}
9395inline ::Hdfs::Internal::SnapshotDiffReportEntryProto* SnapshotDiffReportProto::add_diffreportentries() {
9396 // @@protoc_insertion_point(field_add:Hdfs.Internal.SnapshotDiffReportProto.diffReportEntries)
9397 return diffreportentries_.Add();
9398}
9399inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::SnapshotDiffReportEntryProto >&
9400SnapshotDiffReportProto::diffreportentries() const {
9401 // @@protoc_insertion_point(field_list:Hdfs.Internal.SnapshotDiffReportProto.diffReportEntries)
9402 return diffreportentries_;
9403}
9404
9405// -------------------------------------------------------------------
9406
9407// StorageInfoProto
9408
9409// required uint32 layoutVersion = 1;
9410inline bool StorageInfoProto::has_layoutversion() const {
9411 return (_has_bits_[0] & 0x00000002u) != 0;
9412}
9413inline void StorageInfoProto::set_has_layoutversion() {
9414 _has_bits_[0] |= 0x00000002u;
9415}
9416inline void StorageInfoProto::clear_has_layoutversion() {
9417 _has_bits_[0] &= ~0x00000002u;
9418}
9419inline void StorageInfoProto::clear_layoutversion() {
9420 layoutversion_ = 0u;
9421 clear_has_layoutversion();
9422}
9423inline ::google::protobuf::uint32 StorageInfoProto::layoutversion() const {
9424 // @@protoc_insertion_point(field_get:Hdfs.Internal.StorageInfoProto.layoutVersion)
9425 return layoutversion_;
9426}
9427inline void StorageInfoProto::set_layoutversion(::google::protobuf::uint32 value) {
9428 set_has_layoutversion();
9429 layoutversion_ = value;
9430 // @@protoc_insertion_point(field_set:Hdfs.Internal.StorageInfoProto.layoutVersion)
9431}
9432
9433// required uint32 namespceID = 2;
9434inline bool StorageInfoProto::has_namespceid() const {
9435 return (_has_bits_[0] & 0x00000004u) != 0;
9436}
9437inline void StorageInfoProto::set_has_namespceid() {
9438 _has_bits_[0] |= 0x00000004u;
9439}
9440inline void StorageInfoProto::clear_has_namespceid() {
9441 _has_bits_[0] &= ~0x00000004u;
9442}
9443inline void StorageInfoProto::clear_namespceid() {
9444 namespceid_ = 0u;
9445 clear_has_namespceid();
9446}
9447inline ::google::protobuf::uint32 StorageInfoProto::namespceid() const {
9448 // @@protoc_insertion_point(field_get:Hdfs.Internal.StorageInfoProto.namespceID)
9449 return namespceid_;
9450}
9451inline void StorageInfoProto::set_namespceid(::google::protobuf::uint32 value) {
9452 set_has_namespceid();
9453 namespceid_ = value;
9454 // @@protoc_insertion_point(field_set:Hdfs.Internal.StorageInfoProto.namespceID)
9455}
9456
9457// required string clusterID = 3;
9458inline bool StorageInfoProto::has_clusterid() const {
9459 return (_has_bits_[0] & 0x00000001u) != 0;
9460}
9461inline void StorageInfoProto::set_has_clusterid() {
9462 _has_bits_[0] |= 0x00000001u;
9463}
9464inline void StorageInfoProto::clear_has_clusterid() {
9465 _has_bits_[0] &= ~0x00000001u;
9466}
9467inline void StorageInfoProto::clear_clusterid() {
9468 clusterid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9469 clear_has_clusterid();
9470}
9471inline const ::std::string& StorageInfoProto::clusterid() const {
9472 // @@protoc_insertion_point(field_get:Hdfs.Internal.StorageInfoProto.clusterID)
9473 return clusterid_.GetNoArena();
9474}
9475inline void StorageInfoProto::set_clusterid(const ::std::string& value) {
9476 set_has_clusterid();
9477 clusterid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9478 // @@protoc_insertion_point(field_set:Hdfs.Internal.StorageInfoProto.clusterID)
9479}
9480#if LANG_CXX11
9481inline void StorageInfoProto::set_clusterid(::std::string&& value) {
9482 set_has_clusterid();
9483 clusterid_.SetNoArena(
9484 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9485 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.StorageInfoProto.clusterID)
9486}
9487#endif
9488inline void StorageInfoProto::set_clusterid(const char* value) {
9489 GOOGLE_DCHECK(value != NULL);
9490 set_has_clusterid();
9491 clusterid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9492 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.StorageInfoProto.clusterID)
9493}
9494inline void StorageInfoProto::set_clusterid(const char* value, size_t size) {
9495 set_has_clusterid();
9496 clusterid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9497 ::std::string(reinterpret_cast<const char*>(value), size));
9498 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.StorageInfoProto.clusterID)
9499}
9500inline ::std::string* StorageInfoProto::mutable_clusterid() {
9501 set_has_clusterid();
9502 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.StorageInfoProto.clusterID)
9503 return clusterid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9504}
9505inline ::std::string* StorageInfoProto::release_clusterid() {
9506 // @@protoc_insertion_point(field_release:Hdfs.Internal.StorageInfoProto.clusterID)
9507 if (!has_clusterid()) {
9508 return NULL;
9509 }
9510 clear_has_clusterid();
9511 return clusterid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9512}
9513inline void StorageInfoProto::set_allocated_clusterid(::std::string* clusterid) {
9514 if (clusterid != NULL) {
9515 set_has_clusterid();
9516 } else {
9517 clear_has_clusterid();
9518 }
9519 clusterid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), clusterid);
9520 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.StorageInfoProto.clusterID)
9521}
9522
9523// required uint64 cTime = 4;
9524inline bool StorageInfoProto::has_ctime() const {
9525 return (_has_bits_[0] & 0x00000008u) != 0;
9526}
9527inline void StorageInfoProto::set_has_ctime() {
9528 _has_bits_[0] |= 0x00000008u;
9529}
9530inline void StorageInfoProto::clear_has_ctime() {
9531 _has_bits_[0] &= ~0x00000008u;
9532}
9533inline void StorageInfoProto::clear_ctime() {
9534 ctime_ = GOOGLE_ULONGLONG(0);
9535 clear_has_ctime();
9536}
9537inline ::google::protobuf::uint64 StorageInfoProto::ctime() const {
9538 // @@protoc_insertion_point(field_get:Hdfs.Internal.StorageInfoProto.cTime)
9539 return ctime_;
9540}
9541inline void StorageInfoProto::set_ctime(::google::protobuf::uint64 value) {
9542 set_has_ctime();
9543 ctime_ = value;
9544 // @@protoc_insertion_point(field_set:Hdfs.Internal.StorageInfoProto.cTime)
9545}
9546
9547// -------------------------------------------------------------------
9548
9549// NamenodeRegistrationProto
9550
9551// required string rpcAddress = 1;
9552inline bool NamenodeRegistrationProto::has_rpcaddress() const {
9553 return (_has_bits_[0] & 0x00000001u) != 0;
9554}
9555inline void NamenodeRegistrationProto::set_has_rpcaddress() {
9556 _has_bits_[0] |= 0x00000001u;
9557}
9558inline void NamenodeRegistrationProto::clear_has_rpcaddress() {
9559 _has_bits_[0] &= ~0x00000001u;
9560}
9561inline void NamenodeRegistrationProto::clear_rpcaddress() {
9562 rpcaddress_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9563 clear_has_rpcaddress();
9564}
9565inline const ::std::string& NamenodeRegistrationProto::rpcaddress() const {
9566 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamenodeRegistrationProto.rpcAddress)
9567 return rpcaddress_.GetNoArena();
9568}
9569inline void NamenodeRegistrationProto::set_rpcaddress(const ::std::string& value) {
9570 set_has_rpcaddress();
9571 rpcaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9572 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamenodeRegistrationProto.rpcAddress)
9573}
9574#if LANG_CXX11
9575inline void NamenodeRegistrationProto::set_rpcaddress(::std::string&& value) {
9576 set_has_rpcaddress();
9577 rpcaddress_.SetNoArena(
9578 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9579 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.NamenodeRegistrationProto.rpcAddress)
9580}
9581#endif
9582inline void NamenodeRegistrationProto::set_rpcaddress(const char* value) {
9583 GOOGLE_DCHECK(value != NULL);
9584 set_has_rpcaddress();
9585 rpcaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9586 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.NamenodeRegistrationProto.rpcAddress)
9587}
9588inline void NamenodeRegistrationProto::set_rpcaddress(const char* value, size_t size) {
9589 set_has_rpcaddress();
9590 rpcaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9591 ::std::string(reinterpret_cast<const char*>(value), size));
9592 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.NamenodeRegistrationProto.rpcAddress)
9593}
9594inline ::std::string* NamenodeRegistrationProto::mutable_rpcaddress() {
9595 set_has_rpcaddress();
9596 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.NamenodeRegistrationProto.rpcAddress)
9597 return rpcaddress_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9598}
9599inline ::std::string* NamenodeRegistrationProto::release_rpcaddress() {
9600 // @@protoc_insertion_point(field_release:Hdfs.Internal.NamenodeRegistrationProto.rpcAddress)
9601 if (!has_rpcaddress()) {
9602 return NULL;
9603 }
9604 clear_has_rpcaddress();
9605 return rpcaddress_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9606}
9607inline void NamenodeRegistrationProto::set_allocated_rpcaddress(::std::string* rpcaddress) {
9608 if (rpcaddress != NULL) {
9609 set_has_rpcaddress();
9610 } else {
9611 clear_has_rpcaddress();
9612 }
9613 rpcaddress_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), rpcaddress);
9614 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.NamenodeRegistrationProto.rpcAddress)
9615}
9616
9617// required string httpAddress = 2;
9618inline bool NamenodeRegistrationProto::has_httpaddress() const {
9619 return (_has_bits_[0] & 0x00000002u) != 0;
9620}
9621inline void NamenodeRegistrationProto::set_has_httpaddress() {
9622 _has_bits_[0] |= 0x00000002u;
9623}
9624inline void NamenodeRegistrationProto::clear_has_httpaddress() {
9625 _has_bits_[0] &= ~0x00000002u;
9626}
9627inline void NamenodeRegistrationProto::clear_httpaddress() {
9628 httpaddress_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9629 clear_has_httpaddress();
9630}
9631inline const ::std::string& NamenodeRegistrationProto::httpaddress() const {
9632 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamenodeRegistrationProto.httpAddress)
9633 return httpaddress_.GetNoArena();
9634}
9635inline void NamenodeRegistrationProto::set_httpaddress(const ::std::string& value) {
9636 set_has_httpaddress();
9637 httpaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9638 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamenodeRegistrationProto.httpAddress)
9639}
9640#if LANG_CXX11
9641inline void NamenodeRegistrationProto::set_httpaddress(::std::string&& value) {
9642 set_has_httpaddress();
9643 httpaddress_.SetNoArena(
9644 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9645 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.NamenodeRegistrationProto.httpAddress)
9646}
9647#endif
9648inline void NamenodeRegistrationProto::set_httpaddress(const char* value) {
9649 GOOGLE_DCHECK(value != NULL);
9650 set_has_httpaddress();
9651 httpaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9652 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.NamenodeRegistrationProto.httpAddress)
9653}
9654inline void NamenodeRegistrationProto::set_httpaddress(const char* value, size_t size) {
9655 set_has_httpaddress();
9656 httpaddress_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9657 ::std::string(reinterpret_cast<const char*>(value), size));
9658 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.NamenodeRegistrationProto.httpAddress)
9659}
9660inline ::std::string* NamenodeRegistrationProto::mutable_httpaddress() {
9661 set_has_httpaddress();
9662 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.NamenodeRegistrationProto.httpAddress)
9663 return httpaddress_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9664}
9665inline ::std::string* NamenodeRegistrationProto::release_httpaddress() {
9666 // @@protoc_insertion_point(field_release:Hdfs.Internal.NamenodeRegistrationProto.httpAddress)
9667 if (!has_httpaddress()) {
9668 return NULL;
9669 }
9670 clear_has_httpaddress();
9671 return httpaddress_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9672}
9673inline void NamenodeRegistrationProto::set_allocated_httpaddress(::std::string* httpaddress) {
9674 if (httpaddress != NULL) {
9675 set_has_httpaddress();
9676 } else {
9677 clear_has_httpaddress();
9678 }
9679 httpaddress_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), httpaddress);
9680 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.NamenodeRegistrationProto.httpAddress)
9681}
9682
9683// required .Hdfs.Internal.StorageInfoProto storageInfo = 3;
9684inline bool NamenodeRegistrationProto::has_storageinfo() const {
9685 return (_has_bits_[0] & 0x00000004u) != 0;
9686}
9687inline void NamenodeRegistrationProto::set_has_storageinfo() {
9688 _has_bits_[0] |= 0x00000004u;
9689}
9690inline void NamenodeRegistrationProto::clear_has_storageinfo() {
9691 _has_bits_[0] &= ~0x00000004u;
9692}
9693inline void NamenodeRegistrationProto::clear_storageinfo() {
9694 if (storageinfo_ != NULL) storageinfo_->Clear();
9695 clear_has_storageinfo();
9696}
9697inline const ::Hdfs::Internal::StorageInfoProto& NamenodeRegistrationProto::_internal_storageinfo() const {
9698 return *storageinfo_;
9699}
9700inline const ::Hdfs::Internal::StorageInfoProto& NamenodeRegistrationProto::storageinfo() const {
9701 const ::Hdfs::Internal::StorageInfoProto* p = storageinfo_;
9702 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamenodeRegistrationProto.storageInfo)
9703 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::StorageInfoProto*>(
9704 &::Hdfs::Internal::_StorageInfoProto_default_instance_);
9705}
9706inline ::Hdfs::Internal::StorageInfoProto* NamenodeRegistrationProto::release_storageinfo() {
9707 // @@protoc_insertion_point(field_release:Hdfs.Internal.NamenodeRegistrationProto.storageInfo)
9708 clear_has_storageinfo();
9709 ::Hdfs::Internal::StorageInfoProto* temp = storageinfo_;
9710 storageinfo_ = NULL;
9711 return temp;
9712}
9713inline ::Hdfs::Internal::StorageInfoProto* NamenodeRegistrationProto::mutable_storageinfo() {
9714 set_has_storageinfo();
9715 if (storageinfo_ == NULL) {
9716 auto* p = CreateMaybeMessage<::Hdfs::Internal::StorageInfoProto>(GetArenaNoVirtual());
9717 storageinfo_ = p;
9718 }
9719 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.NamenodeRegistrationProto.storageInfo)
9720 return storageinfo_;
9721}
9722inline void NamenodeRegistrationProto::set_allocated_storageinfo(::Hdfs::Internal::StorageInfoProto* storageinfo) {
9723 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
9724 if (message_arena == NULL) {
9725 delete storageinfo_;
9726 }
9727 if (storageinfo) {
9728 ::google::protobuf::Arena* submessage_arena = NULL;
9729 if (message_arena != submessage_arena) {
9730 storageinfo = ::google::protobuf::internal::GetOwnedMessage(
9731 message_arena, storageinfo, submessage_arena);
9732 }
9733 set_has_storageinfo();
9734 } else {
9735 clear_has_storageinfo();
9736 }
9737 storageinfo_ = storageinfo;
9738 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.NamenodeRegistrationProto.storageInfo)
9739}
9740
9741// optional .Hdfs.Internal.NamenodeRegistrationProto.NamenodeRoleProto role = 4 [default = NAMENODE];
9742inline bool NamenodeRegistrationProto::has_role() const {
9743 return (_has_bits_[0] & 0x00000008u) != 0;
9744}
9745inline void NamenodeRegistrationProto::set_has_role() {
9746 _has_bits_[0] |= 0x00000008u;
9747}
9748inline void NamenodeRegistrationProto::clear_has_role() {
9749 _has_bits_[0] &= ~0x00000008u;
9750}
9751inline void NamenodeRegistrationProto::clear_role() {
9752 role_ = 1;
9753 clear_has_role();
9754}
9755inline ::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto NamenodeRegistrationProto::role() const {
9756 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamenodeRegistrationProto.role)
9757 return static_cast< ::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto >(role_);
9758}
9759inline void NamenodeRegistrationProto::set_role(::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto value) {
9760 assert(::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto_IsValid(value));
9761 set_has_role();
9762 role_ = value;
9763 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamenodeRegistrationProto.role)
9764}
9765
9766// -------------------------------------------------------------------
9767
9768// CheckpointSignatureProto
9769
9770// required string blockPoolId = 1;
9771inline bool CheckpointSignatureProto::has_blockpoolid() const {
9772 return (_has_bits_[0] & 0x00000001u) != 0;
9773}
9774inline void CheckpointSignatureProto::set_has_blockpoolid() {
9775 _has_bits_[0] |= 0x00000001u;
9776}
9777inline void CheckpointSignatureProto::clear_has_blockpoolid() {
9778 _has_bits_[0] &= ~0x00000001u;
9779}
9780inline void CheckpointSignatureProto::clear_blockpoolid() {
9781 blockpoolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9782 clear_has_blockpoolid();
9783}
9784inline const ::std::string& CheckpointSignatureProto::blockpoolid() const {
9785 // @@protoc_insertion_point(field_get:Hdfs.Internal.CheckpointSignatureProto.blockPoolId)
9786 return blockpoolid_.GetNoArena();
9787}
9788inline void CheckpointSignatureProto::set_blockpoolid(const ::std::string& value) {
9789 set_has_blockpoolid();
9790 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
9791 // @@protoc_insertion_point(field_set:Hdfs.Internal.CheckpointSignatureProto.blockPoolId)
9792}
9793#if LANG_CXX11
9794inline void CheckpointSignatureProto::set_blockpoolid(::std::string&& value) {
9795 set_has_blockpoolid();
9796 blockpoolid_.SetNoArena(
9797 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
9798 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.CheckpointSignatureProto.blockPoolId)
9799}
9800#endif
9801inline void CheckpointSignatureProto::set_blockpoolid(const char* value) {
9802 GOOGLE_DCHECK(value != NULL);
9803 set_has_blockpoolid();
9804 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
9805 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.CheckpointSignatureProto.blockPoolId)
9806}
9807inline void CheckpointSignatureProto::set_blockpoolid(const char* value, size_t size) {
9808 set_has_blockpoolid();
9809 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
9810 ::std::string(reinterpret_cast<const char*>(value), size));
9811 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.CheckpointSignatureProto.blockPoolId)
9812}
9813inline ::std::string* CheckpointSignatureProto::mutable_blockpoolid() {
9814 set_has_blockpoolid();
9815 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.CheckpointSignatureProto.blockPoolId)
9816 return blockpoolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9817}
9818inline ::std::string* CheckpointSignatureProto::release_blockpoolid() {
9819 // @@protoc_insertion_point(field_release:Hdfs.Internal.CheckpointSignatureProto.blockPoolId)
9820 if (!has_blockpoolid()) {
9821 return NULL;
9822 }
9823 clear_has_blockpoolid();
9824 return blockpoolid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
9825}
9826inline void CheckpointSignatureProto::set_allocated_blockpoolid(::std::string* blockpoolid) {
9827 if (blockpoolid != NULL) {
9828 set_has_blockpoolid();
9829 } else {
9830 clear_has_blockpoolid();
9831 }
9832 blockpoolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockpoolid);
9833 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.CheckpointSignatureProto.blockPoolId)
9834}
9835
9836// required uint64 mostRecentCheckpointTxId = 2;
9837inline bool CheckpointSignatureProto::has_mostrecentcheckpointtxid() const {
9838 return (_has_bits_[0] & 0x00000004u) != 0;
9839}
9840inline void CheckpointSignatureProto::set_has_mostrecentcheckpointtxid() {
9841 _has_bits_[0] |= 0x00000004u;
9842}
9843inline void CheckpointSignatureProto::clear_has_mostrecentcheckpointtxid() {
9844 _has_bits_[0] &= ~0x00000004u;
9845}
9846inline void CheckpointSignatureProto::clear_mostrecentcheckpointtxid() {
9847 mostrecentcheckpointtxid_ = GOOGLE_ULONGLONG(0);
9848 clear_has_mostrecentcheckpointtxid();
9849}
9850inline ::google::protobuf::uint64 CheckpointSignatureProto::mostrecentcheckpointtxid() const {
9851 // @@protoc_insertion_point(field_get:Hdfs.Internal.CheckpointSignatureProto.mostRecentCheckpointTxId)
9852 return mostrecentcheckpointtxid_;
9853}
9854inline void CheckpointSignatureProto::set_mostrecentcheckpointtxid(::google::protobuf::uint64 value) {
9855 set_has_mostrecentcheckpointtxid();
9856 mostrecentcheckpointtxid_ = value;
9857 // @@protoc_insertion_point(field_set:Hdfs.Internal.CheckpointSignatureProto.mostRecentCheckpointTxId)
9858}
9859
9860// required uint64 curSegmentTxId = 3;
9861inline bool CheckpointSignatureProto::has_cursegmenttxid() const {
9862 return (_has_bits_[0] & 0x00000008u) != 0;
9863}
9864inline void CheckpointSignatureProto::set_has_cursegmenttxid() {
9865 _has_bits_[0] |= 0x00000008u;
9866}
9867inline void CheckpointSignatureProto::clear_has_cursegmenttxid() {
9868 _has_bits_[0] &= ~0x00000008u;
9869}
9870inline void CheckpointSignatureProto::clear_cursegmenttxid() {
9871 cursegmenttxid_ = GOOGLE_ULONGLONG(0);
9872 clear_has_cursegmenttxid();
9873}
9874inline ::google::protobuf::uint64 CheckpointSignatureProto::cursegmenttxid() const {
9875 // @@protoc_insertion_point(field_get:Hdfs.Internal.CheckpointSignatureProto.curSegmentTxId)
9876 return cursegmenttxid_;
9877}
9878inline void CheckpointSignatureProto::set_cursegmenttxid(::google::protobuf::uint64 value) {
9879 set_has_cursegmenttxid();
9880 cursegmenttxid_ = value;
9881 // @@protoc_insertion_point(field_set:Hdfs.Internal.CheckpointSignatureProto.curSegmentTxId)
9882}
9883
9884// required .Hdfs.Internal.StorageInfoProto storageInfo = 4;
9885inline bool CheckpointSignatureProto::has_storageinfo() const {
9886 return (_has_bits_[0] & 0x00000002u) != 0;
9887}
9888inline void CheckpointSignatureProto::set_has_storageinfo() {
9889 _has_bits_[0] |= 0x00000002u;
9890}
9891inline void CheckpointSignatureProto::clear_has_storageinfo() {
9892 _has_bits_[0] &= ~0x00000002u;
9893}
9894inline void CheckpointSignatureProto::clear_storageinfo() {
9895 if (storageinfo_ != NULL) storageinfo_->Clear();
9896 clear_has_storageinfo();
9897}
9898inline const ::Hdfs::Internal::StorageInfoProto& CheckpointSignatureProto::_internal_storageinfo() const {
9899 return *storageinfo_;
9900}
9901inline const ::Hdfs::Internal::StorageInfoProto& CheckpointSignatureProto::storageinfo() const {
9902 const ::Hdfs::Internal::StorageInfoProto* p = storageinfo_;
9903 // @@protoc_insertion_point(field_get:Hdfs.Internal.CheckpointSignatureProto.storageInfo)
9904 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::StorageInfoProto*>(
9905 &::Hdfs::Internal::_StorageInfoProto_default_instance_);
9906}
9907inline ::Hdfs::Internal::StorageInfoProto* CheckpointSignatureProto::release_storageinfo() {
9908 // @@protoc_insertion_point(field_release:Hdfs.Internal.CheckpointSignatureProto.storageInfo)
9909 clear_has_storageinfo();
9910 ::Hdfs::Internal::StorageInfoProto* temp = storageinfo_;
9911 storageinfo_ = NULL;
9912 return temp;
9913}
9914inline ::Hdfs::Internal::StorageInfoProto* CheckpointSignatureProto::mutable_storageinfo() {
9915 set_has_storageinfo();
9916 if (storageinfo_ == NULL) {
9917 auto* p = CreateMaybeMessage<::Hdfs::Internal::StorageInfoProto>(GetArenaNoVirtual());
9918 storageinfo_ = p;
9919 }
9920 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.CheckpointSignatureProto.storageInfo)
9921 return storageinfo_;
9922}
9923inline void CheckpointSignatureProto::set_allocated_storageinfo(::Hdfs::Internal::StorageInfoProto* storageinfo) {
9924 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
9925 if (message_arena == NULL) {
9926 delete storageinfo_;
9927 }
9928 if (storageinfo) {
9929 ::google::protobuf::Arena* submessage_arena = NULL;
9930 if (message_arena != submessage_arena) {
9931 storageinfo = ::google::protobuf::internal::GetOwnedMessage(
9932 message_arena, storageinfo, submessage_arena);
9933 }
9934 set_has_storageinfo();
9935 } else {
9936 clear_has_storageinfo();
9937 }
9938 storageinfo_ = storageinfo;
9939 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.CheckpointSignatureProto.storageInfo)
9940}
9941
9942// -------------------------------------------------------------------
9943
9944// NamenodeCommandProto
9945
9946// required uint32 action = 1;
9947inline bool NamenodeCommandProto::has_action() const {
9948 return (_has_bits_[0] & 0x00000002u) != 0;
9949}
9950inline void NamenodeCommandProto::set_has_action() {
9951 _has_bits_[0] |= 0x00000002u;
9952}
9953inline void NamenodeCommandProto::clear_has_action() {
9954 _has_bits_[0] &= ~0x00000002u;
9955}
9956inline void NamenodeCommandProto::clear_action() {
9957 action_ = 0u;
9958 clear_has_action();
9959}
9960inline ::google::protobuf::uint32 NamenodeCommandProto::action() const {
9961 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamenodeCommandProto.action)
9962 return action_;
9963}
9964inline void NamenodeCommandProto::set_action(::google::protobuf::uint32 value) {
9965 set_has_action();
9966 action_ = value;
9967 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamenodeCommandProto.action)
9968}
9969
9970// required .Hdfs.Internal.NamenodeCommandProto.Type type = 2;
9971inline bool NamenodeCommandProto::has_type() const {
9972 return (_has_bits_[0] & 0x00000004u) != 0;
9973}
9974inline void NamenodeCommandProto::set_has_type() {
9975 _has_bits_[0] |= 0x00000004u;
9976}
9977inline void NamenodeCommandProto::clear_has_type() {
9978 _has_bits_[0] &= ~0x00000004u;
9979}
9980inline void NamenodeCommandProto::clear_type() {
9981 type_ = 0;
9982 clear_has_type();
9983}
9984inline ::Hdfs::Internal::NamenodeCommandProto_Type NamenodeCommandProto::type() const {
9985 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamenodeCommandProto.type)
9986 return static_cast< ::Hdfs::Internal::NamenodeCommandProto_Type >(type_);
9987}
9988inline void NamenodeCommandProto::set_type(::Hdfs::Internal::NamenodeCommandProto_Type value) {
9989 assert(::Hdfs::Internal::NamenodeCommandProto_Type_IsValid(value));
9990 set_has_type();
9991 type_ = value;
9992 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamenodeCommandProto.type)
9993}
9994
9995// optional .Hdfs.Internal.CheckpointCommandProto checkpointCmd = 3;
9996inline bool NamenodeCommandProto::has_checkpointcmd() const {
9997 return (_has_bits_[0] & 0x00000001u) != 0;
9998}
9999inline void NamenodeCommandProto::set_has_checkpointcmd() {
10000 _has_bits_[0] |= 0x00000001u;
10001}
10002inline void NamenodeCommandProto::clear_has_checkpointcmd() {
10003 _has_bits_[0] &= ~0x00000001u;
10004}
10005inline void NamenodeCommandProto::clear_checkpointcmd() {
10006 if (checkpointcmd_ != NULL) checkpointcmd_->Clear();
10007 clear_has_checkpointcmd();
10008}
10009inline const ::Hdfs::Internal::CheckpointCommandProto& NamenodeCommandProto::_internal_checkpointcmd() const {
10010 return *checkpointcmd_;
10011}
10012inline const ::Hdfs::Internal::CheckpointCommandProto& NamenodeCommandProto::checkpointcmd() const {
10013 const ::Hdfs::Internal::CheckpointCommandProto* p = checkpointcmd_;
10014 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamenodeCommandProto.checkpointCmd)
10015 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::CheckpointCommandProto*>(
10016 &::Hdfs::Internal::_CheckpointCommandProto_default_instance_);
10017}
10018inline ::Hdfs::Internal::CheckpointCommandProto* NamenodeCommandProto::release_checkpointcmd() {
10019 // @@protoc_insertion_point(field_release:Hdfs.Internal.NamenodeCommandProto.checkpointCmd)
10020 clear_has_checkpointcmd();
10021 ::Hdfs::Internal::CheckpointCommandProto* temp = checkpointcmd_;
10022 checkpointcmd_ = NULL;
10023 return temp;
10024}
10025inline ::Hdfs::Internal::CheckpointCommandProto* NamenodeCommandProto::mutable_checkpointcmd() {
10026 set_has_checkpointcmd();
10027 if (checkpointcmd_ == NULL) {
10028 auto* p = CreateMaybeMessage<::Hdfs::Internal::CheckpointCommandProto>(GetArenaNoVirtual());
10029 checkpointcmd_ = p;
10030 }
10031 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.NamenodeCommandProto.checkpointCmd)
10032 return checkpointcmd_;
10033}
10034inline void NamenodeCommandProto::set_allocated_checkpointcmd(::Hdfs::Internal::CheckpointCommandProto* checkpointcmd) {
10035 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
10036 if (message_arena == NULL) {
10037 delete checkpointcmd_;
10038 }
10039 if (checkpointcmd) {
10040 ::google::protobuf::Arena* submessage_arena = NULL;
10041 if (message_arena != submessage_arena) {
10042 checkpointcmd = ::google::protobuf::internal::GetOwnedMessage(
10043 message_arena, checkpointcmd, submessage_arena);
10044 }
10045 set_has_checkpointcmd();
10046 } else {
10047 clear_has_checkpointcmd();
10048 }
10049 checkpointcmd_ = checkpointcmd;
10050 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.NamenodeCommandProto.checkpointCmd)
10051}
10052
10053// -------------------------------------------------------------------
10054
10055// CheckpointCommandProto
10056
10057// required .Hdfs.Internal.CheckpointSignatureProto signature = 1;
10058inline bool CheckpointCommandProto::has_signature() const {
10059 return (_has_bits_[0] & 0x00000001u) != 0;
10060}
10061inline void CheckpointCommandProto::set_has_signature() {
10062 _has_bits_[0] |= 0x00000001u;
10063}
10064inline void CheckpointCommandProto::clear_has_signature() {
10065 _has_bits_[0] &= ~0x00000001u;
10066}
10067inline void CheckpointCommandProto::clear_signature() {
10068 if (signature_ != NULL) signature_->Clear();
10069 clear_has_signature();
10070}
10071inline const ::Hdfs::Internal::CheckpointSignatureProto& CheckpointCommandProto::_internal_signature() const {
10072 return *signature_;
10073}
10074inline const ::Hdfs::Internal::CheckpointSignatureProto& CheckpointCommandProto::signature() const {
10075 const ::Hdfs::Internal::CheckpointSignatureProto* p = signature_;
10076 // @@protoc_insertion_point(field_get:Hdfs.Internal.CheckpointCommandProto.signature)
10077 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::CheckpointSignatureProto*>(
10078 &::Hdfs::Internal::_CheckpointSignatureProto_default_instance_);
10079}
10080inline ::Hdfs::Internal::CheckpointSignatureProto* CheckpointCommandProto::release_signature() {
10081 // @@protoc_insertion_point(field_release:Hdfs.Internal.CheckpointCommandProto.signature)
10082 clear_has_signature();
10083 ::Hdfs::Internal::CheckpointSignatureProto* temp = signature_;
10084 signature_ = NULL;
10085 return temp;
10086}
10087inline ::Hdfs::Internal::CheckpointSignatureProto* CheckpointCommandProto::mutable_signature() {
10088 set_has_signature();
10089 if (signature_ == NULL) {
10090 auto* p = CreateMaybeMessage<::Hdfs::Internal::CheckpointSignatureProto>(GetArenaNoVirtual());
10091 signature_ = p;
10092 }
10093 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.CheckpointCommandProto.signature)
10094 return signature_;
10095}
10096inline void CheckpointCommandProto::set_allocated_signature(::Hdfs::Internal::CheckpointSignatureProto* signature) {
10097 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
10098 if (message_arena == NULL) {
10099 delete signature_;
10100 }
10101 if (signature) {
10102 ::google::protobuf::Arena* submessage_arena = NULL;
10103 if (message_arena != submessage_arena) {
10104 signature = ::google::protobuf::internal::GetOwnedMessage(
10105 message_arena, signature, submessage_arena);
10106 }
10107 set_has_signature();
10108 } else {
10109 clear_has_signature();
10110 }
10111 signature_ = signature;
10112 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.CheckpointCommandProto.signature)
10113}
10114
10115// required bool needToReturnImage = 2;
10116inline bool CheckpointCommandProto::has_needtoreturnimage() const {
10117 return (_has_bits_[0] & 0x00000002u) != 0;
10118}
10119inline void CheckpointCommandProto::set_has_needtoreturnimage() {
10120 _has_bits_[0] |= 0x00000002u;
10121}
10122inline void CheckpointCommandProto::clear_has_needtoreturnimage() {
10123 _has_bits_[0] &= ~0x00000002u;
10124}
10125inline void CheckpointCommandProto::clear_needtoreturnimage() {
10126 needtoreturnimage_ = false;
10127 clear_has_needtoreturnimage();
10128}
10129inline bool CheckpointCommandProto::needtoreturnimage() const {
10130 // @@protoc_insertion_point(field_get:Hdfs.Internal.CheckpointCommandProto.needToReturnImage)
10131 return needtoreturnimage_;
10132}
10133inline void CheckpointCommandProto::set_needtoreturnimage(bool value) {
10134 set_has_needtoreturnimage();
10135 needtoreturnimage_ = value;
10136 // @@protoc_insertion_point(field_set:Hdfs.Internal.CheckpointCommandProto.needToReturnImage)
10137}
10138
10139// -------------------------------------------------------------------
10140
10141// BlockProto
10142
10143// required uint64 blockId = 1;
10144inline bool BlockProto::has_blockid() const {
10145 return (_has_bits_[0] & 0x00000001u) != 0;
10146}
10147inline void BlockProto::set_has_blockid() {
10148 _has_bits_[0] |= 0x00000001u;
10149}
10150inline void BlockProto::clear_has_blockid() {
10151 _has_bits_[0] &= ~0x00000001u;
10152}
10153inline void BlockProto::clear_blockid() {
10154 blockid_ = GOOGLE_ULONGLONG(0);
10155 clear_has_blockid();
10156}
10157inline ::google::protobuf::uint64 BlockProto::blockid() const {
10158 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockProto.blockId)
10159 return blockid_;
10160}
10161inline void BlockProto::set_blockid(::google::protobuf::uint64 value) {
10162 set_has_blockid();
10163 blockid_ = value;
10164 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockProto.blockId)
10165}
10166
10167// required uint64 genStamp = 2;
10168inline bool BlockProto::has_genstamp() const {
10169 return (_has_bits_[0] & 0x00000002u) != 0;
10170}
10171inline void BlockProto::set_has_genstamp() {
10172 _has_bits_[0] |= 0x00000002u;
10173}
10174inline void BlockProto::clear_has_genstamp() {
10175 _has_bits_[0] &= ~0x00000002u;
10176}
10177inline void BlockProto::clear_genstamp() {
10178 genstamp_ = GOOGLE_ULONGLONG(0);
10179 clear_has_genstamp();
10180}
10181inline ::google::protobuf::uint64 BlockProto::genstamp() const {
10182 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockProto.genStamp)
10183 return genstamp_;
10184}
10185inline void BlockProto::set_genstamp(::google::protobuf::uint64 value) {
10186 set_has_genstamp();
10187 genstamp_ = value;
10188 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockProto.genStamp)
10189}
10190
10191// optional uint64 numBytes = 3 [default = 0];
10192inline bool BlockProto::has_numbytes() const {
10193 return (_has_bits_[0] & 0x00000004u) != 0;
10194}
10195inline void BlockProto::set_has_numbytes() {
10196 _has_bits_[0] |= 0x00000004u;
10197}
10198inline void BlockProto::clear_has_numbytes() {
10199 _has_bits_[0] &= ~0x00000004u;
10200}
10201inline void BlockProto::clear_numbytes() {
10202 numbytes_ = GOOGLE_ULONGLONG(0);
10203 clear_has_numbytes();
10204}
10205inline ::google::protobuf::uint64 BlockProto::numbytes() const {
10206 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockProto.numBytes)
10207 return numbytes_;
10208}
10209inline void BlockProto::set_numbytes(::google::protobuf::uint64 value) {
10210 set_has_numbytes();
10211 numbytes_ = value;
10212 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockProto.numBytes)
10213}
10214
10215// -------------------------------------------------------------------
10216
10217// BlockWithLocationsProto
10218
10219// required .Hdfs.Internal.BlockProto block = 1;
10220inline bool BlockWithLocationsProto::has_block() const {
10221 return (_has_bits_[0] & 0x00000001u) != 0;
10222}
10223inline void BlockWithLocationsProto::set_has_block() {
10224 _has_bits_[0] |= 0x00000001u;
10225}
10226inline void BlockWithLocationsProto::clear_has_block() {
10227 _has_bits_[0] &= ~0x00000001u;
10228}
10229inline void BlockWithLocationsProto::clear_block() {
10230 if (block_ != NULL) block_->Clear();
10231 clear_has_block();
10232}
10233inline const ::Hdfs::Internal::BlockProto& BlockWithLocationsProto::_internal_block() const {
10234 return *block_;
10235}
10236inline const ::Hdfs::Internal::BlockProto& BlockWithLocationsProto::block() const {
10237 const ::Hdfs::Internal::BlockProto* p = block_;
10238 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockWithLocationsProto.block)
10239 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::BlockProto*>(
10240 &::Hdfs::Internal::_BlockProto_default_instance_);
10241}
10242inline ::Hdfs::Internal::BlockProto* BlockWithLocationsProto::release_block() {
10243 // @@protoc_insertion_point(field_release:Hdfs.Internal.BlockWithLocationsProto.block)
10244 clear_has_block();
10245 ::Hdfs::Internal::BlockProto* temp = block_;
10246 block_ = NULL;
10247 return temp;
10248}
10249inline ::Hdfs::Internal::BlockProto* BlockWithLocationsProto::mutable_block() {
10250 set_has_block();
10251 if (block_ == NULL) {
10252 auto* p = CreateMaybeMessage<::Hdfs::Internal::BlockProto>(GetArenaNoVirtual());
10253 block_ = p;
10254 }
10255 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlockWithLocationsProto.block)
10256 return block_;
10257}
10258inline void BlockWithLocationsProto::set_allocated_block(::Hdfs::Internal::BlockProto* block) {
10259 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
10260 if (message_arena == NULL) {
10261 delete block_;
10262 }
10263 if (block) {
10264 ::google::protobuf::Arena* submessage_arena = NULL;
10265 if (message_arena != submessage_arena) {
10266 block = ::google::protobuf::internal::GetOwnedMessage(
10267 message_arena, block, submessage_arena);
10268 }
10269 set_has_block();
10270 } else {
10271 clear_has_block();
10272 }
10273 block_ = block;
10274 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.BlockWithLocationsProto.block)
10275}
10276
10277// repeated string datanodeUuids = 2;
10278inline int BlockWithLocationsProto::datanodeuuids_size() const {
10279 return datanodeuuids_.size();
10280}
10281inline void BlockWithLocationsProto::clear_datanodeuuids() {
10282 datanodeuuids_.Clear();
10283}
10284inline const ::std::string& BlockWithLocationsProto::datanodeuuids(int index) const {
10285 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10286 return datanodeuuids_.Get(index);
10287}
10288inline ::std::string* BlockWithLocationsProto::mutable_datanodeuuids(int index) {
10289 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10290 return datanodeuuids_.Mutable(index);
10291}
10292inline void BlockWithLocationsProto::set_datanodeuuids(int index, const ::std::string& value) {
10293 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10294 datanodeuuids_.Mutable(index)->assign(value);
10295}
10296#if LANG_CXX11
10297inline void BlockWithLocationsProto::set_datanodeuuids(int index, ::std::string&& value) {
10298 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10299 datanodeuuids_.Mutable(index)->assign(std::move(value));
10300}
10301#endif
10302inline void BlockWithLocationsProto::set_datanodeuuids(int index, const char* value) {
10303 GOOGLE_DCHECK(value != NULL);
10304 datanodeuuids_.Mutable(index)->assign(value);
10305 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10306}
10307inline void BlockWithLocationsProto::set_datanodeuuids(int index, const char* value, size_t size) {
10308 datanodeuuids_.Mutable(index)->assign(
10309 reinterpret_cast<const char*>(value), size);
10310 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10311}
10312inline ::std::string* BlockWithLocationsProto::add_datanodeuuids() {
10313 // @@protoc_insertion_point(field_add_mutable:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10314 return datanodeuuids_.Add();
10315}
10316inline void BlockWithLocationsProto::add_datanodeuuids(const ::std::string& value) {
10317 datanodeuuids_.Add()->assign(value);
10318 // @@protoc_insertion_point(field_add:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10319}
10320#if LANG_CXX11
10321inline void BlockWithLocationsProto::add_datanodeuuids(::std::string&& value) {
10322 datanodeuuids_.Add(std::move(value));
10323 // @@protoc_insertion_point(field_add:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10324}
10325#endif
10326inline void BlockWithLocationsProto::add_datanodeuuids(const char* value) {
10327 GOOGLE_DCHECK(value != NULL);
10328 datanodeuuids_.Add()->assign(value);
10329 // @@protoc_insertion_point(field_add_char:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10330}
10331inline void BlockWithLocationsProto::add_datanodeuuids(const char* value, size_t size) {
10332 datanodeuuids_.Add()->assign(reinterpret_cast<const char*>(value), size);
10333 // @@protoc_insertion_point(field_add_pointer:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10334}
10335inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
10336BlockWithLocationsProto::datanodeuuids() const {
10337 // @@protoc_insertion_point(field_list:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10338 return datanodeuuids_;
10339}
10340inline ::google::protobuf::RepeatedPtrField< ::std::string>*
10341BlockWithLocationsProto::mutable_datanodeuuids() {
10342 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.BlockWithLocationsProto.datanodeUuids)
10343 return &datanodeuuids_;
10344}
10345
10346// repeated string storageUuids = 3;
10347inline int BlockWithLocationsProto::storageuuids_size() const {
10348 return storageuuids_.size();
10349}
10350inline void BlockWithLocationsProto::clear_storageuuids() {
10351 storageuuids_.Clear();
10352}
10353inline const ::std::string& BlockWithLocationsProto::storageuuids(int index) const {
10354 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10355 return storageuuids_.Get(index);
10356}
10357inline ::std::string* BlockWithLocationsProto::mutable_storageuuids(int index) {
10358 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10359 return storageuuids_.Mutable(index);
10360}
10361inline void BlockWithLocationsProto::set_storageuuids(int index, const ::std::string& value) {
10362 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10363 storageuuids_.Mutable(index)->assign(value);
10364}
10365#if LANG_CXX11
10366inline void BlockWithLocationsProto::set_storageuuids(int index, ::std::string&& value) {
10367 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10368 storageuuids_.Mutable(index)->assign(std::move(value));
10369}
10370#endif
10371inline void BlockWithLocationsProto::set_storageuuids(int index, const char* value) {
10372 GOOGLE_DCHECK(value != NULL);
10373 storageuuids_.Mutable(index)->assign(value);
10374 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10375}
10376inline void BlockWithLocationsProto::set_storageuuids(int index, const char* value, size_t size) {
10377 storageuuids_.Mutable(index)->assign(
10378 reinterpret_cast<const char*>(value), size);
10379 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10380}
10381inline ::std::string* BlockWithLocationsProto::add_storageuuids() {
10382 // @@protoc_insertion_point(field_add_mutable:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10383 return storageuuids_.Add();
10384}
10385inline void BlockWithLocationsProto::add_storageuuids(const ::std::string& value) {
10386 storageuuids_.Add()->assign(value);
10387 // @@protoc_insertion_point(field_add:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10388}
10389#if LANG_CXX11
10390inline void BlockWithLocationsProto::add_storageuuids(::std::string&& value) {
10391 storageuuids_.Add(std::move(value));
10392 // @@protoc_insertion_point(field_add:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10393}
10394#endif
10395inline void BlockWithLocationsProto::add_storageuuids(const char* value) {
10396 GOOGLE_DCHECK(value != NULL);
10397 storageuuids_.Add()->assign(value);
10398 // @@protoc_insertion_point(field_add_char:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10399}
10400inline void BlockWithLocationsProto::add_storageuuids(const char* value, size_t size) {
10401 storageuuids_.Add()->assign(reinterpret_cast<const char*>(value), size);
10402 // @@protoc_insertion_point(field_add_pointer:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10403}
10404inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
10405BlockWithLocationsProto::storageuuids() const {
10406 // @@protoc_insertion_point(field_list:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10407 return storageuuids_;
10408}
10409inline ::google::protobuf::RepeatedPtrField< ::std::string>*
10410BlockWithLocationsProto::mutable_storageuuids() {
10411 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.BlockWithLocationsProto.storageUuids)
10412 return &storageuuids_;
10413}
10414
10415// -------------------------------------------------------------------
10416
10417// BlocksWithLocationsProto
10418
10419// repeated .Hdfs.Internal.BlockWithLocationsProto blocks = 1;
10420inline int BlocksWithLocationsProto::blocks_size() const {
10421 return blocks_.size();
10422}
10423inline void BlocksWithLocationsProto::clear_blocks() {
10424 blocks_.Clear();
10425}
10426inline ::Hdfs::Internal::BlockWithLocationsProto* BlocksWithLocationsProto::mutable_blocks(int index) {
10427 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlocksWithLocationsProto.blocks)
10428 return blocks_.Mutable(index);
10429}
10430inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockWithLocationsProto >*
10431BlocksWithLocationsProto::mutable_blocks() {
10432 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.BlocksWithLocationsProto.blocks)
10433 return &blocks_;
10434}
10435inline const ::Hdfs::Internal::BlockWithLocationsProto& BlocksWithLocationsProto::blocks(int index) const {
10436 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlocksWithLocationsProto.blocks)
10437 return blocks_.Get(index);
10438}
10439inline ::Hdfs::Internal::BlockWithLocationsProto* BlocksWithLocationsProto::add_blocks() {
10440 // @@protoc_insertion_point(field_add:Hdfs.Internal.BlocksWithLocationsProto.blocks)
10441 return blocks_.Add();
10442}
10443inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockWithLocationsProto >&
10444BlocksWithLocationsProto::blocks() const {
10445 // @@protoc_insertion_point(field_list:Hdfs.Internal.BlocksWithLocationsProto.blocks)
10446 return blocks_;
10447}
10448
10449// -------------------------------------------------------------------
10450
10451// RemoteEditLogProto
10452
10453// required uint64 startTxId = 1;
10454inline bool RemoteEditLogProto::has_starttxid() const {
10455 return (_has_bits_[0] & 0x00000001u) != 0;
10456}
10457inline void RemoteEditLogProto::set_has_starttxid() {
10458 _has_bits_[0] |= 0x00000001u;
10459}
10460inline void RemoteEditLogProto::clear_has_starttxid() {
10461 _has_bits_[0] &= ~0x00000001u;
10462}
10463inline void RemoteEditLogProto::clear_starttxid() {
10464 starttxid_ = GOOGLE_ULONGLONG(0);
10465 clear_has_starttxid();
10466}
10467inline ::google::protobuf::uint64 RemoteEditLogProto::starttxid() const {
10468 // @@protoc_insertion_point(field_get:Hdfs.Internal.RemoteEditLogProto.startTxId)
10469 return starttxid_;
10470}
10471inline void RemoteEditLogProto::set_starttxid(::google::protobuf::uint64 value) {
10472 set_has_starttxid();
10473 starttxid_ = value;
10474 // @@protoc_insertion_point(field_set:Hdfs.Internal.RemoteEditLogProto.startTxId)
10475}
10476
10477// required uint64 endTxId = 2;
10478inline bool RemoteEditLogProto::has_endtxid() const {
10479 return (_has_bits_[0] & 0x00000002u) != 0;
10480}
10481inline void RemoteEditLogProto::set_has_endtxid() {
10482 _has_bits_[0] |= 0x00000002u;
10483}
10484inline void RemoteEditLogProto::clear_has_endtxid() {
10485 _has_bits_[0] &= ~0x00000002u;
10486}
10487inline void RemoteEditLogProto::clear_endtxid() {
10488 endtxid_ = GOOGLE_ULONGLONG(0);
10489 clear_has_endtxid();
10490}
10491inline ::google::protobuf::uint64 RemoteEditLogProto::endtxid() const {
10492 // @@protoc_insertion_point(field_get:Hdfs.Internal.RemoteEditLogProto.endTxId)
10493 return endtxid_;
10494}
10495inline void RemoteEditLogProto::set_endtxid(::google::protobuf::uint64 value) {
10496 set_has_endtxid();
10497 endtxid_ = value;
10498 // @@protoc_insertion_point(field_set:Hdfs.Internal.RemoteEditLogProto.endTxId)
10499}
10500
10501// optional bool isInProgress = 3 [default = false];
10502inline bool RemoteEditLogProto::has_isinprogress() const {
10503 return (_has_bits_[0] & 0x00000004u) != 0;
10504}
10505inline void RemoteEditLogProto::set_has_isinprogress() {
10506 _has_bits_[0] |= 0x00000004u;
10507}
10508inline void RemoteEditLogProto::clear_has_isinprogress() {
10509 _has_bits_[0] &= ~0x00000004u;
10510}
10511inline void RemoteEditLogProto::clear_isinprogress() {
10512 isinprogress_ = false;
10513 clear_has_isinprogress();
10514}
10515inline bool RemoteEditLogProto::isinprogress() const {
10516 // @@protoc_insertion_point(field_get:Hdfs.Internal.RemoteEditLogProto.isInProgress)
10517 return isinprogress_;
10518}
10519inline void RemoteEditLogProto::set_isinprogress(bool value) {
10520 set_has_isinprogress();
10521 isinprogress_ = value;
10522 // @@protoc_insertion_point(field_set:Hdfs.Internal.RemoteEditLogProto.isInProgress)
10523}
10524
10525// -------------------------------------------------------------------
10526
10527// RemoteEditLogManifestProto
10528
10529// repeated .Hdfs.Internal.RemoteEditLogProto logs = 1;
10530inline int RemoteEditLogManifestProto::logs_size() const {
10531 return logs_.size();
10532}
10533inline void RemoteEditLogManifestProto::clear_logs() {
10534 logs_.Clear();
10535}
10536inline ::Hdfs::Internal::RemoteEditLogProto* RemoteEditLogManifestProto::mutable_logs(int index) {
10537 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RemoteEditLogManifestProto.logs)
10538 return logs_.Mutable(index);
10539}
10540inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RemoteEditLogProto >*
10541RemoteEditLogManifestProto::mutable_logs() {
10542 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.RemoteEditLogManifestProto.logs)
10543 return &logs_;
10544}
10545inline const ::Hdfs::Internal::RemoteEditLogProto& RemoteEditLogManifestProto::logs(int index) const {
10546 // @@protoc_insertion_point(field_get:Hdfs.Internal.RemoteEditLogManifestProto.logs)
10547 return logs_.Get(index);
10548}
10549inline ::Hdfs::Internal::RemoteEditLogProto* RemoteEditLogManifestProto::add_logs() {
10550 // @@protoc_insertion_point(field_add:Hdfs.Internal.RemoteEditLogManifestProto.logs)
10551 return logs_.Add();
10552}
10553inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RemoteEditLogProto >&
10554RemoteEditLogManifestProto::logs() const {
10555 // @@protoc_insertion_point(field_list:Hdfs.Internal.RemoteEditLogManifestProto.logs)
10556 return logs_;
10557}
10558
10559// -------------------------------------------------------------------
10560
10561// NamespaceInfoProto
10562
10563// required string buildVersion = 1;
10564inline bool NamespaceInfoProto::has_buildversion() const {
10565 return (_has_bits_[0] & 0x00000001u) != 0;
10566}
10567inline void NamespaceInfoProto::set_has_buildversion() {
10568 _has_bits_[0] |= 0x00000001u;
10569}
10570inline void NamespaceInfoProto::clear_has_buildversion() {
10571 _has_bits_[0] &= ~0x00000001u;
10572}
10573inline void NamespaceInfoProto::clear_buildversion() {
10574 buildversion_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10575 clear_has_buildversion();
10576}
10577inline const ::std::string& NamespaceInfoProto::buildversion() const {
10578 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamespaceInfoProto.buildVersion)
10579 return buildversion_.GetNoArena();
10580}
10581inline void NamespaceInfoProto::set_buildversion(const ::std::string& value) {
10582 set_has_buildversion();
10583 buildversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
10584 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamespaceInfoProto.buildVersion)
10585}
10586#if LANG_CXX11
10587inline void NamespaceInfoProto::set_buildversion(::std::string&& value) {
10588 set_has_buildversion();
10589 buildversion_.SetNoArena(
10590 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
10591 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.NamespaceInfoProto.buildVersion)
10592}
10593#endif
10594inline void NamespaceInfoProto::set_buildversion(const char* value) {
10595 GOOGLE_DCHECK(value != NULL);
10596 set_has_buildversion();
10597 buildversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
10598 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.NamespaceInfoProto.buildVersion)
10599}
10600inline void NamespaceInfoProto::set_buildversion(const char* value, size_t size) {
10601 set_has_buildversion();
10602 buildversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
10603 ::std::string(reinterpret_cast<const char*>(value), size));
10604 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.NamespaceInfoProto.buildVersion)
10605}
10606inline ::std::string* NamespaceInfoProto::mutable_buildversion() {
10607 set_has_buildversion();
10608 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.NamespaceInfoProto.buildVersion)
10609 return buildversion_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10610}
10611inline ::std::string* NamespaceInfoProto::release_buildversion() {
10612 // @@protoc_insertion_point(field_release:Hdfs.Internal.NamespaceInfoProto.buildVersion)
10613 if (!has_buildversion()) {
10614 return NULL;
10615 }
10616 clear_has_buildversion();
10617 return buildversion_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10618}
10619inline void NamespaceInfoProto::set_allocated_buildversion(::std::string* buildversion) {
10620 if (buildversion != NULL) {
10621 set_has_buildversion();
10622 } else {
10623 clear_has_buildversion();
10624 }
10625 buildversion_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), buildversion);
10626 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.NamespaceInfoProto.buildVersion)
10627}
10628
10629// required uint32 unused = 2;
10630inline bool NamespaceInfoProto::has_unused() const {
10631 return (_has_bits_[0] & 0x00000010u) != 0;
10632}
10633inline void NamespaceInfoProto::set_has_unused() {
10634 _has_bits_[0] |= 0x00000010u;
10635}
10636inline void NamespaceInfoProto::clear_has_unused() {
10637 _has_bits_[0] &= ~0x00000010u;
10638}
10639inline void NamespaceInfoProto::clear_unused() {
10640 unused_ = 0u;
10641 clear_has_unused();
10642}
10643inline ::google::protobuf::uint32 NamespaceInfoProto::unused() const {
10644 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamespaceInfoProto.unused)
10645 return unused_;
10646}
10647inline void NamespaceInfoProto::set_unused(::google::protobuf::uint32 value) {
10648 set_has_unused();
10649 unused_ = value;
10650 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamespaceInfoProto.unused)
10651}
10652
10653// required string blockPoolID = 3;
10654inline bool NamespaceInfoProto::has_blockpoolid() const {
10655 return (_has_bits_[0] & 0x00000002u) != 0;
10656}
10657inline void NamespaceInfoProto::set_has_blockpoolid() {
10658 _has_bits_[0] |= 0x00000002u;
10659}
10660inline void NamespaceInfoProto::clear_has_blockpoolid() {
10661 _has_bits_[0] &= ~0x00000002u;
10662}
10663inline void NamespaceInfoProto::clear_blockpoolid() {
10664 blockpoolid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10665 clear_has_blockpoolid();
10666}
10667inline const ::std::string& NamespaceInfoProto::blockpoolid() const {
10668 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamespaceInfoProto.blockPoolID)
10669 return blockpoolid_.GetNoArena();
10670}
10671inline void NamespaceInfoProto::set_blockpoolid(const ::std::string& value) {
10672 set_has_blockpoolid();
10673 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
10674 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamespaceInfoProto.blockPoolID)
10675}
10676#if LANG_CXX11
10677inline void NamespaceInfoProto::set_blockpoolid(::std::string&& value) {
10678 set_has_blockpoolid();
10679 blockpoolid_.SetNoArena(
10680 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
10681 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.NamespaceInfoProto.blockPoolID)
10682}
10683#endif
10684inline void NamespaceInfoProto::set_blockpoolid(const char* value) {
10685 GOOGLE_DCHECK(value != NULL);
10686 set_has_blockpoolid();
10687 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
10688 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.NamespaceInfoProto.blockPoolID)
10689}
10690inline void NamespaceInfoProto::set_blockpoolid(const char* value, size_t size) {
10691 set_has_blockpoolid();
10692 blockpoolid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
10693 ::std::string(reinterpret_cast<const char*>(value), size));
10694 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.NamespaceInfoProto.blockPoolID)
10695}
10696inline ::std::string* NamespaceInfoProto::mutable_blockpoolid() {
10697 set_has_blockpoolid();
10698 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.NamespaceInfoProto.blockPoolID)
10699 return blockpoolid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10700}
10701inline ::std::string* NamespaceInfoProto::release_blockpoolid() {
10702 // @@protoc_insertion_point(field_release:Hdfs.Internal.NamespaceInfoProto.blockPoolID)
10703 if (!has_blockpoolid()) {
10704 return NULL;
10705 }
10706 clear_has_blockpoolid();
10707 return blockpoolid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10708}
10709inline void NamespaceInfoProto::set_allocated_blockpoolid(::std::string* blockpoolid) {
10710 if (blockpoolid != NULL) {
10711 set_has_blockpoolid();
10712 } else {
10713 clear_has_blockpoolid();
10714 }
10715 blockpoolid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockpoolid);
10716 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.NamespaceInfoProto.blockPoolID)
10717}
10718
10719// required .Hdfs.Internal.StorageInfoProto storageInfo = 4;
10720inline bool NamespaceInfoProto::has_storageinfo() const {
10721 return (_has_bits_[0] & 0x00000008u) != 0;
10722}
10723inline void NamespaceInfoProto::set_has_storageinfo() {
10724 _has_bits_[0] |= 0x00000008u;
10725}
10726inline void NamespaceInfoProto::clear_has_storageinfo() {
10727 _has_bits_[0] &= ~0x00000008u;
10728}
10729inline void NamespaceInfoProto::clear_storageinfo() {
10730 if (storageinfo_ != NULL) storageinfo_->Clear();
10731 clear_has_storageinfo();
10732}
10733inline const ::Hdfs::Internal::StorageInfoProto& NamespaceInfoProto::_internal_storageinfo() const {
10734 return *storageinfo_;
10735}
10736inline const ::Hdfs::Internal::StorageInfoProto& NamespaceInfoProto::storageinfo() const {
10737 const ::Hdfs::Internal::StorageInfoProto* p = storageinfo_;
10738 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamespaceInfoProto.storageInfo)
10739 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::StorageInfoProto*>(
10740 &::Hdfs::Internal::_StorageInfoProto_default_instance_);
10741}
10742inline ::Hdfs::Internal::StorageInfoProto* NamespaceInfoProto::release_storageinfo() {
10743 // @@protoc_insertion_point(field_release:Hdfs.Internal.NamespaceInfoProto.storageInfo)
10744 clear_has_storageinfo();
10745 ::Hdfs::Internal::StorageInfoProto* temp = storageinfo_;
10746 storageinfo_ = NULL;
10747 return temp;
10748}
10749inline ::Hdfs::Internal::StorageInfoProto* NamespaceInfoProto::mutable_storageinfo() {
10750 set_has_storageinfo();
10751 if (storageinfo_ == NULL) {
10752 auto* p = CreateMaybeMessage<::Hdfs::Internal::StorageInfoProto>(GetArenaNoVirtual());
10753 storageinfo_ = p;
10754 }
10755 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.NamespaceInfoProto.storageInfo)
10756 return storageinfo_;
10757}
10758inline void NamespaceInfoProto::set_allocated_storageinfo(::Hdfs::Internal::StorageInfoProto* storageinfo) {
10759 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
10760 if (message_arena == NULL) {
10761 delete storageinfo_;
10762 }
10763 if (storageinfo) {
10764 ::google::protobuf::Arena* submessage_arena = NULL;
10765 if (message_arena != submessage_arena) {
10766 storageinfo = ::google::protobuf::internal::GetOwnedMessage(
10767 message_arena, storageinfo, submessage_arena);
10768 }
10769 set_has_storageinfo();
10770 } else {
10771 clear_has_storageinfo();
10772 }
10773 storageinfo_ = storageinfo;
10774 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.NamespaceInfoProto.storageInfo)
10775}
10776
10777// required string softwareVersion = 5;
10778inline bool NamespaceInfoProto::has_softwareversion() const {
10779 return (_has_bits_[0] & 0x00000004u) != 0;
10780}
10781inline void NamespaceInfoProto::set_has_softwareversion() {
10782 _has_bits_[0] |= 0x00000004u;
10783}
10784inline void NamespaceInfoProto::clear_has_softwareversion() {
10785 _has_bits_[0] &= ~0x00000004u;
10786}
10787inline void NamespaceInfoProto::clear_softwareversion() {
10788 softwareversion_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10789 clear_has_softwareversion();
10790}
10791inline const ::std::string& NamespaceInfoProto::softwareversion() const {
10792 // @@protoc_insertion_point(field_get:Hdfs.Internal.NamespaceInfoProto.softwareVersion)
10793 return softwareversion_.GetNoArena();
10794}
10795inline void NamespaceInfoProto::set_softwareversion(const ::std::string& value) {
10796 set_has_softwareversion();
10797 softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
10798 // @@protoc_insertion_point(field_set:Hdfs.Internal.NamespaceInfoProto.softwareVersion)
10799}
10800#if LANG_CXX11
10801inline void NamespaceInfoProto::set_softwareversion(::std::string&& value) {
10802 set_has_softwareversion();
10803 softwareversion_.SetNoArena(
10804 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
10805 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.NamespaceInfoProto.softwareVersion)
10806}
10807#endif
10808inline void NamespaceInfoProto::set_softwareversion(const char* value) {
10809 GOOGLE_DCHECK(value != NULL);
10810 set_has_softwareversion();
10811 softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
10812 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.NamespaceInfoProto.softwareVersion)
10813}
10814inline void NamespaceInfoProto::set_softwareversion(const char* value, size_t size) {
10815 set_has_softwareversion();
10816 softwareversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
10817 ::std::string(reinterpret_cast<const char*>(value), size));
10818 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.NamespaceInfoProto.softwareVersion)
10819}
10820inline ::std::string* NamespaceInfoProto::mutable_softwareversion() {
10821 set_has_softwareversion();
10822 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.NamespaceInfoProto.softwareVersion)
10823 return softwareversion_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10824}
10825inline ::std::string* NamespaceInfoProto::release_softwareversion() {
10826 // @@protoc_insertion_point(field_release:Hdfs.Internal.NamespaceInfoProto.softwareVersion)
10827 if (!has_softwareversion()) {
10828 return NULL;
10829 }
10830 clear_has_softwareversion();
10831 return softwareversion_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10832}
10833inline void NamespaceInfoProto::set_allocated_softwareversion(::std::string* softwareversion) {
10834 if (softwareversion != NULL) {
10835 set_has_softwareversion();
10836 } else {
10837 clear_has_softwareversion();
10838 }
10839 softwareversion_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), softwareversion);
10840 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.NamespaceInfoProto.softwareVersion)
10841}
10842
10843// -------------------------------------------------------------------
10844
10845// BlockKeyProto
10846
10847// required uint32 keyId = 1;
10848inline bool BlockKeyProto::has_keyid() const {
10849 return (_has_bits_[0] & 0x00000004u) != 0;
10850}
10851inline void BlockKeyProto::set_has_keyid() {
10852 _has_bits_[0] |= 0x00000004u;
10853}
10854inline void BlockKeyProto::clear_has_keyid() {
10855 _has_bits_[0] &= ~0x00000004u;
10856}
10857inline void BlockKeyProto::clear_keyid() {
10858 keyid_ = 0u;
10859 clear_has_keyid();
10860}
10861inline ::google::protobuf::uint32 BlockKeyProto::keyid() const {
10862 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockKeyProto.keyId)
10863 return keyid_;
10864}
10865inline void BlockKeyProto::set_keyid(::google::protobuf::uint32 value) {
10866 set_has_keyid();
10867 keyid_ = value;
10868 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockKeyProto.keyId)
10869}
10870
10871// required uint64 expiryDate = 2;
10872inline bool BlockKeyProto::has_expirydate() const {
10873 return (_has_bits_[0] & 0x00000002u) != 0;
10874}
10875inline void BlockKeyProto::set_has_expirydate() {
10876 _has_bits_[0] |= 0x00000002u;
10877}
10878inline void BlockKeyProto::clear_has_expirydate() {
10879 _has_bits_[0] &= ~0x00000002u;
10880}
10881inline void BlockKeyProto::clear_expirydate() {
10882 expirydate_ = GOOGLE_ULONGLONG(0);
10883 clear_has_expirydate();
10884}
10885inline ::google::protobuf::uint64 BlockKeyProto::expirydate() const {
10886 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockKeyProto.expiryDate)
10887 return expirydate_;
10888}
10889inline void BlockKeyProto::set_expirydate(::google::protobuf::uint64 value) {
10890 set_has_expirydate();
10891 expirydate_ = value;
10892 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockKeyProto.expiryDate)
10893}
10894
10895// optional bytes keyBytes = 3;
10896inline bool BlockKeyProto::has_keybytes() const {
10897 return (_has_bits_[0] & 0x00000001u) != 0;
10898}
10899inline void BlockKeyProto::set_has_keybytes() {
10900 _has_bits_[0] |= 0x00000001u;
10901}
10902inline void BlockKeyProto::clear_has_keybytes() {
10903 _has_bits_[0] &= ~0x00000001u;
10904}
10905inline void BlockKeyProto::clear_keybytes() {
10906 keybytes_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10907 clear_has_keybytes();
10908}
10909inline const ::std::string& BlockKeyProto::keybytes() const {
10910 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockKeyProto.keyBytes)
10911 return keybytes_.GetNoArena();
10912}
10913inline void BlockKeyProto::set_keybytes(const ::std::string& value) {
10914 set_has_keybytes();
10915 keybytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
10916 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockKeyProto.keyBytes)
10917}
10918#if LANG_CXX11
10919inline void BlockKeyProto::set_keybytes(::std::string&& value) {
10920 set_has_keybytes();
10921 keybytes_.SetNoArena(
10922 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
10923 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.BlockKeyProto.keyBytes)
10924}
10925#endif
10926inline void BlockKeyProto::set_keybytes(const char* value) {
10927 GOOGLE_DCHECK(value != NULL);
10928 set_has_keybytes();
10929 keybytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
10930 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.BlockKeyProto.keyBytes)
10931}
10932inline void BlockKeyProto::set_keybytes(const void* value, size_t size) {
10933 set_has_keybytes();
10934 keybytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
10935 ::std::string(reinterpret_cast<const char*>(value), size));
10936 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.BlockKeyProto.keyBytes)
10937}
10938inline ::std::string* BlockKeyProto::mutable_keybytes() {
10939 set_has_keybytes();
10940 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlockKeyProto.keyBytes)
10941 return keybytes_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10942}
10943inline ::std::string* BlockKeyProto::release_keybytes() {
10944 // @@protoc_insertion_point(field_release:Hdfs.Internal.BlockKeyProto.keyBytes)
10945 if (!has_keybytes()) {
10946 return NULL;
10947 }
10948 clear_has_keybytes();
10949 return keybytes_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
10950}
10951inline void BlockKeyProto::set_allocated_keybytes(::std::string* keybytes) {
10952 if (keybytes != NULL) {
10953 set_has_keybytes();
10954 } else {
10955 clear_has_keybytes();
10956 }
10957 keybytes_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), keybytes);
10958 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.BlockKeyProto.keyBytes)
10959}
10960
10961// -------------------------------------------------------------------
10962
10963// ExportedBlockKeysProto
10964
10965// required bool isBlockTokenEnabled = 1;
10966inline bool ExportedBlockKeysProto::has_isblocktokenenabled() const {
10967 return (_has_bits_[0] & 0x00000008u) != 0;
10968}
10969inline void ExportedBlockKeysProto::set_has_isblocktokenenabled() {
10970 _has_bits_[0] |= 0x00000008u;
10971}
10972inline void ExportedBlockKeysProto::clear_has_isblocktokenenabled() {
10973 _has_bits_[0] &= ~0x00000008u;
10974}
10975inline void ExportedBlockKeysProto::clear_isblocktokenenabled() {
10976 isblocktokenenabled_ = false;
10977 clear_has_isblocktokenenabled();
10978}
10979inline bool ExportedBlockKeysProto::isblocktokenenabled() const {
10980 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExportedBlockKeysProto.isBlockTokenEnabled)
10981 return isblocktokenenabled_;
10982}
10983inline void ExportedBlockKeysProto::set_isblocktokenenabled(bool value) {
10984 set_has_isblocktokenenabled();
10985 isblocktokenenabled_ = value;
10986 // @@protoc_insertion_point(field_set:Hdfs.Internal.ExportedBlockKeysProto.isBlockTokenEnabled)
10987}
10988
10989// required uint64 keyUpdateInterval = 2;
10990inline bool ExportedBlockKeysProto::has_keyupdateinterval() const {
10991 return (_has_bits_[0] & 0x00000002u) != 0;
10992}
10993inline void ExportedBlockKeysProto::set_has_keyupdateinterval() {
10994 _has_bits_[0] |= 0x00000002u;
10995}
10996inline void ExportedBlockKeysProto::clear_has_keyupdateinterval() {
10997 _has_bits_[0] &= ~0x00000002u;
10998}
10999inline void ExportedBlockKeysProto::clear_keyupdateinterval() {
11000 keyupdateinterval_ = GOOGLE_ULONGLONG(0);
11001 clear_has_keyupdateinterval();
11002}
11003inline ::google::protobuf::uint64 ExportedBlockKeysProto::keyupdateinterval() const {
11004 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExportedBlockKeysProto.keyUpdateInterval)
11005 return keyupdateinterval_;
11006}
11007inline void ExportedBlockKeysProto::set_keyupdateinterval(::google::protobuf::uint64 value) {
11008 set_has_keyupdateinterval();
11009 keyupdateinterval_ = value;
11010 // @@protoc_insertion_point(field_set:Hdfs.Internal.ExportedBlockKeysProto.keyUpdateInterval)
11011}
11012
11013// required uint64 tokenLifeTime = 3;
11014inline bool ExportedBlockKeysProto::has_tokenlifetime() const {
11015 return (_has_bits_[0] & 0x00000004u) != 0;
11016}
11017inline void ExportedBlockKeysProto::set_has_tokenlifetime() {
11018 _has_bits_[0] |= 0x00000004u;
11019}
11020inline void ExportedBlockKeysProto::clear_has_tokenlifetime() {
11021 _has_bits_[0] &= ~0x00000004u;
11022}
11023inline void ExportedBlockKeysProto::clear_tokenlifetime() {
11024 tokenlifetime_ = GOOGLE_ULONGLONG(0);
11025 clear_has_tokenlifetime();
11026}
11027inline ::google::protobuf::uint64 ExportedBlockKeysProto::tokenlifetime() const {
11028 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExportedBlockKeysProto.tokenLifeTime)
11029 return tokenlifetime_;
11030}
11031inline void ExportedBlockKeysProto::set_tokenlifetime(::google::protobuf::uint64 value) {
11032 set_has_tokenlifetime();
11033 tokenlifetime_ = value;
11034 // @@protoc_insertion_point(field_set:Hdfs.Internal.ExportedBlockKeysProto.tokenLifeTime)
11035}
11036
11037// required .Hdfs.Internal.BlockKeyProto currentKey = 4;
11038inline bool ExportedBlockKeysProto::has_currentkey() const {
11039 return (_has_bits_[0] & 0x00000001u) != 0;
11040}
11041inline void ExportedBlockKeysProto::set_has_currentkey() {
11042 _has_bits_[0] |= 0x00000001u;
11043}
11044inline void ExportedBlockKeysProto::clear_has_currentkey() {
11045 _has_bits_[0] &= ~0x00000001u;
11046}
11047inline void ExportedBlockKeysProto::clear_currentkey() {
11048 if (currentkey_ != NULL) currentkey_->Clear();
11049 clear_has_currentkey();
11050}
11051inline const ::Hdfs::Internal::BlockKeyProto& ExportedBlockKeysProto::_internal_currentkey() const {
11052 return *currentkey_;
11053}
11054inline const ::Hdfs::Internal::BlockKeyProto& ExportedBlockKeysProto::currentkey() const {
11055 const ::Hdfs::Internal::BlockKeyProto* p = currentkey_;
11056 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExportedBlockKeysProto.currentKey)
11057 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::BlockKeyProto*>(
11058 &::Hdfs::Internal::_BlockKeyProto_default_instance_);
11059}
11060inline ::Hdfs::Internal::BlockKeyProto* ExportedBlockKeysProto::release_currentkey() {
11061 // @@protoc_insertion_point(field_release:Hdfs.Internal.ExportedBlockKeysProto.currentKey)
11062 clear_has_currentkey();
11063 ::Hdfs::Internal::BlockKeyProto* temp = currentkey_;
11064 currentkey_ = NULL;
11065 return temp;
11066}
11067inline ::Hdfs::Internal::BlockKeyProto* ExportedBlockKeysProto::mutable_currentkey() {
11068 set_has_currentkey();
11069 if (currentkey_ == NULL) {
11070 auto* p = CreateMaybeMessage<::Hdfs::Internal::BlockKeyProto>(GetArenaNoVirtual());
11071 currentkey_ = p;
11072 }
11073 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.ExportedBlockKeysProto.currentKey)
11074 return currentkey_;
11075}
11076inline void ExportedBlockKeysProto::set_allocated_currentkey(::Hdfs::Internal::BlockKeyProto* currentkey) {
11077 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
11078 if (message_arena == NULL) {
11079 delete currentkey_;
11080 }
11081 if (currentkey) {
11082 ::google::protobuf::Arena* submessage_arena = NULL;
11083 if (message_arena != submessage_arena) {
11084 currentkey = ::google::protobuf::internal::GetOwnedMessage(
11085 message_arena, currentkey, submessage_arena);
11086 }
11087 set_has_currentkey();
11088 } else {
11089 clear_has_currentkey();
11090 }
11091 currentkey_ = currentkey;
11092 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.ExportedBlockKeysProto.currentKey)
11093}
11094
11095// repeated .Hdfs.Internal.BlockKeyProto allKeys = 5;
11096inline int ExportedBlockKeysProto::allkeys_size() const {
11097 return allkeys_.size();
11098}
11099inline void ExportedBlockKeysProto::clear_allkeys() {
11100 allkeys_.Clear();
11101}
11102inline ::Hdfs::Internal::BlockKeyProto* ExportedBlockKeysProto::mutable_allkeys(int index) {
11103 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.ExportedBlockKeysProto.allKeys)
11104 return allkeys_.Mutable(index);
11105}
11106inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockKeyProto >*
11107ExportedBlockKeysProto::mutable_allkeys() {
11108 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.ExportedBlockKeysProto.allKeys)
11109 return &allkeys_;
11110}
11111inline const ::Hdfs::Internal::BlockKeyProto& ExportedBlockKeysProto::allkeys(int index) const {
11112 // @@protoc_insertion_point(field_get:Hdfs.Internal.ExportedBlockKeysProto.allKeys)
11113 return allkeys_.Get(index);
11114}
11115inline ::Hdfs::Internal::BlockKeyProto* ExportedBlockKeysProto::add_allkeys() {
11116 // @@protoc_insertion_point(field_add:Hdfs.Internal.ExportedBlockKeysProto.allKeys)
11117 return allkeys_.Add();
11118}
11119inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::BlockKeyProto >&
11120ExportedBlockKeysProto::allkeys() const {
11121 // @@protoc_insertion_point(field_list:Hdfs.Internal.ExportedBlockKeysProto.allKeys)
11122 return allkeys_;
11123}
11124
11125// -------------------------------------------------------------------
11126
11127// RecoveringBlockProto
11128
11129// required uint64 newGenStamp = 1;
11130inline bool RecoveringBlockProto::has_newgenstamp() const {
11131 return (_has_bits_[0] & 0x00000002u) != 0;
11132}
11133inline void RecoveringBlockProto::set_has_newgenstamp() {
11134 _has_bits_[0] |= 0x00000002u;
11135}
11136inline void RecoveringBlockProto::clear_has_newgenstamp() {
11137 _has_bits_[0] &= ~0x00000002u;
11138}
11139inline void RecoveringBlockProto::clear_newgenstamp() {
11140 newgenstamp_ = GOOGLE_ULONGLONG(0);
11141 clear_has_newgenstamp();
11142}
11143inline ::google::protobuf::uint64 RecoveringBlockProto::newgenstamp() const {
11144 // @@protoc_insertion_point(field_get:Hdfs.Internal.RecoveringBlockProto.newGenStamp)
11145 return newgenstamp_;
11146}
11147inline void RecoveringBlockProto::set_newgenstamp(::google::protobuf::uint64 value) {
11148 set_has_newgenstamp();
11149 newgenstamp_ = value;
11150 // @@protoc_insertion_point(field_set:Hdfs.Internal.RecoveringBlockProto.newGenStamp)
11151}
11152
11153// required .Hdfs.Internal.LocatedBlockProto block = 2;
11154inline bool RecoveringBlockProto::has_block() const {
11155 return (_has_bits_[0] & 0x00000001u) != 0;
11156}
11157inline void RecoveringBlockProto::set_has_block() {
11158 _has_bits_[0] |= 0x00000001u;
11159}
11160inline void RecoveringBlockProto::clear_has_block() {
11161 _has_bits_[0] &= ~0x00000001u;
11162}
11163inline void RecoveringBlockProto::clear_block() {
11164 if (block_ != NULL) block_->Clear();
11165 clear_has_block();
11166}
11167inline const ::Hdfs::Internal::LocatedBlockProto& RecoveringBlockProto::_internal_block() const {
11168 return *block_;
11169}
11170inline const ::Hdfs::Internal::LocatedBlockProto& RecoveringBlockProto::block() const {
11171 const ::Hdfs::Internal::LocatedBlockProto* p = block_;
11172 // @@protoc_insertion_point(field_get:Hdfs.Internal.RecoveringBlockProto.block)
11173 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::LocatedBlockProto*>(
11174 &::Hdfs::Internal::_LocatedBlockProto_default_instance_);
11175}
11176inline ::Hdfs::Internal::LocatedBlockProto* RecoveringBlockProto::release_block() {
11177 // @@protoc_insertion_point(field_release:Hdfs.Internal.RecoveringBlockProto.block)
11178 clear_has_block();
11179 ::Hdfs::Internal::LocatedBlockProto* temp = block_;
11180 block_ = NULL;
11181 return temp;
11182}
11183inline ::Hdfs::Internal::LocatedBlockProto* RecoveringBlockProto::mutable_block() {
11184 set_has_block();
11185 if (block_ == NULL) {
11186 auto* p = CreateMaybeMessage<::Hdfs::Internal::LocatedBlockProto>(GetArenaNoVirtual());
11187 block_ = p;
11188 }
11189 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RecoveringBlockProto.block)
11190 return block_;
11191}
11192inline void RecoveringBlockProto::set_allocated_block(::Hdfs::Internal::LocatedBlockProto* block) {
11193 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
11194 if (message_arena == NULL) {
11195 delete block_;
11196 }
11197 if (block) {
11198 ::google::protobuf::Arena* submessage_arena = NULL;
11199 if (message_arena != submessage_arena) {
11200 block = ::google::protobuf::internal::GetOwnedMessage(
11201 message_arena, block, submessage_arena);
11202 }
11203 set_has_block();
11204 } else {
11205 clear_has_block();
11206 }
11207 block_ = block;
11208 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RecoveringBlockProto.block)
11209}
11210
11211// -------------------------------------------------------------------
11212
11213// VersionRequestProto
11214
11215// -------------------------------------------------------------------
11216
11217// VersionResponseProto
11218
11219// required .Hdfs.Internal.NamespaceInfoProto info = 1;
11220inline bool VersionResponseProto::has_info() const {
11221 return (_has_bits_[0] & 0x00000001u) != 0;
11222}
11223inline void VersionResponseProto::set_has_info() {
11224 _has_bits_[0] |= 0x00000001u;
11225}
11226inline void VersionResponseProto::clear_has_info() {
11227 _has_bits_[0] &= ~0x00000001u;
11228}
11229inline void VersionResponseProto::clear_info() {
11230 if (info_ != NULL) info_->Clear();
11231 clear_has_info();
11232}
11233inline const ::Hdfs::Internal::NamespaceInfoProto& VersionResponseProto::_internal_info() const {
11234 return *info_;
11235}
11236inline const ::Hdfs::Internal::NamespaceInfoProto& VersionResponseProto::info() const {
11237 const ::Hdfs::Internal::NamespaceInfoProto* p = info_;
11238 // @@protoc_insertion_point(field_get:Hdfs.Internal.VersionResponseProto.info)
11239 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::NamespaceInfoProto*>(
11240 &::Hdfs::Internal::_NamespaceInfoProto_default_instance_);
11241}
11242inline ::Hdfs::Internal::NamespaceInfoProto* VersionResponseProto::release_info() {
11243 // @@protoc_insertion_point(field_release:Hdfs.Internal.VersionResponseProto.info)
11244 clear_has_info();
11245 ::Hdfs::Internal::NamespaceInfoProto* temp = info_;
11246 info_ = NULL;
11247 return temp;
11248}
11249inline ::Hdfs::Internal::NamespaceInfoProto* VersionResponseProto::mutable_info() {
11250 set_has_info();
11251 if (info_ == NULL) {
11252 auto* p = CreateMaybeMessage<::Hdfs::Internal::NamespaceInfoProto>(GetArenaNoVirtual());
11253 info_ = p;
11254 }
11255 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.VersionResponseProto.info)
11256 return info_;
11257}
11258inline void VersionResponseProto::set_allocated_info(::Hdfs::Internal::NamespaceInfoProto* info) {
11259 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
11260 if (message_arena == NULL) {
11261 delete info_;
11262 }
11263 if (info) {
11264 ::google::protobuf::Arena* submessage_arena = NULL;
11265 if (message_arena != submessage_arena) {
11266 info = ::google::protobuf::internal::GetOwnedMessage(
11267 message_arena, info, submessage_arena);
11268 }
11269 set_has_info();
11270 } else {
11271 clear_has_info();
11272 }
11273 info_ = info;
11274 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.VersionResponseProto.info)
11275}
11276
11277// -------------------------------------------------------------------
11278
11279// SnapshotInfoProto
11280
11281// required string snapshotName = 1;
11282inline bool SnapshotInfoProto::has_snapshotname() const {
11283 return (_has_bits_[0] & 0x00000001u) != 0;
11284}
11285inline void SnapshotInfoProto::set_has_snapshotname() {
11286 _has_bits_[0] |= 0x00000001u;
11287}
11288inline void SnapshotInfoProto::clear_has_snapshotname() {
11289 _has_bits_[0] &= ~0x00000001u;
11290}
11291inline void SnapshotInfoProto::clear_snapshotname() {
11292 snapshotname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11293 clear_has_snapshotname();
11294}
11295inline const ::std::string& SnapshotInfoProto::snapshotname() const {
11296 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotInfoProto.snapshotName)
11297 return snapshotname_.GetNoArena();
11298}
11299inline void SnapshotInfoProto::set_snapshotname(const ::std::string& value) {
11300 set_has_snapshotname();
11301 snapshotname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
11302 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotInfoProto.snapshotName)
11303}
11304#if LANG_CXX11
11305inline void SnapshotInfoProto::set_snapshotname(::std::string&& value) {
11306 set_has_snapshotname();
11307 snapshotname_.SetNoArena(
11308 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
11309 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotInfoProto.snapshotName)
11310}
11311#endif
11312inline void SnapshotInfoProto::set_snapshotname(const char* value) {
11313 GOOGLE_DCHECK(value != NULL);
11314 set_has_snapshotname();
11315 snapshotname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
11316 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotInfoProto.snapshotName)
11317}
11318inline void SnapshotInfoProto::set_snapshotname(const char* value, size_t size) {
11319 set_has_snapshotname();
11320 snapshotname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
11321 ::std::string(reinterpret_cast<const char*>(value), size));
11322 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotInfoProto.snapshotName)
11323}
11324inline ::std::string* SnapshotInfoProto::mutable_snapshotname() {
11325 set_has_snapshotname();
11326 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotInfoProto.snapshotName)
11327 return snapshotname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11328}
11329inline ::std::string* SnapshotInfoProto::release_snapshotname() {
11330 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotInfoProto.snapshotName)
11331 if (!has_snapshotname()) {
11332 return NULL;
11333 }
11334 clear_has_snapshotname();
11335 return snapshotname_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11336}
11337inline void SnapshotInfoProto::set_allocated_snapshotname(::std::string* snapshotname) {
11338 if (snapshotname != NULL) {
11339 set_has_snapshotname();
11340 } else {
11341 clear_has_snapshotname();
11342 }
11343 snapshotname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshotname);
11344 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotInfoProto.snapshotName)
11345}
11346
11347// required string snapshotRoot = 2;
11348inline bool SnapshotInfoProto::has_snapshotroot() const {
11349 return (_has_bits_[0] & 0x00000002u) != 0;
11350}
11351inline void SnapshotInfoProto::set_has_snapshotroot() {
11352 _has_bits_[0] |= 0x00000002u;
11353}
11354inline void SnapshotInfoProto::clear_has_snapshotroot() {
11355 _has_bits_[0] &= ~0x00000002u;
11356}
11357inline void SnapshotInfoProto::clear_snapshotroot() {
11358 snapshotroot_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11359 clear_has_snapshotroot();
11360}
11361inline const ::std::string& SnapshotInfoProto::snapshotroot() const {
11362 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotInfoProto.snapshotRoot)
11363 return snapshotroot_.GetNoArena();
11364}
11365inline void SnapshotInfoProto::set_snapshotroot(const ::std::string& value) {
11366 set_has_snapshotroot();
11367 snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
11368 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotInfoProto.snapshotRoot)
11369}
11370#if LANG_CXX11
11371inline void SnapshotInfoProto::set_snapshotroot(::std::string&& value) {
11372 set_has_snapshotroot();
11373 snapshotroot_.SetNoArena(
11374 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
11375 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotInfoProto.snapshotRoot)
11376}
11377#endif
11378inline void SnapshotInfoProto::set_snapshotroot(const char* value) {
11379 GOOGLE_DCHECK(value != NULL);
11380 set_has_snapshotroot();
11381 snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
11382 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotInfoProto.snapshotRoot)
11383}
11384inline void SnapshotInfoProto::set_snapshotroot(const char* value, size_t size) {
11385 set_has_snapshotroot();
11386 snapshotroot_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
11387 ::std::string(reinterpret_cast<const char*>(value), size));
11388 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotInfoProto.snapshotRoot)
11389}
11390inline ::std::string* SnapshotInfoProto::mutable_snapshotroot() {
11391 set_has_snapshotroot();
11392 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotInfoProto.snapshotRoot)
11393 return snapshotroot_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11394}
11395inline ::std::string* SnapshotInfoProto::release_snapshotroot() {
11396 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotInfoProto.snapshotRoot)
11397 if (!has_snapshotroot()) {
11398 return NULL;
11399 }
11400 clear_has_snapshotroot();
11401 return snapshotroot_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11402}
11403inline void SnapshotInfoProto::set_allocated_snapshotroot(::std::string* snapshotroot) {
11404 if (snapshotroot != NULL) {
11405 set_has_snapshotroot();
11406 } else {
11407 clear_has_snapshotroot();
11408 }
11409 snapshotroot_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshotroot);
11410 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotInfoProto.snapshotRoot)
11411}
11412
11413// required .Hdfs.Internal.FsPermissionProto permission = 3;
11414inline bool SnapshotInfoProto::has_permission() const {
11415 return (_has_bits_[0] & 0x00000020u) != 0;
11416}
11417inline void SnapshotInfoProto::set_has_permission() {
11418 _has_bits_[0] |= 0x00000020u;
11419}
11420inline void SnapshotInfoProto::clear_has_permission() {
11421 _has_bits_[0] &= ~0x00000020u;
11422}
11423inline void SnapshotInfoProto::clear_permission() {
11424 if (permission_ != NULL) permission_->Clear();
11425 clear_has_permission();
11426}
11427inline const ::Hdfs::Internal::FsPermissionProto& SnapshotInfoProto::_internal_permission() const {
11428 return *permission_;
11429}
11430inline const ::Hdfs::Internal::FsPermissionProto& SnapshotInfoProto::permission() const {
11431 const ::Hdfs::Internal::FsPermissionProto* p = permission_;
11432 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotInfoProto.permission)
11433 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::FsPermissionProto*>(
11434 &::Hdfs::Internal::_FsPermissionProto_default_instance_);
11435}
11436inline ::Hdfs::Internal::FsPermissionProto* SnapshotInfoProto::release_permission() {
11437 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotInfoProto.permission)
11438 clear_has_permission();
11439 ::Hdfs::Internal::FsPermissionProto* temp = permission_;
11440 permission_ = NULL;
11441 return temp;
11442}
11443inline ::Hdfs::Internal::FsPermissionProto* SnapshotInfoProto::mutable_permission() {
11444 set_has_permission();
11445 if (permission_ == NULL) {
11446 auto* p = CreateMaybeMessage<::Hdfs::Internal::FsPermissionProto>(GetArenaNoVirtual());
11447 permission_ = p;
11448 }
11449 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotInfoProto.permission)
11450 return permission_;
11451}
11452inline void SnapshotInfoProto::set_allocated_permission(::Hdfs::Internal::FsPermissionProto* permission) {
11453 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
11454 if (message_arena == NULL) {
11455 delete permission_;
11456 }
11457 if (permission) {
11458 ::google::protobuf::Arena* submessage_arena = NULL;
11459 if (message_arena != submessage_arena) {
11460 permission = ::google::protobuf::internal::GetOwnedMessage(
11461 message_arena, permission, submessage_arena);
11462 }
11463 set_has_permission();
11464 } else {
11465 clear_has_permission();
11466 }
11467 permission_ = permission;
11468 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotInfoProto.permission)
11469}
11470
11471// required string owner = 4;
11472inline bool SnapshotInfoProto::has_owner() const {
11473 return (_has_bits_[0] & 0x00000004u) != 0;
11474}
11475inline void SnapshotInfoProto::set_has_owner() {
11476 _has_bits_[0] |= 0x00000004u;
11477}
11478inline void SnapshotInfoProto::clear_has_owner() {
11479 _has_bits_[0] &= ~0x00000004u;
11480}
11481inline void SnapshotInfoProto::clear_owner() {
11482 owner_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11483 clear_has_owner();
11484}
11485inline const ::std::string& SnapshotInfoProto::owner() const {
11486 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotInfoProto.owner)
11487 return owner_.GetNoArena();
11488}
11489inline void SnapshotInfoProto::set_owner(const ::std::string& value) {
11490 set_has_owner();
11491 owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
11492 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotInfoProto.owner)
11493}
11494#if LANG_CXX11
11495inline void SnapshotInfoProto::set_owner(::std::string&& value) {
11496 set_has_owner();
11497 owner_.SetNoArena(
11498 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
11499 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotInfoProto.owner)
11500}
11501#endif
11502inline void SnapshotInfoProto::set_owner(const char* value) {
11503 GOOGLE_DCHECK(value != NULL);
11504 set_has_owner();
11505 owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
11506 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotInfoProto.owner)
11507}
11508inline void SnapshotInfoProto::set_owner(const char* value, size_t size) {
11509 set_has_owner();
11510 owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
11511 ::std::string(reinterpret_cast<const char*>(value), size));
11512 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotInfoProto.owner)
11513}
11514inline ::std::string* SnapshotInfoProto::mutable_owner() {
11515 set_has_owner();
11516 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotInfoProto.owner)
11517 return owner_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11518}
11519inline ::std::string* SnapshotInfoProto::release_owner() {
11520 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotInfoProto.owner)
11521 if (!has_owner()) {
11522 return NULL;
11523 }
11524 clear_has_owner();
11525 return owner_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11526}
11527inline void SnapshotInfoProto::set_allocated_owner(::std::string* owner) {
11528 if (owner != NULL) {
11529 set_has_owner();
11530 } else {
11531 clear_has_owner();
11532 }
11533 owner_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), owner);
11534 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotInfoProto.owner)
11535}
11536
11537// required string group = 5;
11538inline bool SnapshotInfoProto::has_group() const {
11539 return (_has_bits_[0] & 0x00000008u) != 0;
11540}
11541inline void SnapshotInfoProto::set_has_group() {
11542 _has_bits_[0] |= 0x00000008u;
11543}
11544inline void SnapshotInfoProto::clear_has_group() {
11545 _has_bits_[0] &= ~0x00000008u;
11546}
11547inline void SnapshotInfoProto::clear_group() {
11548 group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11549 clear_has_group();
11550}
11551inline const ::std::string& SnapshotInfoProto::group() const {
11552 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotInfoProto.group)
11553 return group_.GetNoArena();
11554}
11555inline void SnapshotInfoProto::set_group(const ::std::string& value) {
11556 set_has_group();
11557 group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
11558 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotInfoProto.group)
11559}
11560#if LANG_CXX11
11561inline void SnapshotInfoProto::set_group(::std::string&& value) {
11562 set_has_group();
11563 group_.SetNoArena(
11564 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
11565 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotInfoProto.group)
11566}
11567#endif
11568inline void SnapshotInfoProto::set_group(const char* value) {
11569 GOOGLE_DCHECK(value != NULL);
11570 set_has_group();
11571 group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
11572 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotInfoProto.group)
11573}
11574inline void SnapshotInfoProto::set_group(const char* value, size_t size) {
11575 set_has_group();
11576 group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
11577 ::std::string(reinterpret_cast<const char*>(value), size));
11578 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotInfoProto.group)
11579}
11580inline ::std::string* SnapshotInfoProto::mutable_group() {
11581 set_has_group();
11582 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotInfoProto.group)
11583 return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11584}
11585inline ::std::string* SnapshotInfoProto::release_group() {
11586 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotInfoProto.group)
11587 if (!has_group()) {
11588 return NULL;
11589 }
11590 clear_has_group();
11591 return group_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11592}
11593inline void SnapshotInfoProto::set_allocated_group(::std::string* group) {
11594 if (group != NULL) {
11595 set_has_group();
11596 } else {
11597 clear_has_group();
11598 }
11599 group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
11600 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotInfoProto.group)
11601}
11602
11603// required string createTime = 6;
11604inline bool SnapshotInfoProto::has_createtime() const {
11605 return (_has_bits_[0] & 0x00000010u) != 0;
11606}
11607inline void SnapshotInfoProto::set_has_createtime() {
11608 _has_bits_[0] |= 0x00000010u;
11609}
11610inline void SnapshotInfoProto::clear_has_createtime() {
11611 _has_bits_[0] &= ~0x00000010u;
11612}
11613inline void SnapshotInfoProto::clear_createtime() {
11614 createtime_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11615 clear_has_createtime();
11616}
11617inline const ::std::string& SnapshotInfoProto::createtime() const {
11618 // @@protoc_insertion_point(field_get:Hdfs.Internal.SnapshotInfoProto.createTime)
11619 return createtime_.GetNoArena();
11620}
11621inline void SnapshotInfoProto::set_createtime(const ::std::string& value) {
11622 set_has_createtime();
11623 createtime_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
11624 // @@protoc_insertion_point(field_set:Hdfs.Internal.SnapshotInfoProto.createTime)
11625}
11626#if LANG_CXX11
11627inline void SnapshotInfoProto::set_createtime(::std::string&& value) {
11628 set_has_createtime();
11629 createtime_.SetNoArena(
11630 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
11631 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.SnapshotInfoProto.createTime)
11632}
11633#endif
11634inline void SnapshotInfoProto::set_createtime(const char* value) {
11635 GOOGLE_DCHECK(value != NULL);
11636 set_has_createtime();
11637 createtime_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
11638 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.SnapshotInfoProto.createTime)
11639}
11640inline void SnapshotInfoProto::set_createtime(const char* value, size_t size) {
11641 set_has_createtime();
11642 createtime_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
11643 ::std::string(reinterpret_cast<const char*>(value), size));
11644 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.SnapshotInfoProto.createTime)
11645}
11646inline ::std::string* SnapshotInfoProto::mutable_createtime() {
11647 set_has_createtime();
11648 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.SnapshotInfoProto.createTime)
11649 return createtime_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11650}
11651inline ::std::string* SnapshotInfoProto::release_createtime() {
11652 // @@protoc_insertion_point(field_release:Hdfs.Internal.SnapshotInfoProto.createTime)
11653 if (!has_createtime()) {
11654 return NULL;
11655 }
11656 clear_has_createtime();
11657 return createtime_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
11658}
11659inline void SnapshotInfoProto::set_allocated_createtime(::std::string* createtime) {
11660 if (createtime != NULL) {
11661 set_has_createtime();
11662 } else {
11663 clear_has_createtime();
11664 }
11665 createtime_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), createtime);
11666 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.SnapshotInfoProto.createTime)
11667}
11668
11669#ifdef __GNUC__
11670 #pragma GCC diagnostic pop
11671#endif // __GNUC__
11672// -------------------------------------------------------------------
11673
11674// -------------------------------------------------------------------
11675
11676// -------------------------------------------------------------------
11677
11678// -------------------------------------------------------------------
11679
11680// -------------------------------------------------------------------
11681
11682// -------------------------------------------------------------------
11683
11684// -------------------------------------------------------------------
11685
11686// -------------------------------------------------------------------
11687
11688// -------------------------------------------------------------------
11689
11690// -------------------------------------------------------------------
11691
11692// -------------------------------------------------------------------
11693
11694// -------------------------------------------------------------------
11695
11696// -------------------------------------------------------------------
11697
11698// -------------------------------------------------------------------
11699
11700// -------------------------------------------------------------------
11701
11702// -------------------------------------------------------------------
11703
11704// -------------------------------------------------------------------
11705
11706// -------------------------------------------------------------------
11707
11708// -------------------------------------------------------------------
11709
11710// -------------------------------------------------------------------
11711
11712// -------------------------------------------------------------------
11713
11714// -------------------------------------------------------------------
11715
11716// -------------------------------------------------------------------
11717
11718// -------------------------------------------------------------------
11719
11720// -------------------------------------------------------------------
11721
11722// -------------------------------------------------------------------
11723
11724// -------------------------------------------------------------------
11725
11726// -------------------------------------------------------------------
11727
11728// -------------------------------------------------------------------
11729
11730// -------------------------------------------------------------------
11731
11732// -------------------------------------------------------------------
11733
11734// -------------------------------------------------------------------
11735
11736// -------------------------------------------------------------------
11737
11738// -------------------------------------------------------------------
11739
11740
11741// @@protoc_insertion_point(namespace_scope)
11742
11743} // namespace Internal
11744} // namespace Hdfs
11745
11746namespace google {
11747namespace protobuf {
11748
11749template <> struct is_proto_enum< ::Hdfs::Internal::DatanodeInfoProto_AdminState> : ::std::true_type {};
11750template <>
11751inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::DatanodeInfoProto_AdminState>() {
11752 return ::Hdfs::Internal::DatanodeInfoProto_AdminState_descriptor();
11753}
11754template <> struct is_proto_enum< ::Hdfs::Internal::HdfsFileStatusProto_FileType> : ::std::true_type {};
11755template <>
11756inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::HdfsFileStatusProto_FileType>() {
11757 return ::Hdfs::Internal::HdfsFileStatusProto_FileType_descriptor();
11758}
11759template <> struct is_proto_enum< ::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto> : ::std::true_type {};
11760template <>
11761inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto>() {
11762 return ::Hdfs::Internal::NamenodeRegistrationProto_NamenodeRoleProto_descriptor();
11763}
11764template <> struct is_proto_enum< ::Hdfs::Internal::NamenodeCommandProto_Type> : ::std::true_type {};
11765template <>
11766inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::NamenodeCommandProto_Type>() {
11767 return ::Hdfs::Internal::NamenodeCommandProto_Type_descriptor();
11768}
11769template <> struct is_proto_enum< ::Hdfs::Internal::StorageTypeProto> : ::std::true_type {};
11770template <>
11771inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::StorageTypeProto>() {
11772 return ::Hdfs::Internal::StorageTypeProto_descriptor();
11773}
11774template <> struct is_proto_enum< ::Hdfs::Internal::ChecksumTypeProto> : ::std::true_type {};
11775template <>
11776inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::ChecksumTypeProto>() {
11777 return ::Hdfs::Internal::ChecksumTypeProto_descriptor();
11778}
11779template <> struct is_proto_enum< ::Hdfs::Internal::ReplicaStateProto> : ::std::true_type {};
11780template <>
11781inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::ReplicaStateProto>() {
11782 return ::Hdfs::Internal::ReplicaStateProto_descriptor();
11783}
11784
11785} // namespace protobuf
11786} // namespace google
11787
11788// @@protoc_insertion_point(global_scope)
11789
11790#endif // PROTOBUF_INCLUDED_hdfs_2eproto
11791