1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: ClientDatanodeProtocol.proto
3
4#ifndef PROTOBUF_INCLUDED_ClientDatanodeProtocol_2eproto
5#define PROTOBUF_INCLUDED_ClientDatanodeProtocol_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/service.h>
33#include <google/protobuf/unknown_field_set.h>
34#include "hdfs.pb.h"
35#include "Security.pb.h"
36// @@protoc_insertion_point(includes)
37#define PROTOBUF_INTERNAL_EXPORT_protobuf_ClientDatanodeProtocol_2eproto
38
39namespace protobuf_ClientDatanodeProtocol_2eproto {
40// Internal implementation detail -- do not use these members.
41struct TableStruct {
42 static const ::google::protobuf::internal::ParseTableField entries[];
43 static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
44 static const ::google::protobuf::internal::ParseTable schema[10];
45 static const ::google::protobuf::internal::FieldMetadata field_metadata[];
46 static const ::google::protobuf::internal::SerializationTable serialization_table[];
47 static const ::google::protobuf::uint32 offsets[];
48};
49void AddDescriptors();
50} // namespace protobuf_ClientDatanodeProtocol_2eproto
51namespace Hdfs {
52namespace Internal {
53class DeleteBlockPoolRequestProto;
54class DeleteBlockPoolRequestProtoDefaultTypeInternal;
55extern DeleteBlockPoolRequestProtoDefaultTypeInternal _DeleteBlockPoolRequestProto_default_instance_;
56class DeleteBlockPoolResponseProto;
57class DeleteBlockPoolResponseProtoDefaultTypeInternal;
58extern DeleteBlockPoolResponseProtoDefaultTypeInternal _DeleteBlockPoolResponseProto_default_instance_;
59class GetBlockLocalPathInfoRequestProto;
60class GetBlockLocalPathInfoRequestProtoDefaultTypeInternal;
61extern GetBlockLocalPathInfoRequestProtoDefaultTypeInternal _GetBlockLocalPathInfoRequestProto_default_instance_;
62class GetBlockLocalPathInfoResponseProto;
63class GetBlockLocalPathInfoResponseProtoDefaultTypeInternal;
64extern GetBlockLocalPathInfoResponseProtoDefaultTypeInternal _GetBlockLocalPathInfoResponseProto_default_instance_;
65class GetHdfsBlockLocationsRequestProto;
66class GetHdfsBlockLocationsRequestProtoDefaultTypeInternal;
67extern GetHdfsBlockLocationsRequestProtoDefaultTypeInternal _GetHdfsBlockLocationsRequestProto_default_instance_;
68class GetHdfsBlockLocationsResponseProto;
69class GetHdfsBlockLocationsResponseProtoDefaultTypeInternal;
70extern GetHdfsBlockLocationsResponseProtoDefaultTypeInternal _GetHdfsBlockLocationsResponseProto_default_instance_;
71class GetReplicaVisibleLengthRequestProto;
72class GetReplicaVisibleLengthRequestProtoDefaultTypeInternal;
73extern GetReplicaVisibleLengthRequestProtoDefaultTypeInternal _GetReplicaVisibleLengthRequestProto_default_instance_;
74class GetReplicaVisibleLengthResponseProto;
75class GetReplicaVisibleLengthResponseProtoDefaultTypeInternal;
76extern GetReplicaVisibleLengthResponseProtoDefaultTypeInternal _GetReplicaVisibleLengthResponseProto_default_instance_;
77class RefreshNamenodesRequestProto;
78class RefreshNamenodesRequestProtoDefaultTypeInternal;
79extern RefreshNamenodesRequestProtoDefaultTypeInternal _RefreshNamenodesRequestProto_default_instance_;
80class RefreshNamenodesResponseProto;
81class RefreshNamenodesResponseProtoDefaultTypeInternal;
82extern RefreshNamenodesResponseProtoDefaultTypeInternal _RefreshNamenodesResponseProto_default_instance_;
83} // namespace Internal
84} // namespace Hdfs
85namespace google {
86namespace protobuf {
87template<> ::Hdfs::Internal::DeleteBlockPoolRequestProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DeleteBlockPoolRequestProto>(Arena*);
88template<> ::Hdfs::Internal::DeleteBlockPoolResponseProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DeleteBlockPoolResponseProto>(Arena*);
89template<> ::Hdfs::Internal::GetBlockLocalPathInfoRequestProto* Arena::CreateMaybeMessage<::Hdfs::Internal::GetBlockLocalPathInfoRequestProto>(Arena*);
90template<> ::Hdfs::Internal::GetBlockLocalPathInfoResponseProto* Arena::CreateMaybeMessage<::Hdfs::Internal::GetBlockLocalPathInfoResponseProto>(Arena*);
91template<> ::Hdfs::Internal::GetHdfsBlockLocationsRequestProto* Arena::CreateMaybeMessage<::Hdfs::Internal::GetHdfsBlockLocationsRequestProto>(Arena*);
92template<> ::Hdfs::Internal::GetHdfsBlockLocationsResponseProto* Arena::CreateMaybeMessage<::Hdfs::Internal::GetHdfsBlockLocationsResponseProto>(Arena*);
93template<> ::Hdfs::Internal::GetReplicaVisibleLengthRequestProto* Arena::CreateMaybeMessage<::Hdfs::Internal::GetReplicaVisibleLengthRequestProto>(Arena*);
94template<> ::Hdfs::Internal::GetReplicaVisibleLengthResponseProto* Arena::CreateMaybeMessage<::Hdfs::Internal::GetReplicaVisibleLengthResponseProto>(Arena*);
95template<> ::Hdfs::Internal::RefreshNamenodesRequestProto* Arena::CreateMaybeMessage<::Hdfs::Internal::RefreshNamenodesRequestProto>(Arena*);
96template<> ::Hdfs::Internal::RefreshNamenodesResponseProto* Arena::CreateMaybeMessage<::Hdfs::Internal::RefreshNamenodesResponseProto>(Arena*);
97} // namespace protobuf
98} // namespace google
99namespace Hdfs {
100namespace Internal {
101
102// ===================================================================
103
104class GetReplicaVisibleLengthRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.GetReplicaVisibleLengthRequestProto) */ {
105 public:
106 GetReplicaVisibleLengthRequestProto();
107 virtual ~GetReplicaVisibleLengthRequestProto();
108
109 GetReplicaVisibleLengthRequestProto(const GetReplicaVisibleLengthRequestProto& from);
110
111 inline GetReplicaVisibleLengthRequestProto& operator=(const GetReplicaVisibleLengthRequestProto& from) {
112 CopyFrom(from);
113 return *this;
114 }
115 #if LANG_CXX11
116 GetReplicaVisibleLengthRequestProto(GetReplicaVisibleLengthRequestProto&& from) noexcept
117 : GetReplicaVisibleLengthRequestProto() {
118 *this = ::std::move(from);
119 }
120
121 inline GetReplicaVisibleLengthRequestProto& operator=(GetReplicaVisibleLengthRequestProto&& from) noexcept {
122 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
123 if (this != &from) InternalSwap(&from);
124 } else {
125 CopyFrom(from);
126 }
127 return *this;
128 }
129 #endif
130 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
131 return _internal_metadata_.unknown_fields();
132 }
133 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
134 return _internal_metadata_.mutable_unknown_fields();
135 }
136
137 static const ::google::protobuf::Descriptor* descriptor();
138 static const GetReplicaVisibleLengthRequestProto& default_instance();
139
140 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
141 static inline const GetReplicaVisibleLengthRequestProto* internal_default_instance() {
142 return reinterpret_cast<const GetReplicaVisibleLengthRequestProto*>(
143 &_GetReplicaVisibleLengthRequestProto_default_instance_);
144 }
145 static constexpr int kIndexInFileMessages =
146 0;
147
148 void Swap(GetReplicaVisibleLengthRequestProto* other);
149 friend void swap(GetReplicaVisibleLengthRequestProto& a, GetReplicaVisibleLengthRequestProto& b) {
150 a.Swap(&b);
151 }
152
153 // implements Message ----------------------------------------------
154
155 inline GetReplicaVisibleLengthRequestProto* New() const final {
156 return CreateMaybeMessage<GetReplicaVisibleLengthRequestProto>(NULL);
157 }
158
159 GetReplicaVisibleLengthRequestProto* New(::google::protobuf::Arena* arena) const final {
160 return CreateMaybeMessage<GetReplicaVisibleLengthRequestProto>(arena);
161 }
162 void CopyFrom(const ::google::protobuf::Message& from) final;
163 void MergeFrom(const ::google::protobuf::Message& from) final;
164 void CopyFrom(const GetReplicaVisibleLengthRequestProto& from);
165 void MergeFrom(const GetReplicaVisibleLengthRequestProto& from);
166 void Clear() final;
167 bool IsInitialized() const final;
168
169 size_t ByteSizeLong() const final;
170 bool MergePartialFromCodedStream(
171 ::google::protobuf::io::CodedInputStream* input) final;
172 void SerializeWithCachedSizes(
173 ::google::protobuf::io::CodedOutputStream* output) const final;
174 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
175 bool deterministic, ::google::protobuf::uint8* target) const final;
176 int GetCachedSize() const final { return _cached_size_.Get(); }
177
178 private:
179 void SharedCtor();
180 void SharedDtor();
181 void SetCachedSize(int size) const final;
182 void InternalSwap(GetReplicaVisibleLengthRequestProto* other);
183 private:
184 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
185 return NULL;
186 }
187 inline void* MaybeArenaPtr() const {
188 return NULL;
189 }
190 public:
191
192 ::google::protobuf::Metadata GetMetadata() const final;
193
194 // nested types ----------------------------------------------------
195
196 // accessors -------------------------------------------------------
197
198 // required .Hdfs.Internal.ExtendedBlockProto block = 1;
199 bool has_block() const;
200 void clear_block();
201 static const int kBlockFieldNumber = 1;
202 private:
203 const ::Hdfs::Internal::ExtendedBlockProto& _internal_block() const;
204 public:
205 const ::Hdfs::Internal::ExtendedBlockProto& block() const;
206 ::Hdfs::Internal::ExtendedBlockProto* release_block();
207 ::Hdfs::Internal::ExtendedBlockProto* mutable_block();
208 void set_allocated_block(::Hdfs::Internal::ExtendedBlockProto* block);
209
210 // @@protoc_insertion_point(class_scope:Hdfs.Internal.GetReplicaVisibleLengthRequestProto)
211 private:
212 void set_has_block();
213 void clear_has_block();
214
215 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
216 ::google::protobuf::internal::HasBits<1> _has_bits_;
217 mutable ::google::protobuf::internal::CachedSize _cached_size_;
218 ::Hdfs::Internal::ExtendedBlockProto* block_;
219 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
220};
221// -------------------------------------------------------------------
222
223class GetReplicaVisibleLengthResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.GetReplicaVisibleLengthResponseProto) */ {
224 public:
225 GetReplicaVisibleLengthResponseProto();
226 virtual ~GetReplicaVisibleLengthResponseProto();
227
228 GetReplicaVisibleLengthResponseProto(const GetReplicaVisibleLengthResponseProto& from);
229
230 inline GetReplicaVisibleLengthResponseProto& operator=(const GetReplicaVisibleLengthResponseProto& from) {
231 CopyFrom(from);
232 return *this;
233 }
234 #if LANG_CXX11
235 GetReplicaVisibleLengthResponseProto(GetReplicaVisibleLengthResponseProto&& from) noexcept
236 : GetReplicaVisibleLengthResponseProto() {
237 *this = ::std::move(from);
238 }
239
240 inline GetReplicaVisibleLengthResponseProto& operator=(GetReplicaVisibleLengthResponseProto&& from) noexcept {
241 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
242 if (this != &from) InternalSwap(&from);
243 } else {
244 CopyFrom(from);
245 }
246 return *this;
247 }
248 #endif
249 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
250 return _internal_metadata_.unknown_fields();
251 }
252 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
253 return _internal_metadata_.mutable_unknown_fields();
254 }
255
256 static const ::google::protobuf::Descriptor* descriptor();
257 static const GetReplicaVisibleLengthResponseProto& default_instance();
258
259 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
260 static inline const GetReplicaVisibleLengthResponseProto* internal_default_instance() {
261 return reinterpret_cast<const GetReplicaVisibleLengthResponseProto*>(
262 &_GetReplicaVisibleLengthResponseProto_default_instance_);
263 }
264 static constexpr int kIndexInFileMessages =
265 1;
266
267 void Swap(GetReplicaVisibleLengthResponseProto* other);
268 friend void swap(GetReplicaVisibleLengthResponseProto& a, GetReplicaVisibleLengthResponseProto& b) {
269 a.Swap(&b);
270 }
271
272 // implements Message ----------------------------------------------
273
274 inline GetReplicaVisibleLengthResponseProto* New() const final {
275 return CreateMaybeMessage<GetReplicaVisibleLengthResponseProto>(NULL);
276 }
277
278 GetReplicaVisibleLengthResponseProto* New(::google::protobuf::Arena* arena) const final {
279 return CreateMaybeMessage<GetReplicaVisibleLengthResponseProto>(arena);
280 }
281 void CopyFrom(const ::google::protobuf::Message& from) final;
282 void MergeFrom(const ::google::protobuf::Message& from) final;
283 void CopyFrom(const GetReplicaVisibleLengthResponseProto& from);
284 void MergeFrom(const GetReplicaVisibleLengthResponseProto& from);
285 void Clear() final;
286 bool IsInitialized() const final;
287
288 size_t ByteSizeLong() const final;
289 bool MergePartialFromCodedStream(
290 ::google::protobuf::io::CodedInputStream* input) final;
291 void SerializeWithCachedSizes(
292 ::google::protobuf::io::CodedOutputStream* output) const final;
293 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
294 bool deterministic, ::google::protobuf::uint8* target) const final;
295 int GetCachedSize() const final { return _cached_size_.Get(); }
296
297 private:
298 void SharedCtor();
299 void SharedDtor();
300 void SetCachedSize(int size) const final;
301 void InternalSwap(GetReplicaVisibleLengthResponseProto* other);
302 private:
303 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
304 return NULL;
305 }
306 inline void* MaybeArenaPtr() const {
307 return NULL;
308 }
309 public:
310
311 ::google::protobuf::Metadata GetMetadata() const final;
312
313 // nested types ----------------------------------------------------
314
315 // accessors -------------------------------------------------------
316
317 // required uint64 length = 1;
318 bool has_length() const;
319 void clear_length();
320 static const int kLengthFieldNumber = 1;
321 ::google::protobuf::uint64 length() const;
322 void set_length(::google::protobuf::uint64 value);
323
324 // @@protoc_insertion_point(class_scope:Hdfs.Internal.GetReplicaVisibleLengthResponseProto)
325 private:
326 void set_has_length();
327 void clear_has_length();
328
329 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
330 ::google::protobuf::internal::HasBits<1> _has_bits_;
331 mutable ::google::protobuf::internal::CachedSize _cached_size_;
332 ::google::protobuf::uint64 length_;
333 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
334};
335// -------------------------------------------------------------------
336
337class RefreshNamenodesRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RefreshNamenodesRequestProto) */ {
338 public:
339 RefreshNamenodesRequestProto();
340 virtual ~RefreshNamenodesRequestProto();
341
342 RefreshNamenodesRequestProto(const RefreshNamenodesRequestProto& from);
343
344 inline RefreshNamenodesRequestProto& operator=(const RefreshNamenodesRequestProto& from) {
345 CopyFrom(from);
346 return *this;
347 }
348 #if LANG_CXX11
349 RefreshNamenodesRequestProto(RefreshNamenodesRequestProto&& from) noexcept
350 : RefreshNamenodesRequestProto() {
351 *this = ::std::move(from);
352 }
353
354 inline RefreshNamenodesRequestProto& operator=(RefreshNamenodesRequestProto&& from) noexcept {
355 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
356 if (this != &from) InternalSwap(&from);
357 } else {
358 CopyFrom(from);
359 }
360 return *this;
361 }
362 #endif
363 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
364 return _internal_metadata_.unknown_fields();
365 }
366 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
367 return _internal_metadata_.mutable_unknown_fields();
368 }
369
370 static const ::google::protobuf::Descriptor* descriptor();
371 static const RefreshNamenodesRequestProto& default_instance();
372
373 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
374 static inline const RefreshNamenodesRequestProto* internal_default_instance() {
375 return reinterpret_cast<const RefreshNamenodesRequestProto*>(
376 &_RefreshNamenodesRequestProto_default_instance_);
377 }
378 static constexpr int kIndexInFileMessages =
379 2;
380
381 void Swap(RefreshNamenodesRequestProto* other);
382 friend void swap(RefreshNamenodesRequestProto& a, RefreshNamenodesRequestProto& b) {
383 a.Swap(&b);
384 }
385
386 // implements Message ----------------------------------------------
387
388 inline RefreshNamenodesRequestProto* New() const final {
389 return CreateMaybeMessage<RefreshNamenodesRequestProto>(NULL);
390 }
391
392 RefreshNamenodesRequestProto* New(::google::protobuf::Arena* arena) const final {
393 return CreateMaybeMessage<RefreshNamenodesRequestProto>(arena);
394 }
395 void CopyFrom(const ::google::protobuf::Message& from) final;
396 void MergeFrom(const ::google::protobuf::Message& from) final;
397 void CopyFrom(const RefreshNamenodesRequestProto& from);
398 void MergeFrom(const RefreshNamenodesRequestProto& from);
399 void Clear() final;
400 bool IsInitialized() const final;
401
402 size_t ByteSizeLong() const final;
403 bool MergePartialFromCodedStream(
404 ::google::protobuf::io::CodedInputStream* input) final;
405 void SerializeWithCachedSizes(
406 ::google::protobuf::io::CodedOutputStream* output) const final;
407 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
408 bool deterministic, ::google::protobuf::uint8* target) const final;
409 int GetCachedSize() const final { return _cached_size_.Get(); }
410
411 private:
412 void SharedCtor();
413 void SharedDtor();
414 void SetCachedSize(int size) const final;
415 void InternalSwap(RefreshNamenodesRequestProto* other);
416 private:
417 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
418 return NULL;
419 }
420 inline void* MaybeArenaPtr() const {
421 return NULL;
422 }
423 public:
424
425 ::google::protobuf::Metadata GetMetadata() const final;
426
427 // nested types ----------------------------------------------------
428
429 // accessors -------------------------------------------------------
430
431 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RefreshNamenodesRequestProto)
432 private:
433
434 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
435 ::google::protobuf::internal::HasBits<1> _has_bits_;
436 mutable ::google::protobuf::internal::CachedSize _cached_size_;
437 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
438};
439// -------------------------------------------------------------------
440
441class RefreshNamenodesResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RefreshNamenodesResponseProto) */ {
442 public:
443 RefreshNamenodesResponseProto();
444 virtual ~RefreshNamenodesResponseProto();
445
446 RefreshNamenodesResponseProto(const RefreshNamenodesResponseProto& from);
447
448 inline RefreshNamenodesResponseProto& operator=(const RefreshNamenodesResponseProto& from) {
449 CopyFrom(from);
450 return *this;
451 }
452 #if LANG_CXX11
453 RefreshNamenodesResponseProto(RefreshNamenodesResponseProto&& from) noexcept
454 : RefreshNamenodesResponseProto() {
455 *this = ::std::move(from);
456 }
457
458 inline RefreshNamenodesResponseProto& operator=(RefreshNamenodesResponseProto&& from) noexcept {
459 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
460 if (this != &from) InternalSwap(&from);
461 } else {
462 CopyFrom(from);
463 }
464 return *this;
465 }
466 #endif
467 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
468 return _internal_metadata_.unknown_fields();
469 }
470 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
471 return _internal_metadata_.mutable_unknown_fields();
472 }
473
474 static const ::google::protobuf::Descriptor* descriptor();
475 static const RefreshNamenodesResponseProto& default_instance();
476
477 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
478 static inline const RefreshNamenodesResponseProto* internal_default_instance() {
479 return reinterpret_cast<const RefreshNamenodesResponseProto*>(
480 &_RefreshNamenodesResponseProto_default_instance_);
481 }
482 static constexpr int kIndexInFileMessages =
483 3;
484
485 void Swap(RefreshNamenodesResponseProto* other);
486 friend void swap(RefreshNamenodesResponseProto& a, RefreshNamenodesResponseProto& b) {
487 a.Swap(&b);
488 }
489
490 // implements Message ----------------------------------------------
491
492 inline RefreshNamenodesResponseProto* New() const final {
493 return CreateMaybeMessage<RefreshNamenodesResponseProto>(NULL);
494 }
495
496 RefreshNamenodesResponseProto* New(::google::protobuf::Arena* arena) const final {
497 return CreateMaybeMessage<RefreshNamenodesResponseProto>(arena);
498 }
499 void CopyFrom(const ::google::protobuf::Message& from) final;
500 void MergeFrom(const ::google::protobuf::Message& from) final;
501 void CopyFrom(const RefreshNamenodesResponseProto& from);
502 void MergeFrom(const RefreshNamenodesResponseProto& from);
503 void Clear() final;
504 bool IsInitialized() const final;
505
506 size_t ByteSizeLong() const final;
507 bool MergePartialFromCodedStream(
508 ::google::protobuf::io::CodedInputStream* input) final;
509 void SerializeWithCachedSizes(
510 ::google::protobuf::io::CodedOutputStream* output) const final;
511 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
512 bool deterministic, ::google::protobuf::uint8* target) const final;
513 int GetCachedSize() const final { return _cached_size_.Get(); }
514
515 private:
516 void SharedCtor();
517 void SharedDtor();
518 void SetCachedSize(int size) const final;
519 void InternalSwap(RefreshNamenodesResponseProto* other);
520 private:
521 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
522 return NULL;
523 }
524 inline void* MaybeArenaPtr() const {
525 return NULL;
526 }
527 public:
528
529 ::google::protobuf::Metadata GetMetadata() const final;
530
531 // nested types ----------------------------------------------------
532
533 // accessors -------------------------------------------------------
534
535 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RefreshNamenodesResponseProto)
536 private:
537
538 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
539 ::google::protobuf::internal::HasBits<1> _has_bits_;
540 mutable ::google::protobuf::internal::CachedSize _cached_size_;
541 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
542};
543// -------------------------------------------------------------------
544
545class DeleteBlockPoolRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DeleteBlockPoolRequestProto) */ {
546 public:
547 DeleteBlockPoolRequestProto();
548 virtual ~DeleteBlockPoolRequestProto();
549
550 DeleteBlockPoolRequestProto(const DeleteBlockPoolRequestProto& from);
551
552 inline DeleteBlockPoolRequestProto& operator=(const DeleteBlockPoolRequestProto& from) {
553 CopyFrom(from);
554 return *this;
555 }
556 #if LANG_CXX11
557 DeleteBlockPoolRequestProto(DeleteBlockPoolRequestProto&& from) noexcept
558 : DeleteBlockPoolRequestProto() {
559 *this = ::std::move(from);
560 }
561
562 inline DeleteBlockPoolRequestProto& operator=(DeleteBlockPoolRequestProto&& from) noexcept {
563 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
564 if (this != &from) InternalSwap(&from);
565 } else {
566 CopyFrom(from);
567 }
568 return *this;
569 }
570 #endif
571 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
572 return _internal_metadata_.unknown_fields();
573 }
574 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
575 return _internal_metadata_.mutable_unknown_fields();
576 }
577
578 static const ::google::protobuf::Descriptor* descriptor();
579 static const DeleteBlockPoolRequestProto& default_instance();
580
581 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
582 static inline const DeleteBlockPoolRequestProto* internal_default_instance() {
583 return reinterpret_cast<const DeleteBlockPoolRequestProto*>(
584 &_DeleteBlockPoolRequestProto_default_instance_);
585 }
586 static constexpr int kIndexInFileMessages =
587 4;
588
589 void Swap(DeleteBlockPoolRequestProto* other);
590 friend void swap(DeleteBlockPoolRequestProto& a, DeleteBlockPoolRequestProto& b) {
591 a.Swap(&b);
592 }
593
594 // implements Message ----------------------------------------------
595
596 inline DeleteBlockPoolRequestProto* New() const final {
597 return CreateMaybeMessage<DeleteBlockPoolRequestProto>(NULL);
598 }
599
600 DeleteBlockPoolRequestProto* New(::google::protobuf::Arena* arena) const final {
601 return CreateMaybeMessage<DeleteBlockPoolRequestProto>(arena);
602 }
603 void CopyFrom(const ::google::protobuf::Message& from) final;
604 void MergeFrom(const ::google::protobuf::Message& from) final;
605 void CopyFrom(const DeleteBlockPoolRequestProto& from);
606 void MergeFrom(const DeleteBlockPoolRequestProto& from);
607 void Clear() final;
608 bool IsInitialized() const final;
609
610 size_t ByteSizeLong() const final;
611 bool MergePartialFromCodedStream(
612 ::google::protobuf::io::CodedInputStream* input) final;
613 void SerializeWithCachedSizes(
614 ::google::protobuf::io::CodedOutputStream* output) const final;
615 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
616 bool deterministic, ::google::protobuf::uint8* target) const final;
617 int GetCachedSize() const final { return _cached_size_.Get(); }
618
619 private:
620 void SharedCtor();
621 void SharedDtor();
622 void SetCachedSize(int size) const final;
623 void InternalSwap(DeleteBlockPoolRequestProto* other);
624 private:
625 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
626 return NULL;
627 }
628 inline void* MaybeArenaPtr() const {
629 return NULL;
630 }
631 public:
632
633 ::google::protobuf::Metadata GetMetadata() const final;
634
635 // nested types ----------------------------------------------------
636
637 // accessors -------------------------------------------------------
638
639 // required string blockPool = 1;
640 bool has_blockpool() const;
641 void clear_blockpool();
642 static const int kBlockPoolFieldNumber = 1;
643 const ::std::string& blockpool() const;
644 void set_blockpool(const ::std::string& value);
645 #if LANG_CXX11
646 void set_blockpool(::std::string&& value);
647 #endif
648 void set_blockpool(const char* value);
649 void set_blockpool(const char* value, size_t size);
650 ::std::string* mutable_blockpool();
651 ::std::string* release_blockpool();
652 void set_allocated_blockpool(::std::string* blockpool);
653
654 // required bool force = 2;
655 bool has_force() const;
656 void clear_force();
657 static const int kForceFieldNumber = 2;
658 bool force() const;
659 void set_force(bool value);
660
661 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DeleteBlockPoolRequestProto)
662 private:
663 void set_has_blockpool();
664 void clear_has_blockpool();
665 void set_has_force();
666 void clear_has_force();
667
668 // helper for ByteSizeLong()
669 size_t RequiredFieldsByteSizeFallback() const;
670
671 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
672 ::google::protobuf::internal::HasBits<1> _has_bits_;
673 mutable ::google::protobuf::internal::CachedSize _cached_size_;
674 ::google::protobuf::internal::ArenaStringPtr blockpool_;
675 bool force_;
676 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
677};
678// -------------------------------------------------------------------
679
680class DeleteBlockPoolResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DeleteBlockPoolResponseProto) */ {
681 public:
682 DeleteBlockPoolResponseProto();
683 virtual ~DeleteBlockPoolResponseProto();
684
685 DeleteBlockPoolResponseProto(const DeleteBlockPoolResponseProto& from);
686
687 inline DeleteBlockPoolResponseProto& operator=(const DeleteBlockPoolResponseProto& from) {
688 CopyFrom(from);
689 return *this;
690 }
691 #if LANG_CXX11
692 DeleteBlockPoolResponseProto(DeleteBlockPoolResponseProto&& from) noexcept
693 : DeleteBlockPoolResponseProto() {
694 *this = ::std::move(from);
695 }
696
697 inline DeleteBlockPoolResponseProto& operator=(DeleteBlockPoolResponseProto&& from) noexcept {
698 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
699 if (this != &from) InternalSwap(&from);
700 } else {
701 CopyFrom(from);
702 }
703 return *this;
704 }
705 #endif
706 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
707 return _internal_metadata_.unknown_fields();
708 }
709 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
710 return _internal_metadata_.mutable_unknown_fields();
711 }
712
713 static const ::google::protobuf::Descriptor* descriptor();
714 static const DeleteBlockPoolResponseProto& default_instance();
715
716 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
717 static inline const DeleteBlockPoolResponseProto* internal_default_instance() {
718 return reinterpret_cast<const DeleteBlockPoolResponseProto*>(
719 &_DeleteBlockPoolResponseProto_default_instance_);
720 }
721 static constexpr int kIndexInFileMessages =
722 5;
723
724 void Swap(DeleteBlockPoolResponseProto* other);
725 friend void swap(DeleteBlockPoolResponseProto& a, DeleteBlockPoolResponseProto& b) {
726 a.Swap(&b);
727 }
728
729 // implements Message ----------------------------------------------
730
731 inline DeleteBlockPoolResponseProto* New() const final {
732 return CreateMaybeMessage<DeleteBlockPoolResponseProto>(NULL);
733 }
734
735 DeleteBlockPoolResponseProto* New(::google::protobuf::Arena* arena) const final {
736 return CreateMaybeMessage<DeleteBlockPoolResponseProto>(arena);
737 }
738 void CopyFrom(const ::google::protobuf::Message& from) final;
739 void MergeFrom(const ::google::protobuf::Message& from) final;
740 void CopyFrom(const DeleteBlockPoolResponseProto& from);
741 void MergeFrom(const DeleteBlockPoolResponseProto& from);
742 void Clear() final;
743 bool IsInitialized() const final;
744
745 size_t ByteSizeLong() const final;
746 bool MergePartialFromCodedStream(
747 ::google::protobuf::io::CodedInputStream* input) final;
748 void SerializeWithCachedSizes(
749 ::google::protobuf::io::CodedOutputStream* output) const final;
750 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
751 bool deterministic, ::google::protobuf::uint8* target) const final;
752 int GetCachedSize() const final { return _cached_size_.Get(); }
753
754 private:
755 void SharedCtor();
756 void SharedDtor();
757 void SetCachedSize(int size) const final;
758 void InternalSwap(DeleteBlockPoolResponseProto* other);
759 private:
760 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
761 return NULL;
762 }
763 inline void* MaybeArenaPtr() const {
764 return NULL;
765 }
766 public:
767
768 ::google::protobuf::Metadata GetMetadata() const final;
769
770 // nested types ----------------------------------------------------
771
772 // accessors -------------------------------------------------------
773
774 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DeleteBlockPoolResponseProto)
775 private:
776
777 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
778 ::google::protobuf::internal::HasBits<1> _has_bits_;
779 mutable ::google::protobuf::internal::CachedSize _cached_size_;
780 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
781};
782// -------------------------------------------------------------------
783
784class GetBlockLocalPathInfoRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.GetBlockLocalPathInfoRequestProto) */ {
785 public:
786 GetBlockLocalPathInfoRequestProto();
787 virtual ~GetBlockLocalPathInfoRequestProto();
788
789 GetBlockLocalPathInfoRequestProto(const GetBlockLocalPathInfoRequestProto& from);
790
791 inline GetBlockLocalPathInfoRequestProto& operator=(const GetBlockLocalPathInfoRequestProto& from) {
792 CopyFrom(from);
793 return *this;
794 }
795 #if LANG_CXX11
796 GetBlockLocalPathInfoRequestProto(GetBlockLocalPathInfoRequestProto&& from) noexcept
797 : GetBlockLocalPathInfoRequestProto() {
798 *this = ::std::move(from);
799 }
800
801 inline GetBlockLocalPathInfoRequestProto& operator=(GetBlockLocalPathInfoRequestProto&& from) noexcept {
802 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
803 if (this != &from) InternalSwap(&from);
804 } else {
805 CopyFrom(from);
806 }
807 return *this;
808 }
809 #endif
810 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
811 return _internal_metadata_.unknown_fields();
812 }
813 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
814 return _internal_metadata_.mutable_unknown_fields();
815 }
816
817 static const ::google::protobuf::Descriptor* descriptor();
818 static const GetBlockLocalPathInfoRequestProto& default_instance();
819
820 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
821 static inline const GetBlockLocalPathInfoRequestProto* internal_default_instance() {
822 return reinterpret_cast<const GetBlockLocalPathInfoRequestProto*>(
823 &_GetBlockLocalPathInfoRequestProto_default_instance_);
824 }
825 static constexpr int kIndexInFileMessages =
826 6;
827
828 void Swap(GetBlockLocalPathInfoRequestProto* other);
829 friend void swap(GetBlockLocalPathInfoRequestProto& a, GetBlockLocalPathInfoRequestProto& b) {
830 a.Swap(&b);
831 }
832
833 // implements Message ----------------------------------------------
834
835 inline GetBlockLocalPathInfoRequestProto* New() const final {
836 return CreateMaybeMessage<GetBlockLocalPathInfoRequestProto>(NULL);
837 }
838
839 GetBlockLocalPathInfoRequestProto* New(::google::protobuf::Arena* arena) const final {
840 return CreateMaybeMessage<GetBlockLocalPathInfoRequestProto>(arena);
841 }
842 void CopyFrom(const ::google::protobuf::Message& from) final;
843 void MergeFrom(const ::google::protobuf::Message& from) final;
844 void CopyFrom(const GetBlockLocalPathInfoRequestProto& from);
845 void MergeFrom(const GetBlockLocalPathInfoRequestProto& from);
846 void Clear() final;
847 bool IsInitialized() const final;
848
849 size_t ByteSizeLong() const final;
850 bool MergePartialFromCodedStream(
851 ::google::protobuf::io::CodedInputStream* input) final;
852 void SerializeWithCachedSizes(
853 ::google::protobuf::io::CodedOutputStream* output) const final;
854 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
855 bool deterministic, ::google::protobuf::uint8* target) const final;
856 int GetCachedSize() const final { return _cached_size_.Get(); }
857
858 private:
859 void SharedCtor();
860 void SharedDtor();
861 void SetCachedSize(int size) const final;
862 void InternalSwap(GetBlockLocalPathInfoRequestProto* other);
863 private:
864 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
865 return NULL;
866 }
867 inline void* MaybeArenaPtr() const {
868 return NULL;
869 }
870 public:
871
872 ::google::protobuf::Metadata GetMetadata() const final;
873
874 // nested types ----------------------------------------------------
875
876 // accessors -------------------------------------------------------
877
878 // required .Hdfs.Internal.ExtendedBlockProto block = 1;
879 bool has_block() const;
880 void clear_block();
881 static const int kBlockFieldNumber = 1;
882 private:
883 const ::Hdfs::Internal::ExtendedBlockProto& _internal_block() const;
884 public:
885 const ::Hdfs::Internal::ExtendedBlockProto& block() const;
886 ::Hdfs::Internal::ExtendedBlockProto* release_block();
887 ::Hdfs::Internal::ExtendedBlockProto* mutable_block();
888 void set_allocated_block(::Hdfs::Internal::ExtendedBlockProto* block);
889
890 // required .Hdfs.Internal.TokenProto token = 2;
891 bool has_token() const;
892 void clear_token();
893 static const int kTokenFieldNumber = 2;
894 private:
895 const ::Hdfs::Internal::TokenProto& _internal_token() const;
896 public:
897 const ::Hdfs::Internal::TokenProto& token() const;
898 ::Hdfs::Internal::TokenProto* release_token();
899 ::Hdfs::Internal::TokenProto* mutable_token();
900 void set_allocated_token(::Hdfs::Internal::TokenProto* token);
901
902 // @@protoc_insertion_point(class_scope:Hdfs.Internal.GetBlockLocalPathInfoRequestProto)
903 private:
904 void set_has_block();
905 void clear_has_block();
906 void set_has_token();
907 void clear_has_token();
908
909 // helper for ByteSizeLong()
910 size_t RequiredFieldsByteSizeFallback() const;
911
912 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
913 ::google::protobuf::internal::HasBits<1> _has_bits_;
914 mutable ::google::protobuf::internal::CachedSize _cached_size_;
915 ::Hdfs::Internal::ExtendedBlockProto* block_;
916 ::Hdfs::Internal::TokenProto* token_;
917 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
918};
919// -------------------------------------------------------------------
920
921class GetBlockLocalPathInfoResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.GetBlockLocalPathInfoResponseProto) */ {
922 public:
923 GetBlockLocalPathInfoResponseProto();
924 virtual ~GetBlockLocalPathInfoResponseProto();
925
926 GetBlockLocalPathInfoResponseProto(const GetBlockLocalPathInfoResponseProto& from);
927
928 inline GetBlockLocalPathInfoResponseProto& operator=(const GetBlockLocalPathInfoResponseProto& from) {
929 CopyFrom(from);
930 return *this;
931 }
932 #if LANG_CXX11
933 GetBlockLocalPathInfoResponseProto(GetBlockLocalPathInfoResponseProto&& from) noexcept
934 : GetBlockLocalPathInfoResponseProto() {
935 *this = ::std::move(from);
936 }
937
938 inline GetBlockLocalPathInfoResponseProto& operator=(GetBlockLocalPathInfoResponseProto&& from) noexcept {
939 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
940 if (this != &from) InternalSwap(&from);
941 } else {
942 CopyFrom(from);
943 }
944 return *this;
945 }
946 #endif
947 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
948 return _internal_metadata_.unknown_fields();
949 }
950 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
951 return _internal_metadata_.mutable_unknown_fields();
952 }
953
954 static const ::google::protobuf::Descriptor* descriptor();
955 static const GetBlockLocalPathInfoResponseProto& default_instance();
956
957 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
958 static inline const GetBlockLocalPathInfoResponseProto* internal_default_instance() {
959 return reinterpret_cast<const GetBlockLocalPathInfoResponseProto*>(
960 &_GetBlockLocalPathInfoResponseProto_default_instance_);
961 }
962 static constexpr int kIndexInFileMessages =
963 7;
964
965 void Swap(GetBlockLocalPathInfoResponseProto* other);
966 friend void swap(GetBlockLocalPathInfoResponseProto& a, GetBlockLocalPathInfoResponseProto& b) {
967 a.Swap(&b);
968 }
969
970 // implements Message ----------------------------------------------
971
972 inline GetBlockLocalPathInfoResponseProto* New() const final {
973 return CreateMaybeMessage<GetBlockLocalPathInfoResponseProto>(NULL);
974 }
975
976 GetBlockLocalPathInfoResponseProto* New(::google::protobuf::Arena* arena) const final {
977 return CreateMaybeMessage<GetBlockLocalPathInfoResponseProto>(arena);
978 }
979 void CopyFrom(const ::google::protobuf::Message& from) final;
980 void MergeFrom(const ::google::protobuf::Message& from) final;
981 void CopyFrom(const GetBlockLocalPathInfoResponseProto& from);
982 void MergeFrom(const GetBlockLocalPathInfoResponseProto& from);
983 void Clear() final;
984 bool IsInitialized() const final;
985
986 size_t ByteSizeLong() const final;
987 bool MergePartialFromCodedStream(
988 ::google::protobuf::io::CodedInputStream* input) final;
989 void SerializeWithCachedSizes(
990 ::google::protobuf::io::CodedOutputStream* output) const final;
991 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
992 bool deterministic, ::google::protobuf::uint8* target) const final;
993 int GetCachedSize() const final { return _cached_size_.Get(); }
994
995 private:
996 void SharedCtor();
997 void SharedDtor();
998 void SetCachedSize(int size) const final;
999 void InternalSwap(GetBlockLocalPathInfoResponseProto* other);
1000 private:
1001 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1002 return NULL;
1003 }
1004 inline void* MaybeArenaPtr() const {
1005 return NULL;
1006 }
1007 public:
1008
1009 ::google::protobuf::Metadata GetMetadata() const final;
1010
1011 // nested types ----------------------------------------------------
1012
1013 // accessors -------------------------------------------------------
1014
1015 // required string localPath = 2;
1016 bool has_localpath() const;
1017 void clear_localpath();
1018 static const int kLocalPathFieldNumber = 2;
1019 const ::std::string& localpath() const;
1020 void set_localpath(const ::std::string& value);
1021 #if LANG_CXX11
1022 void set_localpath(::std::string&& value);
1023 #endif
1024 void set_localpath(const char* value);
1025 void set_localpath(const char* value, size_t size);
1026 ::std::string* mutable_localpath();
1027 ::std::string* release_localpath();
1028 void set_allocated_localpath(::std::string* localpath);
1029
1030 // required string localMetaPath = 3;
1031 bool has_localmetapath() const;
1032 void clear_localmetapath();
1033 static const int kLocalMetaPathFieldNumber = 3;
1034 const ::std::string& localmetapath() const;
1035 void set_localmetapath(const ::std::string& value);
1036 #if LANG_CXX11
1037 void set_localmetapath(::std::string&& value);
1038 #endif
1039 void set_localmetapath(const char* value);
1040 void set_localmetapath(const char* value, size_t size);
1041 ::std::string* mutable_localmetapath();
1042 ::std::string* release_localmetapath();
1043 void set_allocated_localmetapath(::std::string* localmetapath);
1044
1045 // required .Hdfs.Internal.ExtendedBlockProto block = 1;
1046 bool has_block() const;
1047 void clear_block();
1048 static const int kBlockFieldNumber = 1;
1049 private:
1050 const ::Hdfs::Internal::ExtendedBlockProto& _internal_block() const;
1051 public:
1052 const ::Hdfs::Internal::ExtendedBlockProto& block() const;
1053 ::Hdfs::Internal::ExtendedBlockProto* release_block();
1054 ::Hdfs::Internal::ExtendedBlockProto* mutable_block();
1055 void set_allocated_block(::Hdfs::Internal::ExtendedBlockProto* block);
1056
1057 // @@protoc_insertion_point(class_scope:Hdfs.Internal.GetBlockLocalPathInfoResponseProto)
1058 private:
1059 void set_has_block();
1060 void clear_has_block();
1061 void set_has_localpath();
1062 void clear_has_localpath();
1063 void set_has_localmetapath();
1064 void clear_has_localmetapath();
1065
1066 // helper for ByteSizeLong()
1067 size_t RequiredFieldsByteSizeFallback() const;
1068
1069 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1070 ::google::protobuf::internal::HasBits<1> _has_bits_;
1071 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1072 ::google::protobuf::internal::ArenaStringPtr localpath_;
1073 ::google::protobuf::internal::ArenaStringPtr localmetapath_;
1074 ::Hdfs::Internal::ExtendedBlockProto* block_;
1075 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
1076};
1077// -------------------------------------------------------------------
1078
1079class GetHdfsBlockLocationsRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.GetHdfsBlockLocationsRequestProto) */ {
1080 public:
1081 GetHdfsBlockLocationsRequestProto();
1082 virtual ~GetHdfsBlockLocationsRequestProto();
1083
1084 GetHdfsBlockLocationsRequestProto(const GetHdfsBlockLocationsRequestProto& from);
1085
1086 inline GetHdfsBlockLocationsRequestProto& operator=(const GetHdfsBlockLocationsRequestProto& from) {
1087 CopyFrom(from);
1088 return *this;
1089 }
1090 #if LANG_CXX11
1091 GetHdfsBlockLocationsRequestProto(GetHdfsBlockLocationsRequestProto&& from) noexcept
1092 : GetHdfsBlockLocationsRequestProto() {
1093 *this = ::std::move(from);
1094 }
1095
1096 inline GetHdfsBlockLocationsRequestProto& operator=(GetHdfsBlockLocationsRequestProto&& from) noexcept {
1097 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1098 if (this != &from) InternalSwap(&from);
1099 } else {
1100 CopyFrom(from);
1101 }
1102 return *this;
1103 }
1104 #endif
1105 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1106 return _internal_metadata_.unknown_fields();
1107 }
1108 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1109 return _internal_metadata_.mutable_unknown_fields();
1110 }
1111
1112 static const ::google::protobuf::Descriptor* descriptor();
1113 static const GetHdfsBlockLocationsRequestProto& default_instance();
1114
1115 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1116 static inline const GetHdfsBlockLocationsRequestProto* internal_default_instance() {
1117 return reinterpret_cast<const GetHdfsBlockLocationsRequestProto*>(
1118 &_GetHdfsBlockLocationsRequestProto_default_instance_);
1119 }
1120 static constexpr int kIndexInFileMessages =
1121 8;
1122
1123 void Swap(GetHdfsBlockLocationsRequestProto* other);
1124 friend void swap(GetHdfsBlockLocationsRequestProto& a, GetHdfsBlockLocationsRequestProto& b) {
1125 a.Swap(&b);
1126 }
1127
1128 // implements Message ----------------------------------------------
1129
1130 inline GetHdfsBlockLocationsRequestProto* New() const final {
1131 return CreateMaybeMessage<GetHdfsBlockLocationsRequestProto>(NULL);
1132 }
1133
1134 GetHdfsBlockLocationsRequestProto* New(::google::protobuf::Arena* arena) const final {
1135 return CreateMaybeMessage<GetHdfsBlockLocationsRequestProto>(arena);
1136 }
1137 void CopyFrom(const ::google::protobuf::Message& from) final;
1138 void MergeFrom(const ::google::protobuf::Message& from) final;
1139 void CopyFrom(const GetHdfsBlockLocationsRequestProto& from);
1140 void MergeFrom(const GetHdfsBlockLocationsRequestProto& from);
1141 void Clear() final;
1142 bool IsInitialized() const final;
1143
1144 size_t ByteSizeLong() const final;
1145 bool MergePartialFromCodedStream(
1146 ::google::protobuf::io::CodedInputStream* input) final;
1147 void SerializeWithCachedSizes(
1148 ::google::protobuf::io::CodedOutputStream* output) const final;
1149 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1150 bool deterministic, ::google::protobuf::uint8* target) const final;
1151 int GetCachedSize() const final { return _cached_size_.Get(); }
1152
1153 private:
1154 void SharedCtor();
1155 void SharedDtor();
1156 void SetCachedSize(int size) const final;
1157 void InternalSwap(GetHdfsBlockLocationsRequestProto* other);
1158 private:
1159 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1160 return NULL;
1161 }
1162 inline void* MaybeArenaPtr() const {
1163 return NULL;
1164 }
1165 public:
1166
1167 ::google::protobuf::Metadata GetMetadata() const final;
1168
1169 // nested types ----------------------------------------------------
1170
1171 // accessors -------------------------------------------------------
1172
1173 // repeated .Hdfs.Internal.ExtendedBlockProto blocks = 1;
1174 int blocks_size() const;
1175 void clear_blocks();
1176 static const int kBlocksFieldNumber = 1;
1177 ::Hdfs::Internal::ExtendedBlockProto* mutable_blocks(int index);
1178 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::ExtendedBlockProto >*
1179 mutable_blocks();
1180 const ::Hdfs::Internal::ExtendedBlockProto& blocks(int index) const;
1181 ::Hdfs::Internal::ExtendedBlockProto* add_blocks();
1182 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::ExtendedBlockProto >&
1183 blocks() const;
1184
1185 // repeated .Hdfs.Internal.TokenProto tokens = 2;
1186 int tokens_size() const;
1187 void clear_tokens();
1188 static const int kTokensFieldNumber = 2;
1189 ::Hdfs::Internal::TokenProto* mutable_tokens(int index);
1190 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::TokenProto >*
1191 mutable_tokens();
1192 const ::Hdfs::Internal::TokenProto& tokens(int index) const;
1193 ::Hdfs::Internal::TokenProto* add_tokens();
1194 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::TokenProto >&
1195 tokens() const;
1196
1197 // @@protoc_insertion_point(class_scope:Hdfs.Internal.GetHdfsBlockLocationsRequestProto)
1198 private:
1199
1200 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1201 ::google::protobuf::internal::HasBits<1> _has_bits_;
1202 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1203 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::ExtendedBlockProto > blocks_;
1204 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::TokenProto > tokens_;
1205 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
1206};
1207// -------------------------------------------------------------------
1208
1209class GetHdfsBlockLocationsResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.GetHdfsBlockLocationsResponseProto) */ {
1210 public:
1211 GetHdfsBlockLocationsResponseProto();
1212 virtual ~GetHdfsBlockLocationsResponseProto();
1213
1214 GetHdfsBlockLocationsResponseProto(const GetHdfsBlockLocationsResponseProto& from);
1215
1216 inline GetHdfsBlockLocationsResponseProto& operator=(const GetHdfsBlockLocationsResponseProto& from) {
1217 CopyFrom(from);
1218 return *this;
1219 }
1220 #if LANG_CXX11
1221 GetHdfsBlockLocationsResponseProto(GetHdfsBlockLocationsResponseProto&& from) noexcept
1222 : GetHdfsBlockLocationsResponseProto() {
1223 *this = ::std::move(from);
1224 }
1225
1226 inline GetHdfsBlockLocationsResponseProto& operator=(GetHdfsBlockLocationsResponseProto&& from) noexcept {
1227 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1228 if (this != &from) InternalSwap(&from);
1229 } else {
1230 CopyFrom(from);
1231 }
1232 return *this;
1233 }
1234 #endif
1235 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1236 return _internal_metadata_.unknown_fields();
1237 }
1238 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1239 return _internal_metadata_.mutable_unknown_fields();
1240 }
1241
1242 static const ::google::protobuf::Descriptor* descriptor();
1243 static const GetHdfsBlockLocationsResponseProto& default_instance();
1244
1245 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1246 static inline const GetHdfsBlockLocationsResponseProto* internal_default_instance() {
1247 return reinterpret_cast<const GetHdfsBlockLocationsResponseProto*>(
1248 &_GetHdfsBlockLocationsResponseProto_default_instance_);
1249 }
1250 static constexpr int kIndexInFileMessages =
1251 9;
1252
1253 void Swap(GetHdfsBlockLocationsResponseProto* other);
1254 friend void swap(GetHdfsBlockLocationsResponseProto& a, GetHdfsBlockLocationsResponseProto& b) {
1255 a.Swap(&b);
1256 }
1257
1258 // implements Message ----------------------------------------------
1259
1260 inline GetHdfsBlockLocationsResponseProto* New() const final {
1261 return CreateMaybeMessage<GetHdfsBlockLocationsResponseProto>(NULL);
1262 }
1263
1264 GetHdfsBlockLocationsResponseProto* New(::google::protobuf::Arena* arena) const final {
1265 return CreateMaybeMessage<GetHdfsBlockLocationsResponseProto>(arena);
1266 }
1267 void CopyFrom(const ::google::protobuf::Message& from) final;
1268 void MergeFrom(const ::google::protobuf::Message& from) final;
1269 void CopyFrom(const GetHdfsBlockLocationsResponseProto& from);
1270 void MergeFrom(const GetHdfsBlockLocationsResponseProto& from);
1271 void Clear() final;
1272 bool IsInitialized() const final;
1273
1274 size_t ByteSizeLong() const final;
1275 bool MergePartialFromCodedStream(
1276 ::google::protobuf::io::CodedInputStream* input) final;
1277 void SerializeWithCachedSizes(
1278 ::google::protobuf::io::CodedOutputStream* output) const final;
1279 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1280 bool deterministic, ::google::protobuf::uint8* target) const final;
1281 int GetCachedSize() const final { return _cached_size_.Get(); }
1282
1283 private:
1284 void SharedCtor();
1285 void SharedDtor();
1286 void SetCachedSize(int size) const final;
1287 void InternalSwap(GetHdfsBlockLocationsResponseProto* other);
1288 private:
1289 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1290 return NULL;
1291 }
1292 inline void* MaybeArenaPtr() const {
1293 return NULL;
1294 }
1295 public:
1296
1297 ::google::protobuf::Metadata GetMetadata() const final;
1298
1299 // nested types ----------------------------------------------------
1300
1301 // accessors -------------------------------------------------------
1302
1303 // repeated bytes volumeIds = 1;
1304 int volumeids_size() const;
1305 void clear_volumeids();
1306 static const int kVolumeIdsFieldNumber = 1;
1307 const ::std::string& volumeids(int index) const;
1308 ::std::string* mutable_volumeids(int index);
1309 void set_volumeids(int index, const ::std::string& value);
1310 #if LANG_CXX11
1311 void set_volumeids(int index, ::std::string&& value);
1312 #endif
1313 void set_volumeids(int index, const char* value);
1314 void set_volumeids(int index, const void* value, size_t size);
1315 ::std::string* add_volumeids();
1316 void add_volumeids(const ::std::string& value);
1317 #if LANG_CXX11
1318 void add_volumeids(::std::string&& value);
1319 #endif
1320 void add_volumeids(const char* value);
1321 void add_volumeids(const void* value, size_t size);
1322 const ::google::protobuf::RepeatedPtrField< ::std::string>& volumeids() const;
1323 ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_volumeids();
1324
1325 // repeated uint32 volumeIndexes = 2;
1326 int volumeindexes_size() const;
1327 void clear_volumeindexes();
1328 static const int kVolumeIndexesFieldNumber = 2;
1329 ::google::protobuf::uint32 volumeindexes(int index) const;
1330 void set_volumeindexes(int index, ::google::protobuf::uint32 value);
1331 void add_volumeindexes(::google::protobuf::uint32 value);
1332 const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
1333 volumeindexes() const;
1334 ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
1335 mutable_volumeindexes();
1336
1337 // @@protoc_insertion_point(class_scope:Hdfs.Internal.GetHdfsBlockLocationsResponseProto)
1338 private:
1339
1340 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1341 ::google::protobuf::internal::HasBits<1> _has_bits_;
1342 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1343 ::google::protobuf::RepeatedPtrField< ::std::string> volumeids_;
1344 ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > volumeindexes_;
1345 friend struct ::protobuf_ClientDatanodeProtocol_2eproto::TableStruct;
1346};
1347// ===================================================================
1348
1349class ClientDatanodeProtocolService_Stub;
1350
1351class ClientDatanodeProtocolService : public ::google::protobuf::Service {
1352 protected:
1353 // This class should be treated as an abstract interface.
1354 inline ClientDatanodeProtocolService() {};
1355 public:
1356 virtual ~ClientDatanodeProtocolService();
1357
1358 typedef ClientDatanodeProtocolService_Stub Stub;
1359
1360 static const ::google::protobuf::ServiceDescriptor* descriptor();
1361
1362 virtual void getReplicaVisibleLength(::google::protobuf::RpcController* controller,
1363 const ::Hdfs::Internal::GetReplicaVisibleLengthRequestProto* request,
1364 ::Hdfs::Internal::GetReplicaVisibleLengthResponseProto* response,
1365 ::google::protobuf::Closure* done);
1366 virtual void refreshNamenodes(::google::protobuf::RpcController* controller,
1367 const ::Hdfs::Internal::RefreshNamenodesRequestProto* request,
1368 ::Hdfs::Internal::RefreshNamenodesResponseProto* response,
1369 ::google::protobuf::Closure* done);
1370 virtual void deleteBlockPool(::google::protobuf::RpcController* controller,
1371 const ::Hdfs::Internal::DeleteBlockPoolRequestProto* request,
1372 ::Hdfs::Internal::DeleteBlockPoolResponseProto* response,
1373 ::google::protobuf::Closure* done);
1374 virtual void getBlockLocalPathInfo(::google::protobuf::RpcController* controller,
1375 const ::Hdfs::Internal::GetBlockLocalPathInfoRequestProto* request,
1376 ::Hdfs::Internal::GetBlockLocalPathInfoResponseProto* response,
1377 ::google::protobuf::Closure* done);
1378 virtual void getHdfsBlockLocations(::google::protobuf::RpcController* controller,
1379 const ::Hdfs::Internal::GetHdfsBlockLocationsRequestProto* request,
1380 ::Hdfs::Internal::GetHdfsBlockLocationsResponseProto* response,
1381 ::google::protobuf::Closure* done);
1382
1383 // implements Service ----------------------------------------------
1384
1385 const ::google::protobuf::ServiceDescriptor* GetDescriptor();
1386 void CallMethod(const ::google::protobuf::MethodDescriptor* method,
1387 ::google::protobuf::RpcController* controller,
1388 const ::google::protobuf::Message* request,
1389 ::google::protobuf::Message* response,
1390 ::google::protobuf::Closure* done);
1391 const ::google::protobuf::Message& GetRequestPrototype(
1392 const ::google::protobuf::MethodDescriptor* method) const;
1393 const ::google::protobuf::Message& GetResponsePrototype(
1394 const ::google::protobuf::MethodDescriptor* method) const;
1395
1396 private:
1397 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ClientDatanodeProtocolService);
1398};
1399
1400class ClientDatanodeProtocolService_Stub : public ClientDatanodeProtocolService {
1401 public:
1402 ClientDatanodeProtocolService_Stub(::google::protobuf::RpcChannel* channel);
1403 ClientDatanodeProtocolService_Stub(::google::protobuf::RpcChannel* channel,
1404 ::google::protobuf::Service::ChannelOwnership ownership);
1405 ~ClientDatanodeProtocolService_Stub();
1406
1407 inline ::google::protobuf::RpcChannel* channel() { return channel_; }
1408
1409 // implements ClientDatanodeProtocolService ------------------------------------------
1410
1411 void getReplicaVisibleLength(::google::protobuf::RpcController* controller,
1412 const ::Hdfs::Internal::GetReplicaVisibleLengthRequestProto* request,
1413 ::Hdfs::Internal::GetReplicaVisibleLengthResponseProto* response,
1414 ::google::protobuf::Closure* done);
1415 void refreshNamenodes(::google::protobuf::RpcController* controller,
1416 const ::Hdfs::Internal::RefreshNamenodesRequestProto* request,
1417 ::Hdfs::Internal::RefreshNamenodesResponseProto* response,
1418 ::google::protobuf::Closure* done);
1419 void deleteBlockPool(::google::protobuf::RpcController* controller,
1420 const ::Hdfs::Internal::DeleteBlockPoolRequestProto* request,
1421 ::Hdfs::Internal::DeleteBlockPoolResponseProto* response,
1422 ::google::protobuf::Closure* done);
1423 void getBlockLocalPathInfo(::google::protobuf::RpcController* controller,
1424 const ::Hdfs::Internal::GetBlockLocalPathInfoRequestProto* request,
1425 ::Hdfs::Internal::GetBlockLocalPathInfoResponseProto* response,
1426 ::google::protobuf::Closure* done);
1427 void getHdfsBlockLocations(::google::protobuf::RpcController* controller,
1428 const ::Hdfs::Internal::GetHdfsBlockLocationsRequestProto* request,
1429 ::Hdfs::Internal::GetHdfsBlockLocationsResponseProto* response,
1430 ::google::protobuf::Closure* done);
1431 private:
1432 ::google::protobuf::RpcChannel* channel_;
1433 bool owns_channel_;
1434 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ClientDatanodeProtocolService_Stub);
1435};
1436
1437
1438// ===================================================================
1439
1440
1441// ===================================================================
1442
1443#ifdef __GNUC__
1444 #pragma GCC diagnostic push
1445 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1446#endif // __GNUC__
1447// GetReplicaVisibleLengthRequestProto
1448
1449// required .Hdfs.Internal.ExtendedBlockProto block = 1;
1450inline bool GetReplicaVisibleLengthRequestProto::has_block() const {
1451 return (_has_bits_[0] & 0x00000001u) != 0;
1452}
1453inline void GetReplicaVisibleLengthRequestProto::set_has_block() {
1454 _has_bits_[0] |= 0x00000001u;
1455}
1456inline void GetReplicaVisibleLengthRequestProto::clear_has_block() {
1457 _has_bits_[0] &= ~0x00000001u;
1458}
1459inline const ::Hdfs::Internal::ExtendedBlockProto& GetReplicaVisibleLengthRequestProto::_internal_block() const {
1460 return *block_;
1461}
1462inline const ::Hdfs::Internal::ExtendedBlockProto& GetReplicaVisibleLengthRequestProto::block() const {
1463 const ::Hdfs::Internal::ExtendedBlockProto* p = block_;
1464 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetReplicaVisibleLengthRequestProto.block)
1465 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ExtendedBlockProto*>(
1466 &::Hdfs::Internal::_ExtendedBlockProto_default_instance_);
1467}
1468inline ::Hdfs::Internal::ExtendedBlockProto* GetReplicaVisibleLengthRequestProto::release_block() {
1469 // @@protoc_insertion_point(field_release:Hdfs.Internal.GetReplicaVisibleLengthRequestProto.block)
1470 clear_has_block();
1471 ::Hdfs::Internal::ExtendedBlockProto* temp = block_;
1472 block_ = NULL;
1473 return temp;
1474}
1475inline ::Hdfs::Internal::ExtendedBlockProto* GetReplicaVisibleLengthRequestProto::mutable_block() {
1476 set_has_block();
1477 if (block_ == NULL) {
1478 auto* p = CreateMaybeMessage<::Hdfs::Internal::ExtendedBlockProto>(GetArenaNoVirtual());
1479 block_ = p;
1480 }
1481 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetReplicaVisibleLengthRequestProto.block)
1482 return block_;
1483}
1484inline void GetReplicaVisibleLengthRequestProto::set_allocated_block(::Hdfs::Internal::ExtendedBlockProto* block) {
1485 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1486 if (message_arena == NULL) {
1487 delete reinterpret_cast< ::google::protobuf::MessageLite*>(block_);
1488 }
1489 if (block) {
1490 ::google::protobuf::Arena* submessage_arena = NULL;
1491 if (message_arena != submessage_arena) {
1492 block = ::google::protobuf::internal::GetOwnedMessage(
1493 message_arena, block, submessage_arena);
1494 }
1495 set_has_block();
1496 } else {
1497 clear_has_block();
1498 }
1499 block_ = block;
1500 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.GetReplicaVisibleLengthRequestProto.block)
1501}
1502
1503// -------------------------------------------------------------------
1504
1505// GetReplicaVisibleLengthResponseProto
1506
1507// required uint64 length = 1;
1508inline bool GetReplicaVisibleLengthResponseProto::has_length() const {
1509 return (_has_bits_[0] & 0x00000001u) != 0;
1510}
1511inline void GetReplicaVisibleLengthResponseProto::set_has_length() {
1512 _has_bits_[0] |= 0x00000001u;
1513}
1514inline void GetReplicaVisibleLengthResponseProto::clear_has_length() {
1515 _has_bits_[0] &= ~0x00000001u;
1516}
1517inline void GetReplicaVisibleLengthResponseProto::clear_length() {
1518 length_ = GOOGLE_ULONGLONG(0);
1519 clear_has_length();
1520}
1521inline ::google::protobuf::uint64 GetReplicaVisibleLengthResponseProto::length() const {
1522 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetReplicaVisibleLengthResponseProto.length)
1523 return length_;
1524}
1525inline void GetReplicaVisibleLengthResponseProto::set_length(::google::protobuf::uint64 value) {
1526 set_has_length();
1527 length_ = value;
1528 // @@protoc_insertion_point(field_set:Hdfs.Internal.GetReplicaVisibleLengthResponseProto.length)
1529}
1530
1531// -------------------------------------------------------------------
1532
1533// RefreshNamenodesRequestProto
1534
1535// -------------------------------------------------------------------
1536
1537// RefreshNamenodesResponseProto
1538
1539// -------------------------------------------------------------------
1540
1541// DeleteBlockPoolRequestProto
1542
1543// required string blockPool = 1;
1544inline bool DeleteBlockPoolRequestProto::has_blockpool() const {
1545 return (_has_bits_[0] & 0x00000001u) != 0;
1546}
1547inline void DeleteBlockPoolRequestProto::set_has_blockpool() {
1548 _has_bits_[0] |= 0x00000001u;
1549}
1550inline void DeleteBlockPoolRequestProto::clear_has_blockpool() {
1551 _has_bits_[0] &= ~0x00000001u;
1552}
1553inline void DeleteBlockPoolRequestProto::clear_blockpool() {
1554 blockpool_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1555 clear_has_blockpool();
1556}
1557inline const ::std::string& DeleteBlockPoolRequestProto::blockpool() const {
1558 // @@protoc_insertion_point(field_get:Hdfs.Internal.DeleteBlockPoolRequestProto.blockPool)
1559 return blockpool_.GetNoArena();
1560}
1561inline void DeleteBlockPoolRequestProto::set_blockpool(const ::std::string& value) {
1562 set_has_blockpool();
1563 blockpool_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1564 // @@protoc_insertion_point(field_set:Hdfs.Internal.DeleteBlockPoolRequestProto.blockPool)
1565}
1566#if LANG_CXX11
1567inline void DeleteBlockPoolRequestProto::set_blockpool(::std::string&& value) {
1568 set_has_blockpool();
1569 blockpool_.SetNoArena(
1570 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1571 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DeleteBlockPoolRequestProto.blockPool)
1572}
1573#endif
1574inline void DeleteBlockPoolRequestProto::set_blockpool(const char* value) {
1575 GOOGLE_DCHECK(value != NULL);
1576 set_has_blockpool();
1577 blockpool_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1578 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DeleteBlockPoolRequestProto.blockPool)
1579}
1580inline void DeleteBlockPoolRequestProto::set_blockpool(const char* value, size_t size) {
1581 set_has_blockpool();
1582 blockpool_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1583 ::std::string(reinterpret_cast<const char*>(value), size));
1584 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DeleteBlockPoolRequestProto.blockPool)
1585}
1586inline ::std::string* DeleteBlockPoolRequestProto::mutable_blockpool() {
1587 set_has_blockpool();
1588 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DeleteBlockPoolRequestProto.blockPool)
1589 return blockpool_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1590}
1591inline ::std::string* DeleteBlockPoolRequestProto::release_blockpool() {
1592 // @@protoc_insertion_point(field_release:Hdfs.Internal.DeleteBlockPoolRequestProto.blockPool)
1593 if (!has_blockpool()) {
1594 return NULL;
1595 }
1596 clear_has_blockpool();
1597 return blockpool_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1598}
1599inline void DeleteBlockPoolRequestProto::set_allocated_blockpool(::std::string* blockpool) {
1600 if (blockpool != NULL) {
1601 set_has_blockpool();
1602 } else {
1603 clear_has_blockpool();
1604 }
1605 blockpool_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), blockpool);
1606 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DeleteBlockPoolRequestProto.blockPool)
1607}
1608
1609// required bool force = 2;
1610inline bool DeleteBlockPoolRequestProto::has_force() const {
1611 return (_has_bits_[0] & 0x00000002u) != 0;
1612}
1613inline void DeleteBlockPoolRequestProto::set_has_force() {
1614 _has_bits_[0] |= 0x00000002u;
1615}
1616inline void DeleteBlockPoolRequestProto::clear_has_force() {
1617 _has_bits_[0] &= ~0x00000002u;
1618}
1619inline void DeleteBlockPoolRequestProto::clear_force() {
1620 force_ = false;
1621 clear_has_force();
1622}
1623inline bool DeleteBlockPoolRequestProto::force() const {
1624 // @@protoc_insertion_point(field_get:Hdfs.Internal.DeleteBlockPoolRequestProto.force)
1625 return force_;
1626}
1627inline void DeleteBlockPoolRequestProto::set_force(bool value) {
1628 set_has_force();
1629 force_ = value;
1630 // @@protoc_insertion_point(field_set:Hdfs.Internal.DeleteBlockPoolRequestProto.force)
1631}
1632
1633// -------------------------------------------------------------------
1634
1635// DeleteBlockPoolResponseProto
1636
1637// -------------------------------------------------------------------
1638
1639// GetBlockLocalPathInfoRequestProto
1640
1641// required .Hdfs.Internal.ExtendedBlockProto block = 1;
1642inline bool GetBlockLocalPathInfoRequestProto::has_block() const {
1643 return (_has_bits_[0] & 0x00000001u) != 0;
1644}
1645inline void GetBlockLocalPathInfoRequestProto::set_has_block() {
1646 _has_bits_[0] |= 0x00000001u;
1647}
1648inline void GetBlockLocalPathInfoRequestProto::clear_has_block() {
1649 _has_bits_[0] &= ~0x00000001u;
1650}
1651inline const ::Hdfs::Internal::ExtendedBlockProto& GetBlockLocalPathInfoRequestProto::_internal_block() const {
1652 return *block_;
1653}
1654inline const ::Hdfs::Internal::ExtendedBlockProto& GetBlockLocalPathInfoRequestProto::block() const {
1655 const ::Hdfs::Internal::ExtendedBlockProto* p = block_;
1656 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetBlockLocalPathInfoRequestProto.block)
1657 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ExtendedBlockProto*>(
1658 &::Hdfs::Internal::_ExtendedBlockProto_default_instance_);
1659}
1660inline ::Hdfs::Internal::ExtendedBlockProto* GetBlockLocalPathInfoRequestProto::release_block() {
1661 // @@protoc_insertion_point(field_release:Hdfs.Internal.GetBlockLocalPathInfoRequestProto.block)
1662 clear_has_block();
1663 ::Hdfs::Internal::ExtendedBlockProto* temp = block_;
1664 block_ = NULL;
1665 return temp;
1666}
1667inline ::Hdfs::Internal::ExtendedBlockProto* GetBlockLocalPathInfoRequestProto::mutable_block() {
1668 set_has_block();
1669 if (block_ == NULL) {
1670 auto* p = CreateMaybeMessage<::Hdfs::Internal::ExtendedBlockProto>(GetArenaNoVirtual());
1671 block_ = p;
1672 }
1673 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetBlockLocalPathInfoRequestProto.block)
1674 return block_;
1675}
1676inline void GetBlockLocalPathInfoRequestProto::set_allocated_block(::Hdfs::Internal::ExtendedBlockProto* block) {
1677 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1678 if (message_arena == NULL) {
1679 delete reinterpret_cast< ::google::protobuf::MessageLite*>(block_);
1680 }
1681 if (block) {
1682 ::google::protobuf::Arena* submessage_arena = NULL;
1683 if (message_arena != submessage_arena) {
1684 block = ::google::protobuf::internal::GetOwnedMessage(
1685 message_arena, block, submessage_arena);
1686 }
1687 set_has_block();
1688 } else {
1689 clear_has_block();
1690 }
1691 block_ = block;
1692 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.GetBlockLocalPathInfoRequestProto.block)
1693}
1694
1695// required .Hdfs.Internal.TokenProto token = 2;
1696inline bool GetBlockLocalPathInfoRequestProto::has_token() const {
1697 return (_has_bits_[0] & 0x00000002u) != 0;
1698}
1699inline void GetBlockLocalPathInfoRequestProto::set_has_token() {
1700 _has_bits_[0] |= 0x00000002u;
1701}
1702inline void GetBlockLocalPathInfoRequestProto::clear_has_token() {
1703 _has_bits_[0] &= ~0x00000002u;
1704}
1705inline const ::Hdfs::Internal::TokenProto& GetBlockLocalPathInfoRequestProto::_internal_token() const {
1706 return *token_;
1707}
1708inline const ::Hdfs::Internal::TokenProto& GetBlockLocalPathInfoRequestProto::token() const {
1709 const ::Hdfs::Internal::TokenProto* p = token_;
1710 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetBlockLocalPathInfoRequestProto.token)
1711 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::TokenProto*>(
1712 &::Hdfs::Internal::_TokenProto_default_instance_);
1713}
1714inline ::Hdfs::Internal::TokenProto* GetBlockLocalPathInfoRequestProto::release_token() {
1715 // @@protoc_insertion_point(field_release:Hdfs.Internal.GetBlockLocalPathInfoRequestProto.token)
1716 clear_has_token();
1717 ::Hdfs::Internal::TokenProto* temp = token_;
1718 token_ = NULL;
1719 return temp;
1720}
1721inline ::Hdfs::Internal::TokenProto* GetBlockLocalPathInfoRequestProto::mutable_token() {
1722 set_has_token();
1723 if (token_ == NULL) {
1724 auto* p = CreateMaybeMessage<::Hdfs::Internal::TokenProto>(GetArenaNoVirtual());
1725 token_ = p;
1726 }
1727 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetBlockLocalPathInfoRequestProto.token)
1728 return token_;
1729}
1730inline void GetBlockLocalPathInfoRequestProto::set_allocated_token(::Hdfs::Internal::TokenProto* token) {
1731 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1732 if (message_arena == NULL) {
1733 delete reinterpret_cast< ::google::protobuf::MessageLite*>(token_);
1734 }
1735 if (token) {
1736 ::google::protobuf::Arena* submessage_arena = NULL;
1737 if (message_arena != submessage_arena) {
1738 token = ::google::protobuf::internal::GetOwnedMessage(
1739 message_arena, token, submessage_arena);
1740 }
1741 set_has_token();
1742 } else {
1743 clear_has_token();
1744 }
1745 token_ = token;
1746 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.GetBlockLocalPathInfoRequestProto.token)
1747}
1748
1749// -------------------------------------------------------------------
1750
1751// GetBlockLocalPathInfoResponseProto
1752
1753// required .Hdfs.Internal.ExtendedBlockProto block = 1;
1754inline bool GetBlockLocalPathInfoResponseProto::has_block() const {
1755 return (_has_bits_[0] & 0x00000004u) != 0;
1756}
1757inline void GetBlockLocalPathInfoResponseProto::set_has_block() {
1758 _has_bits_[0] |= 0x00000004u;
1759}
1760inline void GetBlockLocalPathInfoResponseProto::clear_has_block() {
1761 _has_bits_[0] &= ~0x00000004u;
1762}
1763inline const ::Hdfs::Internal::ExtendedBlockProto& GetBlockLocalPathInfoResponseProto::_internal_block() const {
1764 return *block_;
1765}
1766inline const ::Hdfs::Internal::ExtendedBlockProto& GetBlockLocalPathInfoResponseProto::block() const {
1767 const ::Hdfs::Internal::ExtendedBlockProto* p = block_;
1768 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.block)
1769 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ExtendedBlockProto*>(
1770 &::Hdfs::Internal::_ExtendedBlockProto_default_instance_);
1771}
1772inline ::Hdfs::Internal::ExtendedBlockProto* GetBlockLocalPathInfoResponseProto::release_block() {
1773 // @@protoc_insertion_point(field_release:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.block)
1774 clear_has_block();
1775 ::Hdfs::Internal::ExtendedBlockProto* temp = block_;
1776 block_ = NULL;
1777 return temp;
1778}
1779inline ::Hdfs::Internal::ExtendedBlockProto* GetBlockLocalPathInfoResponseProto::mutable_block() {
1780 set_has_block();
1781 if (block_ == NULL) {
1782 auto* p = CreateMaybeMessage<::Hdfs::Internal::ExtendedBlockProto>(GetArenaNoVirtual());
1783 block_ = p;
1784 }
1785 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.block)
1786 return block_;
1787}
1788inline void GetBlockLocalPathInfoResponseProto::set_allocated_block(::Hdfs::Internal::ExtendedBlockProto* block) {
1789 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1790 if (message_arena == NULL) {
1791 delete reinterpret_cast< ::google::protobuf::MessageLite*>(block_);
1792 }
1793 if (block) {
1794 ::google::protobuf::Arena* submessage_arena = NULL;
1795 if (message_arena != submessage_arena) {
1796 block = ::google::protobuf::internal::GetOwnedMessage(
1797 message_arena, block, submessage_arena);
1798 }
1799 set_has_block();
1800 } else {
1801 clear_has_block();
1802 }
1803 block_ = block;
1804 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.block)
1805}
1806
1807// required string localPath = 2;
1808inline bool GetBlockLocalPathInfoResponseProto::has_localpath() const {
1809 return (_has_bits_[0] & 0x00000001u) != 0;
1810}
1811inline void GetBlockLocalPathInfoResponseProto::set_has_localpath() {
1812 _has_bits_[0] |= 0x00000001u;
1813}
1814inline void GetBlockLocalPathInfoResponseProto::clear_has_localpath() {
1815 _has_bits_[0] &= ~0x00000001u;
1816}
1817inline void GetBlockLocalPathInfoResponseProto::clear_localpath() {
1818 localpath_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1819 clear_has_localpath();
1820}
1821inline const ::std::string& GetBlockLocalPathInfoResponseProto::localpath() const {
1822 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localPath)
1823 return localpath_.GetNoArena();
1824}
1825inline void GetBlockLocalPathInfoResponseProto::set_localpath(const ::std::string& value) {
1826 set_has_localpath();
1827 localpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1828 // @@protoc_insertion_point(field_set:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localPath)
1829}
1830#if LANG_CXX11
1831inline void GetBlockLocalPathInfoResponseProto::set_localpath(::std::string&& value) {
1832 set_has_localpath();
1833 localpath_.SetNoArena(
1834 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1835 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localPath)
1836}
1837#endif
1838inline void GetBlockLocalPathInfoResponseProto::set_localpath(const char* value) {
1839 GOOGLE_DCHECK(value != NULL);
1840 set_has_localpath();
1841 localpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1842 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localPath)
1843}
1844inline void GetBlockLocalPathInfoResponseProto::set_localpath(const char* value, size_t size) {
1845 set_has_localpath();
1846 localpath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1847 ::std::string(reinterpret_cast<const char*>(value), size));
1848 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localPath)
1849}
1850inline ::std::string* GetBlockLocalPathInfoResponseProto::mutable_localpath() {
1851 set_has_localpath();
1852 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localPath)
1853 return localpath_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1854}
1855inline ::std::string* GetBlockLocalPathInfoResponseProto::release_localpath() {
1856 // @@protoc_insertion_point(field_release:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localPath)
1857 if (!has_localpath()) {
1858 return NULL;
1859 }
1860 clear_has_localpath();
1861 return localpath_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1862}
1863inline void GetBlockLocalPathInfoResponseProto::set_allocated_localpath(::std::string* localpath) {
1864 if (localpath != NULL) {
1865 set_has_localpath();
1866 } else {
1867 clear_has_localpath();
1868 }
1869 localpath_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), localpath);
1870 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localPath)
1871}
1872
1873// required string localMetaPath = 3;
1874inline bool GetBlockLocalPathInfoResponseProto::has_localmetapath() const {
1875 return (_has_bits_[0] & 0x00000002u) != 0;
1876}
1877inline void GetBlockLocalPathInfoResponseProto::set_has_localmetapath() {
1878 _has_bits_[0] |= 0x00000002u;
1879}
1880inline void GetBlockLocalPathInfoResponseProto::clear_has_localmetapath() {
1881 _has_bits_[0] &= ~0x00000002u;
1882}
1883inline void GetBlockLocalPathInfoResponseProto::clear_localmetapath() {
1884 localmetapath_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1885 clear_has_localmetapath();
1886}
1887inline const ::std::string& GetBlockLocalPathInfoResponseProto::localmetapath() const {
1888 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localMetaPath)
1889 return localmetapath_.GetNoArena();
1890}
1891inline void GetBlockLocalPathInfoResponseProto::set_localmetapath(const ::std::string& value) {
1892 set_has_localmetapath();
1893 localmetapath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1894 // @@protoc_insertion_point(field_set:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localMetaPath)
1895}
1896#if LANG_CXX11
1897inline void GetBlockLocalPathInfoResponseProto::set_localmetapath(::std::string&& value) {
1898 set_has_localmetapath();
1899 localmetapath_.SetNoArena(
1900 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1901 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localMetaPath)
1902}
1903#endif
1904inline void GetBlockLocalPathInfoResponseProto::set_localmetapath(const char* value) {
1905 GOOGLE_DCHECK(value != NULL);
1906 set_has_localmetapath();
1907 localmetapath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1908 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localMetaPath)
1909}
1910inline void GetBlockLocalPathInfoResponseProto::set_localmetapath(const char* value, size_t size) {
1911 set_has_localmetapath();
1912 localmetapath_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1913 ::std::string(reinterpret_cast<const char*>(value), size));
1914 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localMetaPath)
1915}
1916inline ::std::string* GetBlockLocalPathInfoResponseProto::mutable_localmetapath() {
1917 set_has_localmetapath();
1918 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localMetaPath)
1919 return localmetapath_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1920}
1921inline ::std::string* GetBlockLocalPathInfoResponseProto::release_localmetapath() {
1922 // @@protoc_insertion_point(field_release:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localMetaPath)
1923 if (!has_localmetapath()) {
1924 return NULL;
1925 }
1926 clear_has_localmetapath();
1927 return localmetapath_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1928}
1929inline void GetBlockLocalPathInfoResponseProto::set_allocated_localmetapath(::std::string* localmetapath) {
1930 if (localmetapath != NULL) {
1931 set_has_localmetapath();
1932 } else {
1933 clear_has_localmetapath();
1934 }
1935 localmetapath_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), localmetapath);
1936 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.GetBlockLocalPathInfoResponseProto.localMetaPath)
1937}
1938
1939// -------------------------------------------------------------------
1940
1941// GetHdfsBlockLocationsRequestProto
1942
1943// repeated .Hdfs.Internal.ExtendedBlockProto blocks = 1;
1944inline int GetHdfsBlockLocationsRequestProto::blocks_size() const {
1945 return blocks_.size();
1946}
1947inline ::Hdfs::Internal::ExtendedBlockProto* GetHdfsBlockLocationsRequestProto::mutable_blocks(int index) {
1948 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.blocks)
1949 return blocks_.Mutable(index);
1950}
1951inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::ExtendedBlockProto >*
1952GetHdfsBlockLocationsRequestProto::mutable_blocks() {
1953 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.blocks)
1954 return &blocks_;
1955}
1956inline const ::Hdfs::Internal::ExtendedBlockProto& GetHdfsBlockLocationsRequestProto::blocks(int index) const {
1957 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.blocks)
1958 return blocks_.Get(index);
1959}
1960inline ::Hdfs::Internal::ExtendedBlockProto* GetHdfsBlockLocationsRequestProto::add_blocks() {
1961 // @@protoc_insertion_point(field_add:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.blocks)
1962 return blocks_.Add();
1963}
1964inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::ExtendedBlockProto >&
1965GetHdfsBlockLocationsRequestProto::blocks() const {
1966 // @@protoc_insertion_point(field_list:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.blocks)
1967 return blocks_;
1968}
1969
1970// repeated .Hdfs.Internal.TokenProto tokens = 2;
1971inline int GetHdfsBlockLocationsRequestProto::tokens_size() const {
1972 return tokens_.size();
1973}
1974inline ::Hdfs::Internal::TokenProto* GetHdfsBlockLocationsRequestProto::mutable_tokens(int index) {
1975 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.tokens)
1976 return tokens_.Mutable(index);
1977}
1978inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::TokenProto >*
1979GetHdfsBlockLocationsRequestProto::mutable_tokens() {
1980 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.tokens)
1981 return &tokens_;
1982}
1983inline const ::Hdfs::Internal::TokenProto& GetHdfsBlockLocationsRequestProto::tokens(int index) const {
1984 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.tokens)
1985 return tokens_.Get(index);
1986}
1987inline ::Hdfs::Internal::TokenProto* GetHdfsBlockLocationsRequestProto::add_tokens() {
1988 // @@protoc_insertion_point(field_add:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.tokens)
1989 return tokens_.Add();
1990}
1991inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::TokenProto >&
1992GetHdfsBlockLocationsRequestProto::tokens() const {
1993 // @@protoc_insertion_point(field_list:Hdfs.Internal.GetHdfsBlockLocationsRequestProto.tokens)
1994 return tokens_;
1995}
1996
1997// -------------------------------------------------------------------
1998
1999// GetHdfsBlockLocationsResponseProto
2000
2001// repeated bytes volumeIds = 1;
2002inline int GetHdfsBlockLocationsResponseProto::volumeids_size() const {
2003 return volumeids_.size();
2004}
2005inline void GetHdfsBlockLocationsResponseProto::clear_volumeids() {
2006 volumeids_.Clear();
2007}
2008inline const ::std::string& GetHdfsBlockLocationsResponseProto::volumeids(int index) const {
2009 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2010 return volumeids_.Get(index);
2011}
2012inline ::std::string* GetHdfsBlockLocationsResponseProto::mutable_volumeids(int index) {
2013 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2014 return volumeids_.Mutable(index);
2015}
2016inline void GetHdfsBlockLocationsResponseProto::set_volumeids(int index, const ::std::string& value) {
2017 // @@protoc_insertion_point(field_set:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2018 volumeids_.Mutable(index)->assign(value);
2019}
2020#if LANG_CXX11
2021inline void GetHdfsBlockLocationsResponseProto::set_volumeids(int index, ::std::string&& value) {
2022 // @@protoc_insertion_point(field_set:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2023 volumeids_.Mutable(index)->assign(std::move(value));
2024}
2025#endif
2026inline void GetHdfsBlockLocationsResponseProto::set_volumeids(int index, const char* value) {
2027 GOOGLE_DCHECK(value != NULL);
2028 volumeids_.Mutable(index)->assign(value);
2029 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2030}
2031inline void GetHdfsBlockLocationsResponseProto::set_volumeids(int index, const void* value, size_t size) {
2032 volumeids_.Mutable(index)->assign(
2033 reinterpret_cast<const char*>(value), size);
2034 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2035}
2036inline ::std::string* GetHdfsBlockLocationsResponseProto::add_volumeids() {
2037 // @@protoc_insertion_point(field_add_mutable:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2038 return volumeids_.Add();
2039}
2040inline void GetHdfsBlockLocationsResponseProto::add_volumeids(const ::std::string& value) {
2041 volumeids_.Add()->assign(value);
2042 // @@protoc_insertion_point(field_add:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2043}
2044#if LANG_CXX11
2045inline void GetHdfsBlockLocationsResponseProto::add_volumeids(::std::string&& value) {
2046 volumeids_.Add(std::move(value));
2047 // @@protoc_insertion_point(field_add:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2048}
2049#endif
2050inline void GetHdfsBlockLocationsResponseProto::add_volumeids(const char* value) {
2051 GOOGLE_DCHECK(value != NULL);
2052 volumeids_.Add()->assign(value);
2053 // @@protoc_insertion_point(field_add_char:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2054}
2055inline void GetHdfsBlockLocationsResponseProto::add_volumeids(const void* value, size_t size) {
2056 volumeids_.Add()->assign(reinterpret_cast<const char*>(value), size);
2057 // @@protoc_insertion_point(field_add_pointer:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2058}
2059inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
2060GetHdfsBlockLocationsResponseProto::volumeids() const {
2061 // @@protoc_insertion_point(field_list:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2062 return volumeids_;
2063}
2064inline ::google::protobuf::RepeatedPtrField< ::std::string>*
2065GetHdfsBlockLocationsResponseProto::mutable_volumeids() {
2066 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIds)
2067 return &volumeids_;
2068}
2069
2070// repeated uint32 volumeIndexes = 2;
2071inline int GetHdfsBlockLocationsResponseProto::volumeindexes_size() const {
2072 return volumeindexes_.size();
2073}
2074inline void GetHdfsBlockLocationsResponseProto::clear_volumeindexes() {
2075 volumeindexes_.Clear();
2076}
2077inline ::google::protobuf::uint32 GetHdfsBlockLocationsResponseProto::volumeindexes(int index) const {
2078 // @@protoc_insertion_point(field_get:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIndexes)
2079 return volumeindexes_.Get(index);
2080}
2081inline void GetHdfsBlockLocationsResponseProto::set_volumeindexes(int index, ::google::protobuf::uint32 value) {
2082 volumeindexes_.Set(index, value);
2083 // @@protoc_insertion_point(field_set:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIndexes)
2084}
2085inline void GetHdfsBlockLocationsResponseProto::add_volumeindexes(::google::protobuf::uint32 value) {
2086 volumeindexes_.Add(value);
2087 // @@protoc_insertion_point(field_add:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIndexes)
2088}
2089inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
2090GetHdfsBlockLocationsResponseProto::volumeindexes() const {
2091 // @@protoc_insertion_point(field_list:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIndexes)
2092 return volumeindexes_;
2093}
2094inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
2095GetHdfsBlockLocationsResponseProto::mutable_volumeindexes() {
2096 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.GetHdfsBlockLocationsResponseProto.volumeIndexes)
2097 return &volumeindexes_;
2098}
2099
2100#ifdef __GNUC__
2101 #pragma GCC diagnostic pop
2102#endif // __GNUC__
2103// -------------------------------------------------------------------
2104
2105// -------------------------------------------------------------------
2106
2107// -------------------------------------------------------------------
2108
2109// -------------------------------------------------------------------
2110
2111// -------------------------------------------------------------------
2112
2113// -------------------------------------------------------------------
2114
2115// -------------------------------------------------------------------
2116
2117// -------------------------------------------------------------------
2118
2119// -------------------------------------------------------------------
2120
2121
2122// @@protoc_insertion_point(namespace_scope)
2123
2124} // namespace Internal
2125} // namespace Hdfs
2126
2127// @@protoc_insertion_point(global_scope)
2128
2129#endif // PROTOBUF_INCLUDED_ClientDatanodeProtocol_2eproto
2130