1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: datatransfer.proto
3
4#ifndef PROTOBUF_INCLUDED_datatransfer_2eproto
5#define PROTOBUF_INCLUDED_datatransfer_2eproto
6
7#include <string>
8
9#include <google/protobuf/stubs/common.h>
10
11#if GOOGLE_PROTOBUF_VERSION < 3006001
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/io/coded_stream.h>
23#include <google/protobuf/arena.h>
24#include <google/protobuf/arenastring.h>
25#include <google/protobuf/generated_message_table_driven.h>
26#include <google/protobuf/generated_message_util.h>
27#include <google/protobuf/inlined_string_field.h>
28#include <google/protobuf/metadata.h>
29#include <google/protobuf/message.h>
30#include <google/protobuf/repeated_field.h> // IWYU pragma: export
31#include <google/protobuf/extension_set.h> // IWYU pragma: export
32#include <google/protobuf/generated_enum_reflection.h>
33#include <google/protobuf/unknown_field_set.h>
34#include "Security.pb.h"
35#include "hdfs.pb.h"
36// @@protoc_insertion_point(includes)
37#define PROTOBUF_INTERNAL_EXPORT_protobuf_datatransfer_2eproto
38
39namespace protobuf_datatransfer_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[19];
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_datatransfer_2eproto
51namespace Hdfs {
52namespace Internal {
53class BaseHeaderProto;
54class BaseHeaderProtoDefaultTypeInternal;
55extern BaseHeaderProtoDefaultTypeInternal _BaseHeaderProto_default_instance_;
56class BlockOpResponseProto;
57class BlockOpResponseProtoDefaultTypeInternal;
58extern BlockOpResponseProtoDefaultTypeInternal _BlockOpResponseProto_default_instance_;
59class CachingStrategyProto;
60class CachingStrategyProtoDefaultTypeInternal;
61extern CachingStrategyProtoDefaultTypeInternal _CachingStrategyProto_default_instance_;
62class ChecksumProto;
63class ChecksumProtoDefaultTypeInternal;
64extern ChecksumProtoDefaultTypeInternal _ChecksumProto_default_instance_;
65class ClientOperationHeaderProto;
66class ClientOperationHeaderProtoDefaultTypeInternal;
67extern ClientOperationHeaderProtoDefaultTypeInternal _ClientOperationHeaderProto_default_instance_;
68class ClientReadStatusProto;
69class ClientReadStatusProtoDefaultTypeInternal;
70extern ClientReadStatusProtoDefaultTypeInternal _ClientReadStatusProto_default_instance_;
71class DNTransferAckProto;
72class DNTransferAckProtoDefaultTypeInternal;
73extern DNTransferAckProtoDefaultTypeInternal _DNTransferAckProto_default_instance_;
74class DataTransferEncryptorMessageProto;
75class DataTransferEncryptorMessageProtoDefaultTypeInternal;
76extern DataTransferEncryptorMessageProtoDefaultTypeInternal _DataTransferEncryptorMessageProto_default_instance_;
77class OpBlockChecksumProto;
78class OpBlockChecksumProtoDefaultTypeInternal;
79extern OpBlockChecksumProtoDefaultTypeInternal _OpBlockChecksumProto_default_instance_;
80class OpBlockChecksumResponseProto;
81class OpBlockChecksumResponseProtoDefaultTypeInternal;
82extern OpBlockChecksumResponseProtoDefaultTypeInternal _OpBlockChecksumResponseProto_default_instance_;
83class OpCopyBlockProto;
84class OpCopyBlockProtoDefaultTypeInternal;
85extern OpCopyBlockProtoDefaultTypeInternal _OpCopyBlockProto_default_instance_;
86class OpReadBlockProto;
87class OpReadBlockProtoDefaultTypeInternal;
88extern OpReadBlockProtoDefaultTypeInternal _OpReadBlockProto_default_instance_;
89class OpReplaceBlockProto;
90class OpReplaceBlockProtoDefaultTypeInternal;
91extern OpReplaceBlockProtoDefaultTypeInternal _OpReplaceBlockProto_default_instance_;
92class OpRequestShortCircuitAccessProto;
93class OpRequestShortCircuitAccessProtoDefaultTypeInternal;
94extern OpRequestShortCircuitAccessProtoDefaultTypeInternal _OpRequestShortCircuitAccessProto_default_instance_;
95class OpTransferBlockProto;
96class OpTransferBlockProtoDefaultTypeInternal;
97extern OpTransferBlockProtoDefaultTypeInternal _OpTransferBlockProto_default_instance_;
98class OpWriteBlockProto;
99class OpWriteBlockProtoDefaultTypeInternal;
100extern OpWriteBlockProtoDefaultTypeInternal _OpWriteBlockProto_default_instance_;
101class PacketHeaderProto;
102class PacketHeaderProtoDefaultTypeInternal;
103extern PacketHeaderProtoDefaultTypeInternal _PacketHeaderProto_default_instance_;
104class PipelineAckProto;
105class PipelineAckProtoDefaultTypeInternal;
106extern PipelineAckProtoDefaultTypeInternal _PipelineAckProto_default_instance_;
107class ReadOpChecksumInfoProto;
108class ReadOpChecksumInfoProtoDefaultTypeInternal;
109extern ReadOpChecksumInfoProtoDefaultTypeInternal _ReadOpChecksumInfoProto_default_instance_;
110} // namespace Internal
111} // namespace Hdfs
112namespace google {
113namespace protobuf {
114template<> ::Hdfs::Internal::BaseHeaderProto* Arena::CreateMaybeMessage<::Hdfs::Internal::BaseHeaderProto>(Arena*);
115template<> ::Hdfs::Internal::BlockOpResponseProto* Arena::CreateMaybeMessage<::Hdfs::Internal::BlockOpResponseProto>(Arena*);
116template<> ::Hdfs::Internal::CachingStrategyProto* Arena::CreateMaybeMessage<::Hdfs::Internal::CachingStrategyProto>(Arena*);
117template<> ::Hdfs::Internal::ChecksumProto* Arena::CreateMaybeMessage<::Hdfs::Internal::ChecksumProto>(Arena*);
118template<> ::Hdfs::Internal::ClientOperationHeaderProto* Arena::CreateMaybeMessage<::Hdfs::Internal::ClientOperationHeaderProto>(Arena*);
119template<> ::Hdfs::Internal::ClientReadStatusProto* Arena::CreateMaybeMessage<::Hdfs::Internal::ClientReadStatusProto>(Arena*);
120template<> ::Hdfs::Internal::DNTransferAckProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DNTransferAckProto>(Arena*);
121template<> ::Hdfs::Internal::DataTransferEncryptorMessageProto* Arena::CreateMaybeMessage<::Hdfs::Internal::DataTransferEncryptorMessageProto>(Arena*);
122template<> ::Hdfs::Internal::OpBlockChecksumProto* Arena::CreateMaybeMessage<::Hdfs::Internal::OpBlockChecksumProto>(Arena*);
123template<> ::Hdfs::Internal::OpBlockChecksumResponseProto* Arena::CreateMaybeMessage<::Hdfs::Internal::OpBlockChecksumResponseProto>(Arena*);
124template<> ::Hdfs::Internal::OpCopyBlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::OpCopyBlockProto>(Arena*);
125template<> ::Hdfs::Internal::OpReadBlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::OpReadBlockProto>(Arena*);
126template<> ::Hdfs::Internal::OpReplaceBlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::OpReplaceBlockProto>(Arena*);
127template<> ::Hdfs::Internal::OpRequestShortCircuitAccessProto* Arena::CreateMaybeMessage<::Hdfs::Internal::OpRequestShortCircuitAccessProto>(Arena*);
128template<> ::Hdfs::Internal::OpTransferBlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::OpTransferBlockProto>(Arena*);
129template<> ::Hdfs::Internal::OpWriteBlockProto* Arena::CreateMaybeMessage<::Hdfs::Internal::OpWriteBlockProto>(Arena*);
130template<> ::Hdfs::Internal::PacketHeaderProto* Arena::CreateMaybeMessage<::Hdfs::Internal::PacketHeaderProto>(Arena*);
131template<> ::Hdfs::Internal::PipelineAckProto* Arena::CreateMaybeMessage<::Hdfs::Internal::PipelineAckProto>(Arena*);
132template<> ::Hdfs::Internal::ReadOpChecksumInfoProto* Arena::CreateMaybeMessage<::Hdfs::Internal::ReadOpChecksumInfoProto>(Arena*);
133} // namespace protobuf
134} // namespace google
135namespace Hdfs {
136namespace Internal {
137
138enum DataTransferEncryptorMessageProto_DataTransferEncryptorStatus {
139 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_SUCCESS = 0,
140 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_ERROR_UNKNOWN_KEY = 1,
141 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_ERROR = 2
142};
143bool DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_IsValid(int value);
144const DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_DataTransferEncryptorStatus_MIN = DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_SUCCESS;
145const DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_DataTransferEncryptorStatus_MAX = DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_ERROR;
146const int DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_DataTransferEncryptorStatus_ARRAYSIZE = DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_DataTransferEncryptorStatus_MAX + 1;
147
148const ::google::protobuf::EnumDescriptor* DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_descriptor();
149inline const ::std::string& DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_Name(DataTransferEncryptorMessageProto_DataTransferEncryptorStatus value) {
150 return ::google::protobuf::internal::NameOfEnum(
151 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_descriptor(), value);
152}
153inline bool DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_Parse(
154 const ::std::string& name, DataTransferEncryptorMessageProto_DataTransferEncryptorStatus* value) {
155 return ::google::protobuf::internal::ParseNamedEnum<DataTransferEncryptorMessageProto_DataTransferEncryptorStatus>(
156 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_descriptor(), name, value);
157}
158enum OpWriteBlockProto_BlockConstructionStage {
159 OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_APPEND = 0,
160 OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_APPEND_RECOVERY = 1,
161 OpWriteBlockProto_BlockConstructionStage_DATA_STREAMING = 2,
162 OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_STREAMING_RECOVERY = 3,
163 OpWriteBlockProto_BlockConstructionStage_PIPELINE_CLOSE = 4,
164 OpWriteBlockProto_BlockConstructionStage_PIPELINE_CLOSE_RECOVERY = 5,
165 OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_CREATE = 6,
166 OpWriteBlockProto_BlockConstructionStage_TRANSFER_RBW = 7,
167 OpWriteBlockProto_BlockConstructionStage_TRANSFER_FINALIZED = 8
168};
169bool OpWriteBlockProto_BlockConstructionStage_IsValid(int value);
170const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto_BlockConstructionStage_BlockConstructionStage_MIN = OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_APPEND;
171const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto_BlockConstructionStage_BlockConstructionStage_MAX = OpWriteBlockProto_BlockConstructionStage_TRANSFER_FINALIZED;
172const int OpWriteBlockProto_BlockConstructionStage_BlockConstructionStage_ARRAYSIZE = OpWriteBlockProto_BlockConstructionStage_BlockConstructionStage_MAX + 1;
173
174const ::google::protobuf::EnumDescriptor* OpWriteBlockProto_BlockConstructionStage_descriptor();
175inline const ::std::string& OpWriteBlockProto_BlockConstructionStage_Name(OpWriteBlockProto_BlockConstructionStage value) {
176 return ::google::protobuf::internal::NameOfEnum(
177 OpWriteBlockProto_BlockConstructionStage_descriptor(), value);
178}
179inline bool OpWriteBlockProto_BlockConstructionStage_Parse(
180 const ::std::string& name, OpWriteBlockProto_BlockConstructionStage* value) {
181 return ::google::protobuf::internal::ParseNamedEnum<OpWriteBlockProto_BlockConstructionStage>(
182 OpWriteBlockProto_BlockConstructionStage_descriptor(), name, value);
183}
184enum Status {
185 DT_PROTO_SUCCESS = 0,
186 DT_PROTO_ERROR = 1,
187 DT_PROTO_ERROR_CHECKSUM = 2,
188 DT_PROTO_ERROR_INVALID = 3,
189 DT_PROTO_ERROR_EXISTS = 4,
190 DT_PROTO_ERROR_ACCESS_TOKEN = 5,
191 DT_PROTO_CHECKSUM_OK = 6,
192 DT_PROTO_ERROR_UNSUPPORTED = 7,
193 DT_PROTO_OOB_RESTART = 8,
194 DT_PROTO_OOB_RESERVED1 = 9,
195 DT_PROTO_OOB_RESERVED2 = 10,
196 DT_PROTO_OOB_RESERVED3 = 11,
197 DT_PROTO_IN_PROGRESS = 12
198};
199bool Status_IsValid(int value);
200const Status Status_MIN = DT_PROTO_SUCCESS;
201const Status Status_MAX = DT_PROTO_IN_PROGRESS;
202const int Status_ARRAYSIZE = Status_MAX + 1;
203
204const ::google::protobuf::EnumDescriptor* Status_descriptor();
205inline const ::std::string& Status_Name(Status value) {
206 return ::google::protobuf::internal::NameOfEnum(
207 Status_descriptor(), value);
208}
209inline bool Status_Parse(
210 const ::std::string& name, Status* value) {
211 return ::google::protobuf::internal::ParseNamedEnum<Status>(
212 Status_descriptor(), name, value);
213}
214// ===================================================================
215
216class DataTransferEncryptorMessageProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DataTransferEncryptorMessageProto) */ {
217 public:
218 DataTransferEncryptorMessageProto();
219 virtual ~DataTransferEncryptorMessageProto();
220
221 DataTransferEncryptorMessageProto(const DataTransferEncryptorMessageProto& from);
222
223 inline DataTransferEncryptorMessageProto& operator=(const DataTransferEncryptorMessageProto& from) {
224 CopyFrom(from);
225 return *this;
226 }
227 #if LANG_CXX11
228 DataTransferEncryptorMessageProto(DataTransferEncryptorMessageProto&& from) noexcept
229 : DataTransferEncryptorMessageProto() {
230 *this = ::std::move(from);
231 }
232
233 inline DataTransferEncryptorMessageProto& operator=(DataTransferEncryptorMessageProto&& from) noexcept {
234 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
235 if (this != &from) InternalSwap(&from);
236 } else {
237 CopyFrom(from);
238 }
239 return *this;
240 }
241 #endif
242 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
243 return _internal_metadata_.unknown_fields();
244 }
245 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
246 return _internal_metadata_.mutable_unknown_fields();
247 }
248
249 static const ::google::protobuf::Descriptor* descriptor();
250 static const DataTransferEncryptorMessageProto& default_instance();
251
252 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
253 static inline const DataTransferEncryptorMessageProto* internal_default_instance() {
254 return reinterpret_cast<const DataTransferEncryptorMessageProto*>(
255 &_DataTransferEncryptorMessageProto_default_instance_);
256 }
257 static constexpr int kIndexInFileMessages =
258 0;
259
260 void Swap(DataTransferEncryptorMessageProto* other);
261 friend void swap(DataTransferEncryptorMessageProto& a, DataTransferEncryptorMessageProto& b) {
262 a.Swap(&b);
263 }
264
265 // implements Message ----------------------------------------------
266
267 inline DataTransferEncryptorMessageProto* New() const final {
268 return CreateMaybeMessage<DataTransferEncryptorMessageProto>(NULL);
269 }
270
271 DataTransferEncryptorMessageProto* New(::google::protobuf::Arena* arena) const final {
272 return CreateMaybeMessage<DataTransferEncryptorMessageProto>(arena);
273 }
274 void CopyFrom(const ::google::protobuf::Message& from) final;
275 void MergeFrom(const ::google::protobuf::Message& from) final;
276 void CopyFrom(const DataTransferEncryptorMessageProto& from);
277 void MergeFrom(const DataTransferEncryptorMessageProto& from);
278 void Clear() final;
279 bool IsInitialized() const final;
280
281 size_t ByteSizeLong() const final;
282 bool MergePartialFromCodedStream(
283 ::google::protobuf::io::CodedInputStream* input) final;
284 void SerializeWithCachedSizes(
285 ::google::protobuf::io::CodedOutputStream* output) const final;
286 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
287 bool deterministic, ::google::protobuf::uint8* target) const final;
288 int GetCachedSize() const final { return _cached_size_.Get(); }
289
290 private:
291 void SharedCtor();
292 void SharedDtor();
293 void SetCachedSize(int size) const final;
294 void InternalSwap(DataTransferEncryptorMessageProto* other);
295 private:
296 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
297 return NULL;
298 }
299 inline void* MaybeArenaPtr() const {
300 return NULL;
301 }
302 public:
303
304 ::google::protobuf::Metadata GetMetadata() const final;
305
306 // nested types ----------------------------------------------------
307
308 typedef DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorStatus;
309 static const DataTransferEncryptorStatus SUCCESS =
310 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_SUCCESS;
311 static const DataTransferEncryptorStatus ERROR_UNKNOWN_KEY =
312 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_ERROR_UNKNOWN_KEY;
313 static const DataTransferEncryptorStatus ERROR =
314 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_ERROR;
315 static inline bool DataTransferEncryptorStatus_IsValid(int value) {
316 return DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_IsValid(value);
317 }
318 static const DataTransferEncryptorStatus DataTransferEncryptorStatus_MIN =
319 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_DataTransferEncryptorStatus_MIN;
320 static const DataTransferEncryptorStatus DataTransferEncryptorStatus_MAX =
321 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_DataTransferEncryptorStatus_MAX;
322 static const int DataTransferEncryptorStatus_ARRAYSIZE =
323 DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_DataTransferEncryptorStatus_ARRAYSIZE;
324 static inline const ::google::protobuf::EnumDescriptor*
325 DataTransferEncryptorStatus_descriptor() {
326 return DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_descriptor();
327 }
328 static inline const ::std::string& DataTransferEncryptorStatus_Name(DataTransferEncryptorStatus value) {
329 return DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_Name(value);
330 }
331 static inline bool DataTransferEncryptorStatus_Parse(const ::std::string& name,
332 DataTransferEncryptorStatus* value) {
333 return DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_Parse(name, value);
334 }
335
336 // accessors -------------------------------------------------------
337
338 // optional bytes payload = 2;
339 bool has_payload() const;
340 void clear_payload();
341 static const int kPayloadFieldNumber = 2;
342 const ::std::string& payload() const;
343 void set_payload(const ::std::string& value);
344 #if LANG_CXX11
345 void set_payload(::std::string&& value);
346 #endif
347 void set_payload(const char* value);
348 void set_payload(const void* value, size_t size);
349 ::std::string* mutable_payload();
350 ::std::string* release_payload();
351 void set_allocated_payload(::std::string* payload);
352
353 // optional string message = 3;
354 bool has_message() const;
355 void clear_message();
356 static const int kMessageFieldNumber = 3;
357 const ::std::string& message() const;
358 void set_message(const ::std::string& value);
359 #if LANG_CXX11
360 void set_message(::std::string&& value);
361 #endif
362 void set_message(const char* value);
363 void set_message(const char* value, size_t size);
364 ::std::string* mutable_message();
365 ::std::string* release_message();
366 void set_allocated_message(::std::string* message);
367
368 // required .Hdfs.Internal.DataTransferEncryptorMessageProto.DataTransferEncryptorStatus status = 1;
369 bool has_status() const;
370 void clear_status();
371 static const int kStatusFieldNumber = 1;
372 ::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus status() const;
373 void set_status(::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus value);
374
375 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DataTransferEncryptorMessageProto)
376 private:
377 void set_has_status();
378 void clear_has_status();
379 void set_has_payload();
380 void clear_has_payload();
381 void set_has_message();
382 void clear_has_message();
383
384 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
385 ::google::protobuf::internal::HasBits<1> _has_bits_;
386 mutable ::google::protobuf::internal::CachedSize _cached_size_;
387 ::google::protobuf::internal::ArenaStringPtr payload_;
388 ::google::protobuf::internal::ArenaStringPtr message_;
389 int status_;
390 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
391};
392// -------------------------------------------------------------------
393
394class BaseHeaderProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.BaseHeaderProto) */ {
395 public:
396 BaseHeaderProto();
397 virtual ~BaseHeaderProto();
398
399 BaseHeaderProto(const BaseHeaderProto& from);
400
401 inline BaseHeaderProto& operator=(const BaseHeaderProto& from) {
402 CopyFrom(from);
403 return *this;
404 }
405 #if LANG_CXX11
406 BaseHeaderProto(BaseHeaderProto&& from) noexcept
407 : BaseHeaderProto() {
408 *this = ::std::move(from);
409 }
410
411 inline BaseHeaderProto& operator=(BaseHeaderProto&& from) noexcept {
412 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
413 if (this != &from) InternalSwap(&from);
414 } else {
415 CopyFrom(from);
416 }
417 return *this;
418 }
419 #endif
420 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
421 return _internal_metadata_.unknown_fields();
422 }
423 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
424 return _internal_metadata_.mutable_unknown_fields();
425 }
426
427 static const ::google::protobuf::Descriptor* descriptor();
428 static const BaseHeaderProto& default_instance();
429
430 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
431 static inline const BaseHeaderProto* internal_default_instance() {
432 return reinterpret_cast<const BaseHeaderProto*>(
433 &_BaseHeaderProto_default_instance_);
434 }
435 static constexpr int kIndexInFileMessages =
436 1;
437
438 void Swap(BaseHeaderProto* other);
439 friend void swap(BaseHeaderProto& a, BaseHeaderProto& b) {
440 a.Swap(&b);
441 }
442
443 // implements Message ----------------------------------------------
444
445 inline BaseHeaderProto* New() const final {
446 return CreateMaybeMessage<BaseHeaderProto>(NULL);
447 }
448
449 BaseHeaderProto* New(::google::protobuf::Arena* arena) const final {
450 return CreateMaybeMessage<BaseHeaderProto>(arena);
451 }
452 void CopyFrom(const ::google::protobuf::Message& from) final;
453 void MergeFrom(const ::google::protobuf::Message& from) final;
454 void CopyFrom(const BaseHeaderProto& from);
455 void MergeFrom(const BaseHeaderProto& from);
456 void Clear() final;
457 bool IsInitialized() const final;
458
459 size_t ByteSizeLong() const final;
460 bool MergePartialFromCodedStream(
461 ::google::protobuf::io::CodedInputStream* input) final;
462 void SerializeWithCachedSizes(
463 ::google::protobuf::io::CodedOutputStream* output) const final;
464 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
465 bool deterministic, ::google::protobuf::uint8* target) const final;
466 int GetCachedSize() const final { return _cached_size_.Get(); }
467
468 private:
469 void SharedCtor();
470 void SharedDtor();
471 void SetCachedSize(int size) const final;
472 void InternalSwap(BaseHeaderProto* other);
473 private:
474 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
475 return NULL;
476 }
477 inline void* MaybeArenaPtr() const {
478 return NULL;
479 }
480 public:
481
482 ::google::protobuf::Metadata GetMetadata() const final;
483
484 // nested types ----------------------------------------------------
485
486 // accessors -------------------------------------------------------
487
488 // required .Hdfs.Internal.ExtendedBlockProto block = 1;
489 bool has_block() const;
490 void clear_block();
491 static const int kBlockFieldNumber = 1;
492 private:
493 const ::Hdfs::Internal::ExtendedBlockProto& _internal_block() const;
494 public:
495 const ::Hdfs::Internal::ExtendedBlockProto& block() const;
496 ::Hdfs::Internal::ExtendedBlockProto* release_block();
497 ::Hdfs::Internal::ExtendedBlockProto* mutable_block();
498 void set_allocated_block(::Hdfs::Internal::ExtendedBlockProto* block);
499
500 // optional .Hdfs.Internal.TokenProto token = 2;
501 bool has_token() const;
502 void clear_token();
503 static const int kTokenFieldNumber = 2;
504 private:
505 const ::Hdfs::Internal::TokenProto& _internal_token() const;
506 public:
507 const ::Hdfs::Internal::TokenProto& token() const;
508 ::Hdfs::Internal::TokenProto* release_token();
509 ::Hdfs::Internal::TokenProto* mutable_token();
510 void set_allocated_token(::Hdfs::Internal::TokenProto* token);
511
512 // @@protoc_insertion_point(class_scope:Hdfs.Internal.BaseHeaderProto)
513 private:
514 void set_has_block();
515 void clear_has_block();
516 void set_has_token();
517 void clear_has_token();
518
519 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
520 ::google::protobuf::internal::HasBits<1> _has_bits_;
521 mutable ::google::protobuf::internal::CachedSize _cached_size_;
522 ::Hdfs::Internal::ExtendedBlockProto* block_;
523 ::Hdfs::Internal::TokenProto* token_;
524 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
525};
526// -------------------------------------------------------------------
527
528class ClientOperationHeaderProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.ClientOperationHeaderProto) */ {
529 public:
530 ClientOperationHeaderProto();
531 virtual ~ClientOperationHeaderProto();
532
533 ClientOperationHeaderProto(const ClientOperationHeaderProto& from);
534
535 inline ClientOperationHeaderProto& operator=(const ClientOperationHeaderProto& from) {
536 CopyFrom(from);
537 return *this;
538 }
539 #if LANG_CXX11
540 ClientOperationHeaderProto(ClientOperationHeaderProto&& from) noexcept
541 : ClientOperationHeaderProto() {
542 *this = ::std::move(from);
543 }
544
545 inline ClientOperationHeaderProto& operator=(ClientOperationHeaderProto&& from) noexcept {
546 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
547 if (this != &from) InternalSwap(&from);
548 } else {
549 CopyFrom(from);
550 }
551 return *this;
552 }
553 #endif
554 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
555 return _internal_metadata_.unknown_fields();
556 }
557 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
558 return _internal_metadata_.mutable_unknown_fields();
559 }
560
561 static const ::google::protobuf::Descriptor* descriptor();
562 static const ClientOperationHeaderProto& default_instance();
563
564 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
565 static inline const ClientOperationHeaderProto* internal_default_instance() {
566 return reinterpret_cast<const ClientOperationHeaderProto*>(
567 &_ClientOperationHeaderProto_default_instance_);
568 }
569 static constexpr int kIndexInFileMessages =
570 2;
571
572 void Swap(ClientOperationHeaderProto* other);
573 friend void swap(ClientOperationHeaderProto& a, ClientOperationHeaderProto& b) {
574 a.Swap(&b);
575 }
576
577 // implements Message ----------------------------------------------
578
579 inline ClientOperationHeaderProto* New() const final {
580 return CreateMaybeMessage<ClientOperationHeaderProto>(NULL);
581 }
582
583 ClientOperationHeaderProto* New(::google::protobuf::Arena* arena) const final {
584 return CreateMaybeMessage<ClientOperationHeaderProto>(arena);
585 }
586 void CopyFrom(const ::google::protobuf::Message& from) final;
587 void MergeFrom(const ::google::protobuf::Message& from) final;
588 void CopyFrom(const ClientOperationHeaderProto& from);
589 void MergeFrom(const ClientOperationHeaderProto& from);
590 void Clear() final;
591 bool IsInitialized() const final;
592
593 size_t ByteSizeLong() const final;
594 bool MergePartialFromCodedStream(
595 ::google::protobuf::io::CodedInputStream* input) final;
596 void SerializeWithCachedSizes(
597 ::google::protobuf::io::CodedOutputStream* output) const final;
598 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
599 bool deterministic, ::google::protobuf::uint8* target) const final;
600 int GetCachedSize() const final { return _cached_size_.Get(); }
601
602 private:
603 void SharedCtor();
604 void SharedDtor();
605 void SetCachedSize(int size) const final;
606 void InternalSwap(ClientOperationHeaderProto* other);
607 private:
608 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
609 return NULL;
610 }
611 inline void* MaybeArenaPtr() const {
612 return NULL;
613 }
614 public:
615
616 ::google::protobuf::Metadata GetMetadata() const final;
617
618 // nested types ----------------------------------------------------
619
620 // accessors -------------------------------------------------------
621
622 // required string clientName = 2;
623 bool has_clientname() const;
624 void clear_clientname();
625 static const int kClientNameFieldNumber = 2;
626 const ::std::string& clientname() const;
627 void set_clientname(const ::std::string& value);
628 #if LANG_CXX11
629 void set_clientname(::std::string&& value);
630 #endif
631 void set_clientname(const char* value);
632 void set_clientname(const char* value, size_t size);
633 ::std::string* mutable_clientname();
634 ::std::string* release_clientname();
635 void set_allocated_clientname(::std::string* clientname);
636
637 // required .Hdfs.Internal.BaseHeaderProto baseHeader = 1;
638 bool has_baseheader() const;
639 void clear_baseheader();
640 static const int kBaseHeaderFieldNumber = 1;
641 private:
642 const ::Hdfs::Internal::BaseHeaderProto& _internal_baseheader() const;
643 public:
644 const ::Hdfs::Internal::BaseHeaderProto& baseheader() const;
645 ::Hdfs::Internal::BaseHeaderProto* release_baseheader();
646 ::Hdfs::Internal::BaseHeaderProto* mutable_baseheader();
647 void set_allocated_baseheader(::Hdfs::Internal::BaseHeaderProto* baseheader);
648
649 // @@protoc_insertion_point(class_scope:Hdfs.Internal.ClientOperationHeaderProto)
650 private:
651 void set_has_baseheader();
652 void clear_has_baseheader();
653 void set_has_clientname();
654 void clear_has_clientname();
655
656 // helper for ByteSizeLong()
657 size_t RequiredFieldsByteSizeFallback() const;
658
659 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
660 ::google::protobuf::internal::HasBits<1> _has_bits_;
661 mutable ::google::protobuf::internal::CachedSize _cached_size_;
662 ::google::protobuf::internal::ArenaStringPtr clientname_;
663 ::Hdfs::Internal::BaseHeaderProto* baseheader_;
664 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
665};
666// -------------------------------------------------------------------
667
668class CachingStrategyProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.CachingStrategyProto) */ {
669 public:
670 CachingStrategyProto();
671 virtual ~CachingStrategyProto();
672
673 CachingStrategyProto(const CachingStrategyProto& from);
674
675 inline CachingStrategyProto& operator=(const CachingStrategyProto& from) {
676 CopyFrom(from);
677 return *this;
678 }
679 #if LANG_CXX11
680 CachingStrategyProto(CachingStrategyProto&& from) noexcept
681 : CachingStrategyProto() {
682 *this = ::std::move(from);
683 }
684
685 inline CachingStrategyProto& operator=(CachingStrategyProto&& from) noexcept {
686 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
687 if (this != &from) InternalSwap(&from);
688 } else {
689 CopyFrom(from);
690 }
691 return *this;
692 }
693 #endif
694 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
695 return _internal_metadata_.unknown_fields();
696 }
697 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
698 return _internal_metadata_.mutable_unknown_fields();
699 }
700
701 static const ::google::protobuf::Descriptor* descriptor();
702 static const CachingStrategyProto& default_instance();
703
704 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
705 static inline const CachingStrategyProto* internal_default_instance() {
706 return reinterpret_cast<const CachingStrategyProto*>(
707 &_CachingStrategyProto_default_instance_);
708 }
709 static constexpr int kIndexInFileMessages =
710 3;
711
712 void Swap(CachingStrategyProto* other);
713 friend void swap(CachingStrategyProto& a, CachingStrategyProto& b) {
714 a.Swap(&b);
715 }
716
717 // implements Message ----------------------------------------------
718
719 inline CachingStrategyProto* New() const final {
720 return CreateMaybeMessage<CachingStrategyProto>(NULL);
721 }
722
723 CachingStrategyProto* New(::google::protobuf::Arena* arena) const final {
724 return CreateMaybeMessage<CachingStrategyProto>(arena);
725 }
726 void CopyFrom(const ::google::protobuf::Message& from) final;
727 void MergeFrom(const ::google::protobuf::Message& from) final;
728 void CopyFrom(const CachingStrategyProto& from);
729 void MergeFrom(const CachingStrategyProto& from);
730 void Clear() final;
731 bool IsInitialized() const final;
732
733 size_t ByteSizeLong() const final;
734 bool MergePartialFromCodedStream(
735 ::google::protobuf::io::CodedInputStream* input) final;
736 void SerializeWithCachedSizes(
737 ::google::protobuf::io::CodedOutputStream* output) const final;
738 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
739 bool deterministic, ::google::protobuf::uint8* target) const final;
740 int GetCachedSize() const final { return _cached_size_.Get(); }
741
742 private:
743 void SharedCtor();
744 void SharedDtor();
745 void SetCachedSize(int size) const final;
746 void InternalSwap(CachingStrategyProto* other);
747 private:
748 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
749 return NULL;
750 }
751 inline void* MaybeArenaPtr() const {
752 return NULL;
753 }
754 public:
755
756 ::google::protobuf::Metadata GetMetadata() const final;
757
758 // nested types ----------------------------------------------------
759
760 // accessors -------------------------------------------------------
761
762 // optional int64 readahead = 2;
763 bool has_readahead() const;
764 void clear_readahead();
765 static const int kReadaheadFieldNumber = 2;
766 ::google::protobuf::int64 readahead() const;
767 void set_readahead(::google::protobuf::int64 value);
768
769 // optional bool dropBehind = 1;
770 bool has_dropbehind() const;
771 void clear_dropbehind();
772 static const int kDropBehindFieldNumber = 1;
773 bool dropbehind() const;
774 void set_dropbehind(bool value);
775
776 // @@protoc_insertion_point(class_scope:Hdfs.Internal.CachingStrategyProto)
777 private:
778 void set_has_dropbehind();
779 void clear_has_dropbehind();
780 void set_has_readahead();
781 void clear_has_readahead();
782
783 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
784 ::google::protobuf::internal::HasBits<1> _has_bits_;
785 mutable ::google::protobuf::internal::CachedSize _cached_size_;
786 ::google::protobuf::int64 readahead_;
787 bool dropbehind_;
788 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
789};
790// -------------------------------------------------------------------
791
792class OpReadBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.OpReadBlockProto) */ {
793 public:
794 OpReadBlockProto();
795 virtual ~OpReadBlockProto();
796
797 OpReadBlockProto(const OpReadBlockProto& from);
798
799 inline OpReadBlockProto& operator=(const OpReadBlockProto& from) {
800 CopyFrom(from);
801 return *this;
802 }
803 #if LANG_CXX11
804 OpReadBlockProto(OpReadBlockProto&& from) noexcept
805 : OpReadBlockProto() {
806 *this = ::std::move(from);
807 }
808
809 inline OpReadBlockProto& operator=(OpReadBlockProto&& from) noexcept {
810 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
811 if (this != &from) InternalSwap(&from);
812 } else {
813 CopyFrom(from);
814 }
815 return *this;
816 }
817 #endif
818 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
819 return _internal_metadata_.unknown_fields();
820 }
821 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
822 return _internal_metadata_.mutable_unknown_fields();
823 }
824
825 static const ::google::protobuf::Descriptor* descriptor();
826 static const OpReadBlockProto& default_instance();
827
828 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
829 static inline const OpReadBlockProto* internal_default_instance() {
830 return reinterpret_cast<const OpReadBlockProto*>(
831 &_OpReadBlockProto_default_instance_);
832 }
833 static constexpr int kIndexInFileMessages =
834 4;
835
836 void Swap(OpReadBlockProto* other);
837 friend void swap(OpReadBlockProto& a, OpReadBlockProto& b) {
838 a.Swap(&b);
839 }
840
841 // implements Message ----------------------------------------------
842
843 inline OpReadBlockProto* New() const final {
844 return CreateMaybeMessage<OpReadBlockProto>(NULL);
845 }
846
847 OpReadBlockProto* New(::google::protobuf::Arena* arena) const final {
848 return CreateMaybeMessage<OpReadBlockProto>(arena);
849 }
850 void CopyFrom(const ::google::protobuf::Message& from) final;
851 void MergeFrom(const ::google::protobuf::Message& from) final;
852 void CopyFrom(const OpReadBlockProto& from);
853 void MergeFrom(const OpReadBlockProto& from);
854 void Clear() final;
855 bool IsInitialized() const final;
856
857 size_t ByteSizeLong() const final;
858 bool MergePartialFromCodedStream(
859 ::google::protobuf::io::CodedInputStream* input) final;
860 void SerializeWithCachedSizes(
861 ::google::protobuf::io::CodedOutputStream* output) const final;
862 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
863 bool deterministic, ::google::protobuf::uint8* target) const final;
864 int GetCachedSize() const final { return _cached_size_.Get(); }
865
866 private:
867 void SharedCtor();
868 void SharedDtor();
869 void SetCachedSize(int size) const final;
870 void InternalSwap(OpReadBlockProto* other);
871 private:
872 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
873 return NULL;
874 }
875 inline void* MaybeArenaPtr() const {
876 return NULL;
877 }
878 public:
879
880 ::google::protobuf::Metadata GetMetadata() const final;
881
882 // nested types ----------------------------------------------------
883
884 // accessors -------------------------------------------------------
885
886 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
887 bool has_header() const;
888 void clear_header();
889 static const int kHeaderFieldNumber = 1;
890 private:
891 const ::Hdfs::Internal::ClientOperationHeaderProto& _internal_header() const;
892 public:
893 const ::Hdfs::Internal::ClientOperationHeaderProto& header() const;
894 ::Hdfs::Internal::ClientOperationHeaderProto* release_header();
895 ::Hdfs::Internal::ClientOperationHeaderProto* mutable_header();
896 void set_allocated_header(::Hdfs::Internal::ClientOperationHeaderProto* header);
897
898 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 5;
899 bool has_cachingstrategy() const;
900 void clear_cachingstrategy();
901 static const int kCachingStrategyFieldNumber = 5;
902 private:
903 const ::Hdfs::Internal::CachingStrategyProto& _internal_cachingstrategy() const;
904 public:
905 const ::Hdfs::Internal::CachingStrategyProto& cachingstrategy() const;
906 ::Hdfs::Internal::CachingStrategyProto* release_cachingstrategy();
907 ::Hdfs::Internal::CachingStrategyProto* mutable_cachingstrategy();
908 void set_allocated_cachingstrategy(::Hdfs::Internal::CachingStrategyProto* cachingstrategy);
909
910 // required uint64 offset = 2;
911 bool has_offset() const;
912 void clear_offset();
913 static const int kOffsetFieldNumber = 2;
914 ::google::protobuf::uint64 offset() const;
915 void set_offset(::google::protobuf::uint64 value);
916
917 // required uint64 len = 3;
918 bool has_len() const;
919 void clear_len();
920 static const int kLenFieldNumber = 3;
921 ::google::protobuf::uint64 len() const;
922 void set_len(::google::protobuf::uint64 value);
923
924 // optional bool sendChecksums = 4 [default = true];
925 bool has_sendchecksums() const;
926 void clear_sendchecksums();
927 static const int kSendChecksumsFieldNumber = 4;
928 bool sendchecksums() const;
929 void set_sendchecksums(bool value);
930
931 // @@protoc_insertion_point(class_scope:Hdfs.Internal.OpReadBlockProto)
932 private:
933 void set_has_header();
934 void clear_has_header();
935 void set_has_offset();
936 void clear_has_offset();
937 void set_has_len();
938 void clear_has_len();
939 void set_has_sendchecksums();
940 void clear_has_sendchecksums();
941 void set_has_cachingstrategy();
942 void clear_has_cachingstrategy();
943
944 // helper for ByteSizeLong()
945 size_t RequiredFieldsByteSizeFallback() const;
946
947 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
948 ::google::protobuf::internal::HasBits<1> _has_bits_;
949 mutable ::google::protobuf::internal::CachedSize _cached_size_;
950 ::Hdfs::Internal::ClientOperationHeaderProto* header_;
951 ::Hdfs::Internal::CachingStrategyProto* cachingstrategy_;
952 ::google::protobuf::uint64 offset_;
953 ::google::protobuf::uint64 len_;
954 bool sendchecksums_;
955 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
956};
957// -------------------------------------------------------------------
958
959class ChecksumProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.ChecksumProto) */ {
960 public:
961 ChecksumProto();
962 virtual ~ChecksumProto();
963
964 ChecksumProto(const ChecksumProto& from);
965
966 inline ChecksumProto& operator=(const ChecksumProto& from) {
967 CopyFrom(from);
968 return *this;
969 }
970 #if LANG_CXX11
971 ChecksumProto(ChecksumProto&& from) noexcept
972 : ChecksumProto() {
973 *this = ::std::move(from);
974 }
975
976 inline ChecksumProto& operator=(ChecksumProto&& from) noexcept {
977 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
978 if (this != &from) InternalSwap(&from);
979 } else {
980 CopyFrom(from);
981 }
982 return *this;
983 }
984 #endif
985 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
986 return _internal_metadata_.unknown_fields();
987 }
988 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
989 return _internal_metadata_.mutable_unknown_fields();
990 }
991
992 static const ::google::protobuf::Descriptor* descriptor();
993 static const ChecksumProto& default_instance();
994
995 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
996 static inline const ChecksumProto* internal_default_instance() {
997 return reinterpret_cast<const ChecksumProto*>(
998 &_ChecksumProto_default_instance_);
999 }
1000 static constexpr int kIndexInFileMessages =
1001 5;
1002
1003 void Swap(ChecksumProto* other);
1004 friend void swap(ChecksumProto& a, ChecksumProto& b) {
1005 a.Swap(&b);
1006 }
1007
1008 // implements Message ----------------------------------------------
1009
1010 inline ChecksumProto* New() const final {
1011 return CreateMaybeMessage<ChecksumProto>(NULL);
1012 }
1013
1014 ChecksumProto* New(::google::protobuf::Arena* arena) const final {
1015 return CreateMaybeMessage<ChecksumProto>(arena);
1016 }
1017 void CopyFrom(const ::google::protobuf::Message& from) final;
1018 void MergeFrom(const ::google::protobuf::Message& from) final;
1019 void CopyFrom(const ChecksumProto& from);
1020 void MergeFrom(const ChecksumProto& from);
1021 void Clear() final;
1022 bool IsInitialized() const final;
1023
1024 size_t ByteSizeLong() const final;
1025 bool MergePartialFromCodedStream(
1026 ::google::protobuf::io::CodedInputStream* input) final;
1027 void SerializeWithCachedSizes(
1028 ::google::protobuf::io::CodedOutputStream* output) const final;
1029 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1030 bool deterministic, ::google::protobuf::uint8* target) const final;
1031 int GetCachedSize() const final { return _cached_size_.Get(); }
1032
1033 private:
1034 void SharedCtor();
1035 void SharedDtor();
1036 void SetCachedSize(int size) const final;
1037 void InternalSwap(ChecksumProto* other);
1038 private:
1039 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1040 return NULL;
1041 }
1042 inline void* MaybeArenaPtr() const {
1043 return NULL;
1044 }
1045 public:
1046
1047 ::google::protobuf::Metadata GetMetadata() const final;
1048
1049 // nested types ----------------------------------------------------
1050
1051 // accessors -------------------------------------------------------
1052
1053 // required .Hdfs.Internal.ChecksumTypeProto type = 1;
1054 bool has_type() const;
1055 void clear_type();
1056 static const int kTypeFieldNumber = 1;
1057 ::Hdfs::Internal::ChecksumTypeProto type() const;
1058 void set_type(::Hdfs::Internal::ChecksumTypeProto value);
1059
1060 // required uint32 bytesPerChecksum = 2;
1061 bool has_bytesperchecksum() const;
1062 void clear_bytesperchecksum();
1063 static const int kBytesPerChecksumFieldNumber = 2;
1064 ::google::protobuf::uint32 bytesperchecksum() const;
1065 void set_bytesperchecksum(::google::protobuf::uint32 value);
1066
1067 // @@protoc_insertion_point(class_scope:Hdfs.Internal.ChecksumProto)
1068 private:
1069 void set_has_type();
1070 void clear_has_type();
1071 void set_has_bytesperchecksum();
1072 void clear_has_bytesperchecksum();
1073
1074 // helper for ByteSizeLong()
1075 size_t RequiredFieldsByteSizeFallback() const;
1076
1077 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1078 ::google::protobuf::internal::HasBits<1> _has_bits_;
1079 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1080 int type_;
1081 ::google::protobuf::uint32 bytesperchecksum_;
1082 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
1083};
1084// -------------------------------------------------------------------
1085
1086class OpWriteBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.OpWriteBlockProto) */ {
1087 public:
1088 OpWriteBlockProto();
1089 virtual ~OpWriteBlockProto();
1090
1091 OpWriteBlockProto(const OpWriteBlockProto& from);
1092
1093 inline OpWriteBlockProto& operator=(const OpWriteBlockProto& from) {
1094 CopyFrom(from);
1095 return *this;
1096 }
1097 #if LANG_CXX11
1098 OpWriteBlockProto(OpWriteBlockProto&& from) noexcept
1099 : OpWriteBlockProto() {
1100 *this = ::std::move(from);
1101 }
1102
1103 inline OpWriteBlockProto& operator=(OpWriteBlockProto&& from) noexcept {
1104 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1105 if (this != &from) InternalSwap(&from);
1106 } else {
1107 CopyFrom(from);
1108 }
1109 return *this;
1110 }
1111 #endif
1112 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1113 return _internal_metadata_.unknown_fields();
1114 }
1115 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1116 return _internal_metadata_.mutable_unknown_fields();
1117 }
1118
1119 static const ::google::protobuf::Descriptor* descriptor();
1120 static const OpWriteBlockProto& default_instance();
1121
1122 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1123 static inline const OpWriteBlockProto* internal_default_instance() {
1124 return reinterpret_cast<const OpWriteBlockProto*>(
1125 &_OpWriteBlockProto_default_instance_);
1126 }
1127 static constexpr int kIndexInFileMessages =
1128 6;
1129
1130 void Swap(OpWriteBlockProto* other);
1131 friend void swap(OpWriteBlockProto& a, OpWriteBlockProto& b) {
1132 a.Swap(&b);
1133 }
1134
1135 // implements Message ----------------------------------------------
1136
1137 inline OpWriteBlockProto* New() const final {
1138 return CreateMaybeMessage<OpWriteBlockProto>(NULL);
1139 }
1140
1141 OpWriteBlockProto* New(::google::protobuf::Arena* arena) const final {
1142 return CreateMaybeMessage<OpWriteBlockProto>(arena);
1143 }
1144 void CopyFrom(const ::google::protobuf::Message& from) final;
1145 void MergeFrom(const ::google::protobuf::Message& from) final;
1146 void CopyFrom(const OpWriteBlockProto& from);
1147 void MergeFrom(const OpWriteBlockProto& from);
1148 void Clear() final;
1149 bool IsInitialized() const final;
1150
1151 size_t ByteSizeLong() const final;
1152 bool MergePartialFromCodedStream(
1153 ::google::protobuf::io::CodedInputStream* input) final;
1154 void SerializeWithCachedSizes(
1155 ::google::protobuf::io::CodedOutputStream* output) const final;
1156 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1157 bool deterministic, ::google::protobuf::uint8* target) const final;
1158 int GetCachedSize() const final { return _cached_size_.Get(); }
1159
1160 private:
1161 void SharedCtor();
1162 void SharedDtor();
1163 void SetCachedSize(int size) const final;
1164 void InternalSwap(OpWriteBlockProto* other);
1165 private:
1166 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1167 return NULL;
1168 }
1169 inline void* MaybeArenaPtr() const {
1170 return NULL;
1171 }
1172 public:
1173
1174 ::google::protobuf::Metadata GetMetadata() const final;
1175
1176 // nested types ----------------------------------------------------
1177
1178 typedef OpWriteBlockProto_BlockConstructionStage BlockConstructionStage;
1179 static const BlockConstructionStage PIPELINE_SETUP_APPEND =
1180 OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_APPEND;
1181 static const BlockConstructionStage PIPELINE_SETUP_APPEND_RECOVERY =
1182 OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_APPEND_RECOVERY;
1183 static const BlockConstructionStage DATA_STREAMING =
1184 OpWriteBlockProto_BlockConstructionStage_DATA_STREAMING;
1185 static const BlockConstructionStage PIPELINE_SETUP_STREAMING_RECOVERY =
1186 OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_STREAMING_RECOVERY;
1187 static const BlockConstructionStage PIPELINE_CLOSE =
1188 OpWriteBlockProto_BlockConstructionStage_PIPELINE_CLOSE;
1189 static const BlockConstructionStage PIPELINE_CLOSE_RECOVERY =
1190 OpWriteBlockProto_BlockConstructionStage_PIPELINE_CLOSE_RECOVERY;
1191 static const BlockConstructionStage PIPELINE_SETUP_CREATE =
1192 OpWriteBlockProto_BlockConstructionStage_PIPELINE_SETUP_CREATE;
1193 static const BlockConstructionStage TRANSFER_RBW =
1194 OpWriteBlockProto_BlockConstructionStage_TRANSFER_RBW;
1195 static const BlockConstructionStage TRANSFER_FINALIZED =
1196 OpWriteBlockProto_BlockConstructionStage_TRANSFER_FINALIZED;
1197 static inline bool BlockConstructionStage_IsValid(int value) {
1198 return OpWriteBlockProto_BlockConstructionStage_IsValid(value);
1199 }
1200 static const BlockConstructionStage BlockConstructionStage_MIN =
1201 OpWriteBlockProto_BlockConstructionStage_BlockConstructionStage_MIN;
1202 static const BlockConstructionStage BlockConstructionStage_MAX =
1203 OpWriteBlockProto_BlockConstructionStage_BlockConstructionStage_MAX;
1204 static const int BlockConstructionStage_ARRAYSIZE =
1205 OpWriteBlockProto_BlockConstructionStage_BlockConstructionStage_ARRAYSIZE;
1206 static inline const ::google::protobuf::EnumDescriptor*
1207 BlockConstructionStage_descriptor() {
1208 return OpWriteBlockProto_BlockConstructionStage_descriptor();
1209 }
1210 static inline const ::std::string& BlockConstructionStage_Name(BlockConstructionStage value) {
1211 return OpWriteBlockProto_BlockConstructionStage_Name(value);
1212 }
1213 static inline bool BlockConstructionStage_Parse(const ::std::string& name,
1214 BlockConstructionStage* value) {
1215 return OpWriteBlockProto_BlockConstructionStage_Parse(name, value);
1216 }
1217
1218 // accessors -------------------------------------------------------
1219
1220 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
1221 int targets_size() const;
1222 void clear_targets();
1223 static const int kTargetsFieldNumber = 2;
1224 ::Hdfs::Internal::DatanodeInfoProto* mutable_targets(int index);
1225 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >*
1226 mutable_targets();
1227 const ::Hdfs::Internal::DatanodeInfoProto& targets(int index) const;
1228 ::Hdfs::Internal::DatanodeInfoProto* add_targets();
1229 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >&
1230 targets() const;
1231
1232 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
1233 bool has_header() const;
1234 void clear_header();
1235 static const int kHeaderFieldNumber = 1;
1236 private:
1237 const ::Hdfs::Internal::ClientOperationHeaderProto& _internal_header() const;
1238 public:
1239 const ::Hdfs::Internal::ClientOperationHeaderProto& header() const;
1240 ::Hdfs::Internal::ClientOperationHeaderProto* release_header();
1241 ::Hdfs::Internal::ClientOperationHeaderProto* mutable_header();
1242 void set_allocated_header(::Hdfs::Internal::ClientOperationHeaderProto* header);
1243
1244 // optional .Hdfs.Internal.DatanodeInfoProto source = 3;
1245 bool has_source() const;
1246 void clear_source();
1247 static const int kSourceFieldNumber = 3;
1248 private:
1249 const ::Hdfs::Internal::DatanodeInfoProto& _internal_source() const;
1250 public:
1251 const ::Hdfs::Internal::DatanodeInfoProto& source() const;
1252 ::Hdfs::Internal::DatanodeInfoProto* release_source();
1253 ::Hdfs::Internal::DatanodeInfoProto* mutable_source();
1254 void set_allocated_source(::Hdfs::Internal::DatanodeInfoProto* source);
1255
1256 // required .Hdfs.Internal.ChecksumProto requestedChecksum = 9;
1257 bool has_requestedchecksum() const;
1258 void clear_requestedchecksum();
1259 static const int kRequestedChecksumFieldNumber = 9;
1260 private:
1261 const ::Hdfs::Internal::ChecksumProto& _internal_requestedchecksum() const;
1262 public:
1263 const ::Hdfs::Internal::ChecksumProto& requestedchecksum() const;
1264 ::Hdfs::Internal::ChecksumProto* release_requestedchecksum();
1265 ::Hdfs::Internal::ChecksumProto* mutable_requestedchecksum();
1266 void set_allocated_requestedchecksum(::Hdfs::Internal::ChecksumProto* requestedchecksum);
1267
1268 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 10;
1269 bool has_cachingstrategy() const;
1270 void clear_cachingstrategy();
1271 static const int kCachingStrategyFieldNumber = 10;
1272 private:
1273 const ::Hdfs::Internal::CachingStrategyProto& _internal_cachingstrategy() const;
1274 public:
1275 const ::Hdfs::Internal::CachingStrategyProto& cachingstrategy() const;
1276 ::Hdfs::Internal::CachingStrategyProto* release_cachingstrategy();
1277 ::Hdfs::Internal::CachingStrategyProto* mutable_cachingstrategy();
1278 void set_allocated_cachingstrategy(::Hdfs::Internal::CachingStrategyProto* cachingstrategy);
1279
1280 // required .Hdfs.Internal.OpWriteBlockProto.BlockConstructionStage stage = 4;
1281 bool has_stage() const;
1282 void clear_stage();
1283 static const int kStageFieldNumber = 4;
1284 ::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage stage() const;
1285 void set_stage(::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage value);
1286
1287 // required uint32 pipelineSize = 5;
1288 bool has_pipelinesize() const;
1289 void clear_pipelinesize();
1290 static const int kPipelineSizeFieldNumber = 5;
1291 ::google::protobuf::uint32 pipelinesize() const;
1292 void set_pipelinesize(::google::protobuf::uint32 value);
1293
1294 // required uint64 minBytesRcvd = 6;
1295 bool has_minbytesrcvd() const;
1296 void clear_minbytesrcvd();
1297 static const int kMinBytesRcvdFieldNumber = 6;
1298 ::google::protobuf::uint64 minbytesrcvd() const;
1299 void set_minbytesrcvd(::google::protobuf::uint64 value);
1300
1301 // required uint64 maxBytesRcvd = 7;
1302 bool has_maxbytesrcvd() const;
1303 void clear_maxbytesrcvd();
1304 static const int kMaxBytesRcvdFieldNumber = 7;
1305 ::google::protobuf::uint64 maxbytesrcvd() const;
1306 void set_maxbytesrcvd(::google::protobuf::uint64 value);
1307
1308 // required uint64 latestGenerationStamp = 8;
1309 bool has_latestgenerationstamp() const;
1310 void clear_latestgenerationstamp();
1311 static const int kLatestGenerationStampFieldNumber = 8;
1312 ::google::protobuf::uint64 latestgenerationstamp() const;
1313 void set_latestgenerationstamp(::google::protobuf::uint64 value);
1314
1315 // @@protoc_insertion_point(class_scope:Hdfs.Internal.OpWriteBlockProto)
1316 private:
1317 void set_has_header();
1318 void clear_has_header();
1319 void set_has_source();
1320 void clear_has_source();
1321 void set_has_stage();
1322 void clear_has_stage();
1323 void set_has_pipelinesize();
1324 void clear_has_pipelinesize();
1325 void set_has_minbytesrcvd();
1326 void clear_has_minbytesrcvd();
1327 void set_has_maxbytesrcvd();
1328 void clear_has_maxbytesrcvd();
1329 void set_has_latestgenerationstamp();
1330 void clear_has_latestgenerationstamp();
1331 void set_has_requestedchecksum();
1332 void clear_has_requestedchecksum();
1333 void set_has_cachingstrategy();
1334 void clear_has_cachingstrategy();
1335
1336 // helper for ByteSizeLong()
1337 size_t RequiredFieldsByteSizeFallback() const;
1338
1339 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1340 ::google::protobuf::internal::HasBits<1> _has_bits_;
1341 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1342 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto > targets_;
1343 ::Hdfs::Internal::ClientOperationHeaderProto* header_;
1344 ::Hdfs::Internal::DatanodeInfoProto* source_;
1345 ::Hdfs::Internal::ChecksumProto* requestedchecksum_;
1346 ::Hdfs::Internal::CachingStrategyProto* cachingstrategy_;
1347 int stage_;
1348 ::google::protobuf::uint32 pipelinesize_;
1349 ::google::protobuf::uint64 minbytesrcvd_;
1350 ::google::protobuf::uint64 maxbytesrcvd_;
1351 ::google::protobuf::uint64 latestgenerationstamp_;
1352 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
1353};
1354// -------------------------------------------------------------------
1355
1356class OpTransferBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.OpTransferBlockProto) */ {
1357 public:
1358 OpTransferBlockProto();
1359 virtual ~OpTransferBlockProto();
1360
1361 OpTransferBlockProto(const OpTransferBlockProto& from);
1362
1363 inline OpTransferBlockProto& operator=(const OpTransferBlockProto& from) {
1364 CopyFrom(from);
1365 return *this;
1366 }
1367 #if LANG_CXX11
1368 OpTransferBlockProto(OpTransferBlockProto&& from) noexcept
1369 : OpTransferBlockProto() {
1370 *this = ::std::move(from);
1371 }
1372
1373 inline OpTransferBlockProto& operator=(OpTransferBlockProto&& from) noexcept {
1374 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1375 if (this != &from) InternalSwap(&from);
1376 } else {
1377 CopyFrom(from);
1378 }
1379 return *this;
1380 }
1381 #endif
1382 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1383 return _internal_metadata_.unknown_fields();
1384 }
1385 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1386 return _internal_metadata_.mutable_unknown_fields();
1387 }
1388
1389 static const ::google::protobuf::Descriptor* descriptor();
1390 static const OpTransferBlockProto& default_instance();
1391
1392 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1393 static inline const OpTransferBlockProto* internal_default_instance() {
1394 return reinterpret_cast<const OpTransferBlockProto*>(
1395 &_OpTransferBlockProto_default_instance_);
1396 }
1397 static constexpr int kIndexInFileMessages =
1398 7;
1399
1400 void Swap(OpTransferBlockProto* other);
1401 friend void swap(OpTransferBlockProto& a, OpTransferBlockProto& b) {
1402 a.Swap(&b);
1403 }
1404
1405 // implements Message ----------------------------------------------
1406
1407 inline OpTransferBlockProto* New() const final {
1408 return CreateMaybeMessage<OpTransferBlockProto>(NULL);
1409 }
1410
1411 OpTransferBlockProto* New(::google::protobuf::Arena* arena) const final {
1412 return CreateMaybeMessage<OpTransferBlockProto>(arena);
1413 }
1414 void CopyFrom(const ::google::protobuf::Message& from) final;
1415 void MergeFrom(const ::google::protobuf::Message& from) final;
1416 void CopyFrom(const OpTransferBlockProto& from);
1417 void MergeFrom(const OpTransferBlockProto& from);
1418 void Clear() final;
1419 bool IsInitialized() const final;
1420
1421 size_t ByteSizeLong() const final;
1422 bool MergePartialFromCodedStream(
1423 ::google::protobuf::io::CodedInputStream* input) final;
1424 void SerializeWithCachedSizes(
1425 ::google::protobuf::io::CodedOutputStream* output) const final;
1426 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1427 bool deterministic, ::google::protobuf::uint8* target) const final;
1428 int GetCachedSize() const final { return _cached_size_.Get(); }
1429
1430 private:
1431 void SharedCtor();
1432 void SharedDtor();
1433 void SetCachedSize(int size) const final;
1434 void InternalSwap(OpTransferBlockProto* other);
1435 private:
1436 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1437 return NULL;
1438 }
1439 inline void* MaybeArenaPtr() const {
1440 return NULL;
1441 }
1442 public:
1443
1444 ::google::protobuf::Metadata GetMetadata() const final;
1445
1446 // nested types ----------------------------------------------------
1447
1448 // accessors -------------------------------------------------------
1449
1450 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
1451 int targets_size() const;
1452 void clear_targets();
1453 static const int kTargetsFieldNumber = 2;
1454 ::Hdfs::Internal::DatanodeInfoProto* mutable_targets(int index);
1455 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >*
1456 mutable_targets();
1457 const ::Hdfs::Internal::DatanodeInfoProto& targets(int index) const;
1458 ::Hdfs::Internal::DatanodeInfoProto* add_targets();
1459 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >&
1460 targets() const;
1461
1462 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
1463 bool has_header() const;
1464 void clear_header();
1465 static const int kHeaderFieldNumber = 1;
1466 private:
1467 const ::Hdfs::Internal::ClientOperationHeaderProto& _internal_header() const;
1468 public:
1469 const ::Hdfs::Internal::ClientOperationHeaderProto& header() const;
1470 ::Hdfs::Internal::ClientOperationHeaderProto* release_header();
1471 ::Hdfs::Internal::ClientOperationHeaderProto* mutable_header();
1472 void set_allocated_header(::Hdfs::Internal::ClientOperationHeaderProto* header);
1473
1474 // @@protoc_insertion_point(class_scope:Hdfs.Internal.OpTransferBlockProto)
1475 private:
1476 void set_has_header();
1477 void clear_has_header();
1478
1479 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1480 ::google::protobuf::internal::HasBits<1> _has_bits_;
1481 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1482 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto > targets_;
1483 ::Hdfs::Internal::ClientOperationHeaderProto* header_;
1484 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
1485};
1486// -------------------------------------------------------------------
1487
1488class OpReplaceBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.OpReplaceBlockProto) */ {
1489 public:
1490 OpReplaceBlockProto();
1491 virtual ~OpReplaceBlockProto();
1492
1493 OpReplaceBlockProto(const OpReplaceBlockProto& from);
1494
1495 inline OpReplaceBlockProto& operator=(const OpReplaceBlockProto& from) {
1496 CopyFrom(from);
1497 return *this;
1498 }
1499 #if LANG_CXX11
1500 OpReplaceBlockProto(OpReplaceBlockProto&& from) noexcept
1501 : OpReplaceBlockProto() {
1502 *this = ::std::move(from);
1503 }
1504
1505 inline OpReplaceBlockProto& operator=(OpReplaceBlockProto&& from) noexcept {
1506 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1507 if (this != &from) InternalSwap(&from);
1508 } else {
1509 CopyFrom(from);
1510 }
1511 return *this;
1512 }
1513 #endif
1514 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1515 return _internal_metadata_.unknown_fields();
1516 }
1517 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1518 return _internal_metadata_.mutable_unknown_fields();
1519 }
1520
1521 static const ::google::protobuf::Descriptor* descriptor();
1522 static const OpReplaceBlockProto& default_instance();
1523
1524 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1525 static inline const OpReplaceBlockProto* internal_default_instance() {
1526 return reinterpret_cast<const OpReplaceBlockProto*>(
1527 &_OpReplaceBlockProto_default_instance_);
1528 }
1529 static constexpr int kIndexInFileMessages =
1530 8;
1531
1532 void Swap(OpReplaceBlockProto* other);
1533 friend void swap(OpReplaceBlockProto& a, OpReplaceBlockProto& b) {
1534 a.Swap(&b);
1535 }
1536
1537 // implements Message ----------------------------------------------
1538
1539 inline OpReplaceBlockProto* New() const final {
1540 return CreateMaybeMessage<OpReplaceBlockProto>(NULL);
1541 }
1542
1543 OpReplaceBlockProto* New(::google::protobuf::Arena* arena) const final {
1544 return CreateMaybeMessage<OpReplaceBlockProto>(arena);
1545 }
1546 void CopyFrom(const ::google::protobuf::Message& from) final;
1547 void MergeFrom(const ::google::protobuf::Message& from) final;
1548 void CopyFrom(const OpReplaceBlockProto& from);
1549 void MergeFrom(const OpReplaceBlockProto& from);
1550 void Clear() final;
1551 bool IsInitialized() const final;
1552
1553 size_t ByteSizeLong() const final;
1554 bool MergePartialFromCodedStream(
1555 ::google::protobuf::io::CodedInputStream* input) final;
1556 void SerializeWithCachedSizes(
1557 ::google::protobuf::io::CodedOutputStream* output) const final;
1558 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1559 bool deterministic, ::google::protobuf::uint8* target) const final;
1560 int GetCachedSize() const final { return _cached_size_.Get(); }
1561
1562 private:
1563 void SharedCtor();
1564 void SharedDtor();
1565 void SetCachedSize(int size) const final;
1566 void InternalSwap(OpReplaceBlockProto* other);
1567 private:
1568 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1569 return NULL;
1570 }
1571 inline void* MaybeArenaPtr() const {
1572 return NULL;
1573 }
1574 public:
1575
1576 ::google::protobuf::Metadata GetMetadata() const final;
1577
1578 // nested types ----------------------------------------------------
1579
1580 // accessors -------------------------------------------------------
1581
1582 // required string delHint = 2;
1583 bool has_delhint() const;
1584 void clear_delhint();
1585 static const int kDelHintFieldNumber = 2;
1586 const ::std::string& delhint() const;
1587 void set_delhint(const ::std::string& value);
1588 #if LANG_CXX11
1589 void set_delhint(::std::string&& value);
1590 #endif
1591 void set_delhint(const char* value);
1592 void set_delhint(const char* value, size_t size);
1593 ::std::string* mutable_delhint();
1594 ::std::string* release_delhint();
1595 void set_allocated_delhint(::std::string* delhint);
1596
1597 // required .Hdfs.Internal.BaseHeaderProto header = 1;
1598 bool has_header() const;
1599 void clear_header();
1600 static const int kHeaderFieldNumber = 1;
1601 private:
1602 const ::Hdfs::Internal::BaseHeaderProto& _internal_header() const;
1603 public:
1604 const ::Hdfs::Internal::BaseHeaderProto& header() const;
1605 ::Hdfs::Internal::BaseHeaderProto* release_header();
1606 ::Hdfs::Internal::BaseHeaderProto* mutable_header();
1607 void set_allocated_header(::Hdfs::Internal::BaseHeaderProto* header);
1608
1609 // required .Hdfs.Internal.DatanodeInfoProto source = 3;
1610 bool has_source() const;
1611 void clear_source();
1612 static const int kSourceFieldNumber = 3;
1613 private:
1614 const ::Hdfs::Internal::DatanodeInfoProto& _internal_source() const;
1615 public:
1616 const ::Hdfs::Internal::DatanodeInfoProto& source() const;
1617 ::Hdfs::Internal::DatanodeInfoProto* release_source();
1618 ::Hdfs::Internal::DatanodeInfoProto* mutable_source();
1619 void set_allocated_source(::Hdfs::Internal::DatanodeInfoProto* source);
1620
1621 // @@protoc_insertion_point(class_scope:Hdfs.Internal.OpReplaceBlockProto)
1622 private:
1623 void set_has_header();
1624 void clear_has_header();
1625 void set_has_delhint();
1626 void clear_has_delhint();
1627 void set_has_source();
1628 void clear_has_source();
1629
1630 // helper for ByteSizeLong()
1631 size_t RequiredFieldsByteSizeFallback() const;
1632
1633 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1634 ::google::protobuf::internal::HasBits<1> _has_bits_;
1635 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1636 ::google::protobuf::internal::ArenaStringPtr delhint_;
1637 ::Hdfs::Internal::BaseHeaderProto* header_;
1638 ::Hdfs::Internal::DatanodeInfoProto* source_;
1639 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
1640};
1641// -------------------------------------------------------------------
1642
1643class OpCopyBlockProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.OpCopyBlockProto) */ {
1644 public:
1645 OpCopyBlockProto();
1646 virtual ~OpCopyBlockProto();
1647
1648 OpCopyBlockProto(const OpCopyBlockProto& from);
1649
1650 inline OpCopyBlockProto& operator=(const OpCopyBlockProto& from) {
1651 CopyFrom(from);
1652 return *this;
1653 }
1654 #if LANG_CXX11
1655 OpCopyBlockProto(OpCopyBlockProto&& from) noexcept
1656 : OpCopyBlockProto() {
1657 *this = ::std::move(from);
1658 }
1659
1660 inline OpCopyBlockProto& operator=(OpCopyBlockProto&& from) noexcept {
1661 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1662 if (this != &from) InternalSwap(&from);
1663 } else {
1664 CopyFrom(from);
1665 }
1666 return *this;
1667 }
1668 #endif
1669 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1670 return _internal_metadata_.unknown_fields();
1671 }
1672 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1673 return _internal_metadata_.mutable_unknown_fields();
1674 }
1675
1676 static const ::google::protobuf::Descriptor* descriptor();
1677 static const OpCopyBlockProto& default_instance();
1678
1679 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1680 static inline const OpCopyBlockProto* internal_default_instance() {
1681 return reinterpret_cast<const OpCopyBlockProto*>(
1682 &_OpCopyBlockProto_default_instance_);
1683 }
1684 static constexpr int kIndexInFileMessages =
1685 9;
1686
1687 void Swap(OpCopyBlockProto* other);
1688 friend void swap(OpCopyBlockProto& a, OpCopyBlockProto& b) {
1689 a.Swap(&b);
1690 }
1691
1692 // implements Message ----------------------------------------------
1693
1694 inline OpCopyBlockProto* New() const final {
1695 return CreateMaybeMessage<OpCopyBlockProto>(NULL);
1696 }
1697
1698 OpCopyBlockProto* New(::google::protobuf::Arena* arena) const final {
1699 return CreateMaybeMessage<OpCopyBlockProto>(arena);
1700 }
1701 void CopyFrom(const ::google::protobuf::Message& from) final;
1702 void MergeFrom(const ::google::protobuf::Message& from) final;
1703 void CopyFrom(const OpCopyBlockProto& from);
1704 void MergeFrom(const OpCopyBlockProto& from);
1705 void Clear() final;
1706 bool IsInitialized() const final;
1707
1708 size_t ByteSizeLong() const final;
1709 bool MergePartialFromCodedStream(
1710 ::google::protobuf::io::CodedInputStream* input) final;
1711 void SerializeWithCachedSizes(
1712 ::google::protobuf::io::CodedOutputStream* output) const final;
1713 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1714 bool deterministic, ::google::protobuf::uint8* target) const final;
1715 int GetCachedSize() const final { return _cached_size_.Get(); }
1716
1717 private:
1718 void SharedCtor();
1719 void SharedDtor();
1720 void SetCachedSize(int size) const final;
1721 void InternalSwap(OpCopyBlockProto* other);
1722 private:
1723 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1724 return NULL;
1725 }
1726 inline void* MaybeArenaPtr() const {
1727 return NULL;
1728 }
1729 public:
1730
1731 ::google::protobuf::Metadata GetMetadata() const final;
1732
1733 // nested types ----------------------------------------------------
1734
1735 // accessors -------------------------------------------------------
1736
1737 // required .Hdfs.Internal.BaseHeaderProto header = 1;
1738 bool has_header() const;
1739 void clear_header();
1740 static const int kHeaderFieldNumber = 1;
1741 private:
1742 const ::Hdfs::Internal::BaseHeaderProto& _internal_header() const;
1743 public:
1744 const ::Hdfs::Internal::BaseHeaderProto& header() const;
1745 ::Hdfs::Internal::BaseHeaderProto* release_header();
1746 ::Hdfs::Internal::BaseHeaderProto* mutable_header();
1747 void set_allocated_header(::Hdfs::Internal::BaseHeaderProto* header);
1748
1749 // @@protoc_insertion_point(class_scope:Hdfs.Internal.OpCopyBlockProto)
1750 private:
1751 void set_has_header();
1752 void clear_has_header();
1753
1754 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1755 ::google::protobuf::internal::HasBits<1> _has_bits_;
1756 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1757 ::Hdfs::Internal::BaseHeaderProto* header_;
1758 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
1759};
1760// -------------------------------------------------------------------
1761
1762class OpBlockChecksumProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.OpBlockChecksumProto) */ {
1763 public:
1764 OpBlockChecksumProto();
1765 virtual ~OpBlockChecksumProto();
1766
1767 OpBlockChecksumProto(const OpBlockChecksumProto& from);
1768
1769 inline OpBlockChecksumProto& operator=(const OpBlockChecksumProto& from) {
1770 CopyFrom(from);
1771 return *this;
1772 }
1773 #if LANG_CXX11
1774 OpBlockChecksumProto(OpBlockChecksumProto&& from) noexcept
1775 : OpBlockChecksumProto() {
1776 *this = ::std::move(from);
1777 }
1778
1779 inline OpBlockChecksumProto& operator=(OpBlockChecksumProto&& from) noexcept {
1780 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1781 if (this != &from) InternalSwap(&from);
1782 } else {
1783 CopyFrom(from);
1784 }
1785 return *this;
1786 }
1787 #endif
1788 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1789 return _internal_metadata_.unknown_fields();
1790 }
1791 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1792 return _internal_metadata_.mutable_unknown_fields();
1793 }
1794
1795 static const ::google::protobuf::Descriptor* descriptor();
1796 static const OpBlockChecksumProto& default_instance();
1797
1798 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1799 static inline const OpBlockChecksumProto* internal_default_instance() {
1800 return reinterpret_cast<const OpBlockChecksumProto*>(
1801 &_OpBlockChecksumProto_default_instance_);
1802 }
1803 static constexpr int kIndexInFileMessages =
1804 10;
1805
1806 void Swap(OpBlockChecksumProto* other);
1807 friend void swap(OpBlockChecksumProto& a, OpBlockChecksumProto& b) {
1808 a.Swap(&b);
1809 }
1810
1811 // implements Message ----------------------------------------------
1812
1813 inline OpBlockChecksumProto* New() const final {
1814 return CreateMaybeMessage<OpBlockChecksumProto>(NULL);
1815 }
1816
1817 OpBlockChecksumProto* New(::google::protobuf::Arena* arena) const final {
1818 return CreateMaybeMessage<OpBlockChecksumProto>(arena);
1819 }
1820 void CopyFrom(const ::google::protobuf::Message& from) final;
1821 void MergeFrom(const ::google::protobuf::Message& from) final;
1822 void CopyFrom(const OpBlockChecksumProto& from);
1823 void MergeFrom(const OpBlockChecksumProto& from);
1824 void Clear() final;
1825 bool IsInitialized() const final;
1826
1827 size_t ByteSizeLong() const final;
1828 bool MergePartialFromCodedStream(
1829 ::google::protobuf::io::CodedInputStream* input) final;
1830 void SerializeWithCachedSizes(
1831 ::google::protobuf::io::CodedOutputStream* output) const final;
1832 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1833 bool deterministic, ::google::protobuf::uint8* target) const final;
1834 int GetCachedSize() const final { return _cached_size_.Get(); }
1835
1836 private:
1837 void SharedCtor();
1838 void SharedDtor();
1839 void SetCachedSize(int size) const final;
1840 void InternalSwap(OpBlockChecksumProto* other);
1841 private:
1842 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1843 return NULL;
1844 }
1845 inline void* MaybeArenaPtr() const {
1846 return NULL;
1847 }
1848 public:
1849
1850 ::google::protobuf::Metadata GetMetadata() const final;
1851
1852 // nested types ----------------------------------------------------
1853
1854 // accessors -------------------------------------------------------
1855
1856 // required .Hdfs.Internal.BaseHeaderProto header = 1;
1857 bool has_header() const;
1858 void clear_header();
1859 static const int kHeaderFieldNumber = 1;
1860 private:
1861 const ::Hdfs::Internal::BaseHeaderProto& _internal_header() const;
1862 public:
1863 const ::Hdfs::Internal::BaseHeaderProto& header() const;
1864 ::Hdfs::Internal::BaseHeaderProto* release_header();
1865 ::Hdfs::Internal::BaseHeaderProto* mutable_header();
1866 void set_allocated_header(::Hdfs::Internal::BaseHeaderProto* header);
1867
1868 // @@protoc_insertion_point(class_scope:Hdfs.Internal.OpBlockChecksumProto)
1869 private:
1870 void set_has_header();
1871 void clear_has_header();
1872
1873 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1874 ::google::protobuf::internal::HasBits<1> _has_bits_;
1875 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1876 ::Hdfs::Internal::BaseHeaderProto* header_;
1877 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
1878};
1879// -------------------------------------------------------------------
1880
1881class OpRequestShortCircuitAccessProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.OpRequestShortCircuitAccessProto) */ {
1882 public:
1883 OpRequestShortCircuitAccessProto();
1884 virtual ~OpRequestShortCircuitAccessProto();
1885
1886 OpRequestShortCircuitAccessProto(const OpRequestShortCircuitAccessProto& from);
1887
1888 inline OpRequestShortCircuitAccessProto& operator=(const OpRequestShortCircuitAccessProto& from) {
1889 CopyFrom(from);
1890 return *this;
1891 }
1892 #if LANG_CXX11
1893 OpRequestShortCircuitAccessProto(OpRequestShortCircuitAccessProto&& from) noexcept
1894 : OpRequestShortCircuitAccessProto() {
1895 *this = ::std::move(from);
1896 }
1897
1898 inline OpRequestShortCircuitAccessProto& operator=(OpRequestShortCircuitAccessProto&& from) noexcept {
1899 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1900 if (this != &from) InternalSwap(&from);
1901 } else {
1902 CopyFrom(from);
1903 }
1904 return *this;
1905 }
1906 #endif
1907 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1908 return _internal_metadata_.unknown_fields();
1909 }
1910 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1911 return _internal_metadata_.mutable_unknown_fields();
1912 }
1913
1914 static const ::google::protobuf::Descriptor* descriptor();
1915 static const OpRequestShortCircuitAccessProto& default_instance();
1916
1917 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1918 static inline const OpRequestShortCircuitAccessProto* internal_default_instance() {
1919 return reinterpret_cast<const OpRequestShortCircuitAccessProto*>(
1920 &_OpRequestShortCircuitAccessProto_default_instance_);
1921 }
1922 static constexpr int kIndexInFileMessages =
1923 11;
1924
1925 void Swap(OpRequestShortCircuitAccessProto* other);
1926 friend void swap(OpRequestShortCircuitAccessProto& a, OpRequestShortCircuitAccessProto& b) {
1927 a.Swap(&b);
1928 }
1929
1930 // implements Message ----------------------------------------------
1931
1932 inline OpRequestShortCircuitAccessProto* New() const final {
1933 return CreateMaybeMessage<OpRequestShortCircuitAccessProto>(NULL);
1934 }
1935
1936 OpRequestShortCircuitAccessProto* New(::google::protobuf::Arena* arena) const final {
1937 return CreateMaybeMessage<OpRequestShortCircuitAccessProto>(arena);
1938 }
1939 void CopyFrom(const ::google::protobuf::Message& from) final;
1940 void MergeFrom(const ::google::protobuf::Message& from) final;
1941 void CopyFrom(const OpRequestShortCircuitAccessProto& from);
1942 void MergeFrom(const OpRequestShortCircuitAccessProto& from);
1943 void Clear() final;
1944 bool IsInitialized() const final;
1945
1946 size_t ByteSizeLong() const final;
1947 bool MergePartialFromCodedStream(
1948 ::google::protobuf::io::CodedInputStream* input) final;
1949 void SerializeWithCachedSizes(
1950 ::google::protobuf::io::CodedOutputStream* output) const final;
1951 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1952 bool deterministic, ::google::protobuf::uint8* target) const final;
1953 int GetCachedSize() const final { return _cached_size_.Get(); }
1954
1955 private:
1956 void SharedCtor();
1957 void SharedDtor();
1958 void SetCachedSize(int size) const final;
1959 void InternalSwap(OpRequestShortCircuitAccessProto* other);
1960 private:
1961 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1962 return NULL;
1963 }
1964 inline void* MaybeArenaPtr() const {
1965 return NULL;
1966 }
1967 public:
1968
1969 ::google::protobuf::Metadata GetMetadata() const final;
1970
1971 // nested types ----------------------------------------------------
1972
1973 // accessors -------------------------------------------------------
1974
1975 // required .Hdfs.Internal.BaseHeaderProto header = 1;
1976 bool has_header() const;
1977 void clear_header();
1978 static const int kHeaderFieldNumber = 1;
1979 private:
1980 const ::Hdfs::Internal::BaseHeaderProto& _internal_header() const;
1981 public:
1982 const ::Hdfs::Internal::BaseHeaderProto& header() const;
1983 ::Hdfs::Internal::BaseHeaderProto* release_header();
1984 ::Hdfs::Internal::BaseHeaderProto* mutable_header();
1985 void set_allocated_header(::Hdfs::Internal::BaseHeaderProto* header);
1986
1987 // required uint32 maxVersion = 2;
1988 bool has_maxversion() const;
1989 void clear_maxversion();
1990 static const int kMaxVersionFieldNumber = 2;
1991 ::google::protobuf::uint32 maxversion() const;
1992 void set_maxversion(::google::protobuf::uint32 value);
1993
1994 // @@protoc_insertion_point(class_scope:Hdfs.Internal.OpRequestShortCircuitAccessProto)
1995 private:
1996 void set_has_header();
1997 void clear_has_header();
1998 void set_has_maxversion();
1999 void clear_has_maxversion();
2000
2001 // helper for ByteSizeLong()
2002 size_t RequiredFieldsByteSizeFallback() const;
2003
2004 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2005 ::google::protobuf::internal::HasBits<1> _has_bits_;
2006 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2007 ::Hdfs::Internal::BaseHeaderProto* header_;
2008 ::google::protobuf::uint32 maxversion_;
2009 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
2010};
2011// -------------------------------------------------------------------
2012
2013class PacketHeaderProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.PacketHeaderProto) */ {
2014 public:
2015 PacketHeaderProto();
2016 virtual ~PacketHeaderProto();
2017
2018 PacketHeaderProto(const PacketHeaderProto& from);
2019
2020 inline PacketHeaderProto& operator=(const PacketHeaderProto& from) {
2021 CopyFrom(from);
2022 return *this;
2023 }
2024 #if LANG_CXX11
2025 PacketHeaderProto(PacketHeaderProto&& from) noexcept
2026 : PacketHeaderProto() {
2027 *this = ::std::move(from);
2028 }
2029
2030 inline PacketHeaderProto& operator=(PacketHeaderProto&& from) noexcept {
2031 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2032 if (this != &from) InternalSwap(&from);
2033 } else {
2034 CopyFrom(from);
2035 }
2036 return *this;
2037 }
2038 #endif
2039 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2040 return _internal_metadata_.unknown_fields();
2041 }
2042 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2043 return _internal_metadata_.mutable_unknown_fields();
2044 }
2045
2046 static const ::google::protobuf::Descriptor* descriptor();
2047 static const PacketHeaderProto& default_instance();
2048
2049 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2050 static inline const PacketHeaderProto* internal_default_instance() {
2051 return reinterpret_cast<const PacketHeaderProto*>(
2052 &_PacketHeaderProto_default_instance_);
2053 }
2054 static constexpr int kIndexInFileMessages =
2055 12;
2056
2057 void Swap(PacketHeaderProto* other);
2058 friend void swap(PacketHeaderProto& a, PacketHeaderProto& b) {
2059 a.Swap(&b);
2060 }
2061
2062 // implements Message ----------------------------------------------
2063
2064 inline PacketHeaderProto* New() const final {
2065 return CreateMaybeMessage<PacketHeaderProto>(NULL);
2066 }
2067
2068 PacketHeaderProto* New(::google::protobuf::Arena* arena) const final {
2069 return CreateMaybeMessage<PacketHeaderProto>(arena);
2070 }
2071 void CopyFrom(const ::google::protobuf::Message& from) final;
2072 void MergeFrom(const ::google::protobuf::Message& from) final;
2073 void CopyFrom(const PacketHeaderProto& from);
2074 void MergeFrom(const PacketHeaderProto& from);
2075 void Clear() final;
2076 bool IsInitialized() const final;
2077
2078 size_t ByteSizeLong() const final;
2079 bool MergePartialFromCodedStream(
2080 ::google::protobuf::io::CodedInputStream* input) final;
2081 void SerializeWithCachedSizes(
2082 ::google::protobuf::io::CodedOutputStream* output) const final;
2083 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2084 bool deterministic, ::google::protobuf::uint8* target) const final;
2085 int GetCachedSize() const final { return _cached_size_.Get(); }
2086
2087 private:
2088 void SharedCtor();
2089 void SharedDtor();
2090 void SetCachedSize(int size) const final;
2091 void InternalSwap(PacketHeaderProto* other);
2092 private:
2093 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2094 return NULL;
2095 }
2096 inline void* MaybeArenaPtr() const {
2097 return NULL;
2098 }
2099 public:
2100
2101 ::google::protobuf::Metadata GetMetadata() const final;
2102
2103 // nested types ----------------------------------------------------
2104
2105 // accessors -------------------------------------------------------
2106
2107 // required sfixed64 offsetInBlock = 1;
2108 bool has_offsetinblock() const;
2109 void clear_offsetinblock();
2110 static const int kOffsetInBlockFieldNumber = 1;
2111 ::google::protobuf::int64 offsetinblock() const;
2112 void set_offsetinblock(::google::protobuf::int64 value);
2113
2114 // required sfixed64 seqno = 2;
2115 bool has_seqno() const;
2116 void clear_seqno();
2117 static const int kSeqnoFieldNumber = 2;
2118 ::google::protobuf::int64 seqno() const;
2119 void set_seqno(::google::protobuf::int64 value);
2120
2121 // required sfixed32 dataLen = 4;
2122 bool has_datalen() const;
2123 void clear_datalen();
2124 static const int kDataLenFieldNumber = 4;
2125 ::google::protobuf::int32 datalen() const;
2126 void set_datalen(::google::protobuf::int32 value);
2127
2128 // required bool lastPacketInBlock = 3;
2129 bool has_lastpacketinblock() const;
2130 void clear_lastpacketinblock();
2131 static const int kLastPacketInBlockFieldNumber = 3;
2132 bool lastpacketinblock() const;
2133 void set_lastpacketinblock(bool value);
2134
2135 // optional bool syncBlock = 5 [default = false];
2136 bool has_syncblock() const;
2137 void clear_syncblock();
2138 static const int kSyncBlockFieldNumber = 5;
2139 bool syncblock() const;
2140 void set_syncblock(bool value);
2141
2142 // @@protoc_insertion_point(class_scope:Hdfs.Internal.PacketHeaderProto)
2143 private:
2144 void set_has_offsetinblock();
2145 void clear_has_offsetinblock();
2146 void set_has_seqno();
2147 void clear_has_seqno();
2148 void set_has_lastpacketinblock();
2149 void clear_has_lastpacketinblock();
2150 void set_has_datalen();
2151 void clear_has_datalen();
2152 void set_has_syncblock();
2153 void clear_has_syncblock();
2154
2155 // helper for ByteSizeLong()
2156 size_t RequiredFieldsByteSizeFallback() const;
2157
2158 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2159 ::google::protobuf::internal::HasBits<1> _has_bits_;
2160 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2161 ::google::protobuf::int64 offsetinblock_;
2162 ::google::protobuf::int64 seqno_;
2163 ::google::protobuf::int32 datalen_;
2164 bool lastpacketinblock_;
2165 bool syncblock_;
2166 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
2167};
2168// -------------------------------------------------------------------
2169
2170class PipelineAckProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.PipelineAckProto) */ {
2171 public:
2172 PipelineAckProto();
2173 virtual ~PipelineAckProto();
2174
2175 PipelineAckProto(const PipelineAckProto& from);
2176
2177 inline PipelineAckProto& operator=(const PipelineAckProto& from) {
2178 CopyFrom(from);
2179 return *this;
2180 }
2181 #if LANG_CXX11
2182 PipelineAckProto(PipelineAckProto&& from) noexcept
2183 : PipelineAckProto() {
2184 *this = ::std::move(from);
2185 }
2186
2187 inline PipelineAckProto& operator=(PipelineAckProto&& from) noexcept {
2188 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2189 if (this != &from) InternalSwap(&from);
2190 } else {
2191 CopyFrom(from);
2192 }
2193 return *this;
2194 }
2195 #endif
2196 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2197 return _internal_metadata_.unknown_fields();
2198 }
2199 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2200 return _internal_metadata_.mutable_unknown_fields();
2201 }
2202
2203 static const ::google::protobuf::Descriptor* descriptor();
2204 static const PipelineAckProto& default_instance();
2205
2206 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2207 static inline const PipelineAckProto* internal_default_instance() {
2208 return reinterpret_cast<const PipelineAckProto*>(
2209 &_PipelineAckProto_default_instance_);
2210 }
2211 static constexpr int kIndexInFileMessages =
2212 13;
2213
2214 void Swap(PipelineAckProto* other);
2215 friend void swap(PipelineAckProto& a, PipelineAckProto& b) {
2216 a.Swap(&b);
2217 }
2218
2219 // implements Message ----------------------------------------------
2220
2221 inline PipelineAckProto* New() const final {
2222 return CreateMaybeMessage<PipelineAckProto>(NULL);
2223 }
2224
2225 PipelineAckProto* New(::google::protobuf::Arena* arena) const final {
2226 return CreateMaybeMessage<PipelineAckProto>(arena);
2227 }
2228 void CopyFrom(const ::google::protobuf::Message& from) final;
2229 void MergeFrom(const ::google::protobuf::Message& from) final;
2230 void CopyFrom(const PipelineAckProto& from);
2231 void MergeFrom(const PipelineAckProto& from);
2232 void Clear() final;
2233 bool IsInitialized() const final;
2234
2235 size_t ByteSizeLong() const final;
2236 bool MergePartialFromCodedStream(
2237 ::google::protobuf::io::CodedInputStream* input) final;
2238 void SerializeWithCachedSizes(
2239 ::google::protobuf::io::CodedOutputStream* output) const final;
2240 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2241 bool deterministic, ::google::protobuf::uint8* target) const final;
2242 int GetCachedSize() const final { return _cached_size_.Get(); }
2243
2244 private:
2245 void SharedCtor();
2246 void SharedDtor();
2247 void SetCachedSize(int size) const final;
2248 void InternalSwap(PipelineAckProto* other);
2249 private:
2250 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2251 return NULL;
2252 }
2253 inline void* MaybeArenaPtr() const {
2254 return NULL;
2255 }
2256 public:
2257
2258 ::google::protobuf::Metadata GetMetadata() const final;
2259
2260 // nested types ----------------------------------------------------
2261
2262 // accessors -------------------------------------------------------
2263
2264 // repeated .Hdfs.Internal.Status status = 2;
2265 int status_size() const;
2266 void clear_status();
2267 static const int kStatusFieldNumber = 2;
2268 ::Hdfs::Internal::Status status(int index) const;
2269 void set_status(int index, ::Hdfs::Internal::Status value);
2270 void add_status(::Hdfs::Internal::Status value);
2271 const ::google::protobuf::RepeatedField<int>& status() const;
2272 ::google::protobuf::RepeatedField<int>* mutable_status();
2273
2274 // required sint64 seqno = 1;
2275 bool has_seqno() const;
2276 void clear_seqno();
2277 static const int kSeqnoFieldNumber = 1;
2278 ::google::protobuf::int64 seqno() const;
2279 void set_seqno(::google::protobuf::int64 value);
2280
2281 // optional uint64 downstreamAckTimeNanos = 3 [default = 0];
2282 bool has_downstreamacktimenanos() const;
2283 void clear_downstreamacktimenanos();
2284 static const int kDownstreamAckTimeNanosFieldNumber = 3;
2285 ::google::protobuf::uint64 downstreamacktimenanos() const;
2286 void set_downstreamacktimenanos(::google::protobuf::uint64 value);
2287
2288 // @@protoc_insertion_point(class_scope:Hdfs.Internal.PipelineAckProto)
2289 private:
2290 void set_has_seqno();
2291 void clear_has_seqno();
2292 void set_has_downstreamacktimenanos();
2293 void clear_has_downstreamacktimenanos();
2294
2295 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2296 ::google::protobuf::internal::HasBits<1> _has_bits_;
2297 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2298 ::google::protobuf::RepeatedField<int> status_;
2299 ::google::protobuf::int64 seqno_;
2300 ::google::protobuf::uint64 downstreamacktimenanos_;
2301 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
2302};
2303// -------------------------------------------------------------------
2304
2305class ReadOpChecksumInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.ReadOpChecksumInfoProto) */ {
2306 public:
2307 ReadOpChecksumInfoProto();
2308 virtual ~ReadOpChecksumInfoProto();
2309
2310 ReadOpChecksumInfoProto(const ReadOpChecksumInfoProto& from);
2311
2312 inline ReadOpChecksumInfoProto& operator=(const ReadOpChecksumInfoProto& from) {
2313 CopyFrom(from);
2314 return *this;
2315 }
2316 #if LANG_CXX11
2317 ReadOpChecksumInfoProto(ReadOpChecksumInfoProto&& from) noexcept
2318 : ReadOpChecksumInfoProto() {
2319 *this = ::std::move(from);
2320 }
2321
2322 inline ReadOpChecksumInfoProto& operator=(ReadOpChecksumInfoProto&& from) noexcept {
2323 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2324 if (this != &from) InternalSwap(&from);
2325 } else {
2326 CopyFrom(from);
2327 }
2328 return *this;
2329 }
2330 #endif
2331 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2332 return _internal_metadata_.unknown_fields();
2333 }
2334 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2335 return _internal_metadata_.mutable_unknown_fields();
2336 }
2337
2338 static const ::google::protobuf::Descriptor* descriptor();
2339 static const ReadOpChecksumInfoProto& default_instance();
2340
2341 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2342 static inline const ReadOpChecksumInfoProto* internal_default_instance() {
2343 return reinterpret_cast<const ReadOpChecksumInfoProto*>(
2344 &_ReadOpChecksumInfoProto_default_instance_);
2345 }
2346 static constexpr int kIndexInFileMessages =
2347 14;
2348
2349 void Swap(ReadOpChecksumInfoProto* other);
2350 friend void swap(ReadOpChecksumInfoProto& a, ReadOpChecksumInfoProto& b) {
2351 a.Swap(&b);
2352 }
2353
2354 // implements Message ----------------------------------------------
2355
2356 inline ReadOpChecksumInfoProto* New() const final {
2357 return CreateMaybeMessage<ReadOpChecksumInfoProto>(NULL);
2358 }
2359
2360 ReadOpChecksumInfoProto* New(::google::protobuf::Arena* arena) const final {
2361 return CreateMaybeMessage<ReadOpChecksumInfoProto>(arena);
2362 }
2363 void CopyFrom(const ::google::protobuf::Message& from) final;
2364 void MergeFrom(const ::google::protobuf::Message& from) final;
2365 void CopyFrom(const ReadOpChecksumInfoProto& from);
2366 void MergeFrom(const ReadOpChecksumInfoProto& from);
2367 void Clear() final;
2368 bool IsInitialized() const final;
2369
2370 size_t ByteSizeLong() const final;
2371 bool MergePartialFromCodedStream(
2372 ::google::protobuf::io::CodedInputStream* input) final;
2373 void SerializeWithCachedSizes(
2374 ::google::protobuf::io::CodedOutputStream* output) const final;
2375 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2376 bool deterministic, ::google::protobuf::uint8* target) const final;
2377 int GetCachedSize() const final { return _cached_size_.Get(); }
2378
2379 private:
2380 void SharedCtor();
2381 void SharedDtor();
2382 void SetCachedSize(int size) const final;
2383 void InternalSwap(ReadOpChecksumInfoProto* other);
2384 private:
2385 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2386 return NULL;
2387 }
2388 inline void* MaybeArenaPtr() const {
2389 return NULL;
2390 }
2391 public:
2392
2393 ::google::protobuf::Metadata GetMetadata() const final;
2394
2395 // nested types ----------------------------------------------------
2396
2397 // accessors -------------------------------------------------------
2398
2399 // required .Hdfs.Internal.ChecksumProto checksum = 1;
2400 bool has_checksum() const;
2401 void clear_checksum();
2402 static const int kChecksumFieldNumber = 1;
2403 private:
2404 const ::Hdfs::Internal::ChecksumProto& _internal_checksum() const;
2405 public:
2406 const ::Hdfs::Internal::ChecksumProto& checksum() const;
2407 ::Hdfs::Internal::ChecksumProto* release_checksum();
2408 ::Hdfs::Internal::ChecksumProto* mutable_checksum();
2409 void set_allocated_checksum(::Hdfs::Internal::ChecksumProto* checksum);
2410
2411 // required uint64 chunkOffset = 2;
2412 bool has_chunkoffset() const;
2413 void clear_chunkoffset();
2414 static const int kChunkOffsetFieldNumber = 2;
2415 ::google::protobuf::uint64 chunkoffset() const;
2416 void set_chunkoffset(::google::protobuf::uint64 value);
2417
2418 // @@protoc_insertion_point(class_scope:Hdfs.Internal.ReadOpChecksumInfoProto)
2419 private:
2420 void set_has_checksum();
2421 void clear_has_checksum();
2422 void set_has_chunkoffset();
2423 void clear_has_chunkoffset();
2424
2425 // helper for ByteSizeLong()
2426 size_t RequiredFieldsByteSizeFallback() const;
2427
2428 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2429 ::google::protobuf::internal::HasBits<1> _has_bits_;
2430 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2431 ::Hdfs::Internal::ChecksumProto* checksum_;
2432 ::google::protobuf::uint64 chunkoffset_;
2433 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
2434};
2435// -------------------------------------------------------------------
2436
2437class BlockOpResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.BlockOpResponseProto) */ {
2438 public:
2439 BlockOpResponseProto();
2440 virtual ~BlockOpResponseProto();
2441
2442 BlockOpResponseProto(const BlockOpResponseProto& from);
2443
2444 inline BlockOpResponseProto& operator=(const BlockOpResponseProto& from) {
2445 CopyFrom(from);
2446 return *this;
2447 }
2448 #if LANG_CXX11
2449 BlockOpResponseProto(BlockOpResponseProto&& from) noexcept
2450 : BlockOpResponseProto() {
2451 *this = ::std::move(from);
2452 }
2453
2454 inline BlockOpResponseProto& operator=(BlockOpResponseProto&& from) noexcept {
2455 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2456 if (this != &from) InternalSwap(&from);
2457 } else {
2458 CopyFrom(from);
2459 }
2460 return *this;
2461 }
2462 #endif
2463 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2464 return _internal_metadata_.unknown_fields();
2465 }
2466 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2467 return _internal_metadata_.mutable_unknown_fields();
2468 }
2469
2470 static const ::google::protobuf::Descriptor* descriptor();
2471 static const BlockOpResponseProto& default_instance();
2472
2473 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2474 static inline const BlockOpResponseProto* internal_default_instance() {
2475 return reinterpret_cast<const BlockOpResponseProto*>(
2476 &_BlockOpResponseProto_default_instance_);
2477 }
2478 static constexpr int kIndexInFileMessages =
2479 15;
2480
2481 void Swap(BlockOpResponseProto* other);
2482 friend void swap(BlockOpResponseProto& a, BlockOpResponseProto& b) {
2483 a.Swap(&b);
2484 }
2485
2486 // implements Message ----------------------------------------------
2487
2488 inline BlockOpResponseProto* New() const final {
2489 return CreateMaybeMessage<BlockOpResponseProto>(NULL);
2490 }
2491
2492 BlockOpResponseProto* New(::google::protobuf::Arena* arena) const final {
2493 return CreateMaybeMessage<BlockOpResponseProto>(arena);
2494 }
2495 void CopyFrom(const ::google::protobuf::Message& from) final;
2496 void MergeFrom(const ::google::protobuf::Message& from) final;
2497 void CopyFrom(const BlockOpResponseProto& from);
2498 void MergeFrom(const BlockOpResponseProto& from);
2499 void Clear() final;
2500 bool IsInitialized() const final;
2501
2502 size_t ByteSizeLong() const final;
2503 bool MergePartialFromCodedStream(
2504 ::google::protobuf::io::CodedInputStream* input) final;
2505 void SerializeWithCachedSizes(
2506 ::google::protobuf::io::CodedOutputStream* output) const final;
2507 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2508 bool deterministic, ::google::protobuf::uint8* target) const final;
2509 int GetCachedSize() const final { return _cached_size_.Get(); }
2510
2511 private:
2512 void SharedCtor();
2513 void SharedDtor();
2514 void SetCachedSize(int size) const final;
2515 void InternalSwap(BlockOpResponseProto* other);
2516 private:
2517 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2518 return NULL;
2519 }
2520 inline void* MaybeArenaPtr() const {
2521 return NULL;
2522 }
2523 public:
2524
2525 ::google::protobuf::Metadata GetMetadata() const final;
2526
2527 // nested types ----------------------------------------------------
2528
2529 // accessors -------------------------------------------------------
2530
2531 // optional string firstBadLink = 2;
2532 bool has_firstbadlink() const;
2533 void clear_firstbadlink();
2534 static const int kFirstBadLinkFieldNumber = 2;
2535 const ::std::string& firstbadlink() const;
2536 void set_firstbadlink(const ::std::string& value);
2537 #if LANG_CXX11
2538 void set_firstbadlink(::std::string&& value);
2539 #endif
2540 void set_firstbadlink(const char* value);
2541 void set_firstbadlink(const char* value, size_t size);
2542 ::std::string* mutable_firstbadlink();
2543 ::std::string* release_firstbadlink();
2544 void set_allocated_firstbadlink(::std::string* firstbadlink);
2545
2546 // optional string message = 5;
2547 bool has_message() const;
2548 void clear_message();
2549 static const int kMessageFieldNumber = 5;
2550 const ::std::string& message() const;
2551 void set_message(const ::std::string& value);
2552 #if LANG_CXX11
2553 void set_message(::std::string&& value);
2554 #endif
2555 void set_message(const char* value);
2556 void set_message(const char* value, size_t size);
2557 ::std::string* mutable_message();
2558 ::std::string* release_message();
2559 void set_allocated_message(::std::string* message);
2560
2561 // optional .Hdfs.Internal.OpBlockChecksumResponseProto checksumResponse = 3;
2562 bool has_checksumresponse() const;
2563 void clear_checksumresponse();
2564 static const int kChecksumResponseFieldNumber = 3;
2565 private:
2566 const ::Hdfs::Internal::OpBlockChecksumResponseProto& _internal_checksumresponse() const;
2567 public:
2568 const ::Hdfs::Internal::OpBlockChecksumResponseProto& checksumresponse() const;
2569 ::Hdfs::Internal::OpBlockChecksumResponseProto* release_checksumresponse();
2570 ::Hdfs::Internal::OpBlockChecksumResponseProto* mutable_checksumresponse();
2571 void set_allocated_checksumresponse(::Hdfs::Internal::OpBlockChecksumResponseProto* checksumresponse);
2572
2573 // optional .Hdfs.Internal.ReadOpChecksumInfoProto readOpChecksumInfo = 4;
2574 bool has_readopchecksuminfo() const;
2575 void clear_readopchecksuminfo();
2576 static const int kReadOpChecksumInfoFieldNumber = 4;
2577 private:
2578 const ::Hdfs::Internal::ReadOpChecksumInfoProto& _internal_readopchecksuminfo() const;
2579 public:
2580 const ::Hdfs::Internal::ReadOpChecksumInfoProto& readopchecksuminfo() const;
2581 ::Hdfs::Internal::ReadOpChecksumInfoProto* release_readopchecksuminfo();
2582 ::Hdfs::Internal::ReadOpChecksumInfoProto* mutable_readopchecksuminfo();
2583 void set_allocated_readopchecksuminfo(::Hdfs::Internal::ReadOpChecksumInfoProto* readopchecksuminfo);
2584
2585 // required .Hdfs.Internal.Status status = 1;
2586 bool has_status() const;
2587 void clear_status();
2588 static const int kStatusFieldNumber = 1;
2589 ::Hdfs::Internal::Status status() const;
2590 void set_status(::Hdfs::Internal::Status value);
2591
2592 // optional uint32 shortCircuitAccessVersion = 6;
2593 bool has_shortcircuitaccessversion() const;
2594 void clear_shortcircuitaccessversion();
2595 static const int kShortCircuitAccessVersionFieldNumber = 6;
2596 ::google::protobuf::uint32 shortcircuitaccessversion() const;
2597 void set_shortcircuitaccessversion(::google::protobuf::uint32 value);
2598
2599 // @@protoc_insertion_point(class_scope:Hdfs.Internal.BlockOpResponseProto)
2600 private:
2601 void set_has_status();
2602 void clear_has_status();
2603 void set_has_firstbadlink();
2604 void clear_has_firstbadlink();
2605 void set_has_checksumresponse();
2606 void clear_has_checksumresponse();
2607 void set_has_readopchecksuminfo();
2608 void clear_has_readopchecksuminfo();
2609 void set_has_message();
2610 void clear_has_message();
2611 void set_has_shortcircuitaccessversion();
2612 void clear_has_shortcircuitaccessversion();
2613
2614 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2615 ::google::protobuf::internal::HasBits<1> _has_bits_;
2616 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2617 ::google::protobuf::internal::ArenaStringPtr firstbadlink_;
2618 ::google::protobuf::internal::ArenaStringPtr message_;
2619 ::Hdfs::Internal::OpBlockChecksumResponseProto* checksumresponse_;
2620 ::Hdfs::Internal::ReadOpChecksumInfoProto* readopchecksuminfo_;
2621 int status_;
2622 ::google::protobuf::uint32 shortcircuitaccessversion_;
2623 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
2624};
2625// -------------------------------------------------------------------
2626
2627class ClientReadStatusProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.ClientReadStatusProto) */ {
2628 public:
2629 ClientReadStatusProto();
2630 virtual ~ClientReadStatusProto();
2631
2632 ClientReadStatusProto(const ClientReadStatusProto& from);
2633
2634 inline ClientReadStatusProto& operator=(const ClientReadStatusProto& from) {
2635 CopyFrom(from);
2636 return *this;
2637 }
2638 #if LANG_CXX11
2639 ClientReadStatusProto(ClientReadStatusProto&& from) noexcept
2640 : ClientReadStatusProto() {
2641 *this = ::std::move(from);
2642 }
2643
2644 inline ClientReadStatusProto& operator=(ClientReadStatusProto&& from) noexcept {
2645 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2646 if (this != &from) InternalSwap(&from);
2647 } else {
2648 CopyFrom(from);
2649 }
2650 return *this;
2651 }
2652 #endif
2653 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2654 return _internal_metadata_.unknown_fields();
2655 }
2656 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2657 return _internal_metadata_.mutable_unknown_fields();
2658 }
2659
2660 static const ::google::protobuf::Descriptor* descriptor();
2661 static const ClientReadStatusProto& default_instance();
2662
2663 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2664 static inline const ClientReadStatusProto* internal_default_instance() {
2665 return reinterpret_cast<const ClientReadStatusProto*>(
2666 &_ClientReadStatusProto_default_instance_);
2667 }
2668 static constexpr int kIndexInFileMessages =
2669 16;
2670
2671 void Swap(ClientReadStatusProto* other);
2672 friend void swap(ClientReadStatusProto& a, ClientReadStatusProto& b) {
2673 a.Swap(&b);
2674 }
2675
2676 // implements Message ----------------------------------------------
2677
2678 inline ClientReadStatusProto* New() const final {
2679 return CreateMaybeMessage<ClientReadStatusProto>(NULL);
2680 }
2681
2682 ClientReadStatusProto* New(::google::protobuf::Arena* arena) const final {
2683 return CreateMaybeMessage<ClientReadStatusProto>(arena);
2684 }
2685 void CopyFrom(const ::google::protobuf::Message& from) final;
2686 void MergeFrom(const ::google::protobuf::Message& from) final;
2687 void CopyFrom(const ClientReadStatusProto& from);
2688 void MergeFrom(const ClientReadStatusProto& from);
2689 void Clear() final;
2690 bool IsInitialized() const final;
2691
2692 size_t ByteSizeLong() const final;
2693 bool MergePartialFromCodedStream(
2694 ::google::protobuf::io::CodedInputStream* input) final;
2695 void SerializeWithCachedSizes(
2696 ::google::protobuf::io::CodedOutputStream* output) const final;
2697 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2698 bool deterministic, ::google::protobuf::uint8* target) const final;
2699 int GetCachedSize() const final { return _cached_size_.Get(); }
2700
2701 private:
2702 void SharedCtor();
2703 void SharedDtor();
2704 void SetCachedSize(int size) const final;
2705 void InternalSwap(ClientReadStatusProto* other);
2706 private:
2707 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2708 return NULL;
2709 }
2710 inline void* MaybeArenaPtr() const {
2711 return NULL;
2712 }
2713 public:
2714
2715 ::google::protobuf::Metadata GetMetadata() const final;
2716
2717 // nested types ----------------------------------------------------
2718
2719 // accessors -------------------------------------------------------
2720
2721 // required .Hdfs.Internal.Status status = 1;
2722 bool has_status() const;
2723 void clear_status();
2724 static const int kStatusFieldNumber = 1;
2725 ::Hdfs::Internal::Status status() const;
2726 void set_status(::Hdfs::Internal::Status value);
2727
2728 // @@protoc_insertion_point(class_scope:Hdfs.Internal.ClientReadStatusProto)
2729 private:
2730 void set_has_status();
2731 void clear_has_status();
2732
2733 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2734 ::google::protobuf::internal::HasBits<1> _has_bits_;
2735 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2736 int status_;
2737 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
2738};
2739// -------------------------------------------------------------------
2740
2741class DNTransferAckProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.DNTransferAckProto) */ {
2742 public:
2743 DNTransferAckProto();
2744 virtual ~DNTransferAckProto();
2745
2746 DNTransferAckProto(const DNTransferAckProto& from);
2747
2748 inline DNTransferAckProto& operator=(const DNTransferAckProto& from) {
2749 CopyFrom(from);
2750 return *this;
2751 }
2752 #if LANG_CXX11
2753 DNTransferAckProto(DNTransferAckProto&& from) noexcept
2754 : DNTransferAckProto() {
2755 *this = ::std::move(from);
2756 }
2757
2758 inline DNTransferAckProto& operator=(DNTransferAckProto&& from) noexcept {
2759 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2760 if (this != &from) InternalSwap(&from);
2761 } else {
2762 CopyFrom(from);
2763 }
2764 return *this;
2765 }
2766 #endif
2767 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2768 return _internal_metadata_.unknown_fields();
2769 }
2770 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2771 return _internal_metadata_.mutable_unknown_fields();
2772 }
2773
2774 static const ::google::protobuf::Descriptor* descriptor();
2775 static const DNTransferAckProto& default_instance();
2776
2777 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2778 static inline const DNTransferAckProto* internal_default_instance() {
2779 return reinterpret_cast<const DNTransferAckProto*>(
2780 &_DNTransferAckProto_default_instance_);
2781 }
2782 static constexpr int kIndexInFileMessages =
2783 17;
2784
2785 void Swap(DNTransferAckProto* other);
2786 friend void swap(DNTransferAckProto& a, DNTransferAckProto& b) {
2787 a.Swap(&b);
2788 }
2789
2790 // implements Message ----------------------------------------------
2791
2792 inline DNTransferAckProto* New() const final {
2793 return CreateMaybeMessage<DNTransferAckProto>(NULL);
2794 }
2795
2796 DNTransferAckProto* New(::google::protobuf::Arena* arena) const final {
2797 return CreateMaybeMessage<DNTransferAckProto>(arena);
2798 }
2799 void CopyFrom(const ::google::protobuf::Message& from) final;
2800 void MergeFrom(const ::google::protobuf::Message& from) final;
2801 void CopyFrom(const DNTransferAckProto& from);
2802 void MergeFrom(const DNTransferAckProto& from);
2803 void Clear() final;
2804 bool IsInitialized() const final;
2805
2806 size_t ByteSizeLong() const final;
2807 bool MergePartialFromCodedStream(
2808 ::google::protobuf::io::CodedInputStream* input) final;
2809 void SerializeWithCachedSizes(
2810 ::google::protobuf::io::CodedOutputStream* output) const final;
2811 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2812 bool deterministic, ::google::protobuf::uint8* target) const final;
2813 int GetCachedSize() const final { return _cached_size_.Get(); }
2814
2815 private:
2816 void SharedCtor();
2817 void SharedDtor();
2818 void SetCachedSize(int size) const final;
2819 void InternalSwap(DNTransferAckProto* other);
2820 private:
2821 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2822 return NULL;
2823 }
2824 inline void* MaybeArenaPtr() const {
2825 return NULL;
2826 }
2827 public:
2828
2829 ::google::protobuf::Metadata GetMetadata() const final;
2830
2831 // nested types ----------------------------------------------------
2832
2833 // accessors -------------------------------------------------------
2834
2835 // required .Hdfs.Internal.Status status = 1;
2836 bool has_status() const;
2837 void clear_status();
2838 static const int kStatusFieldNumber = 1;
2839 ::Hdfs::Internal::Status status() const;
2840 void set_status(::Hdfs::Internal::Status value);
2841
2842 // @@protoc_insertion_point(class_scope:Hdfs.Internal.DNTransferAckProto)
2843 private:
2844 void set_has_status();
2845 void clear_has_status();
2846
2847 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2848 ::google::protobuf::internal::HasBits<1> _has_bits_;
2849 mutable ::google::protobuf::internal::CachedSize _cached_size_;
2850 int status_;
2851 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
2852};
2853// -------------------------------------------------------------------
2854
2855class OpBlockChecksumResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.OpBlockChecksumResponseProto) */ {
2856 public:
2857 OpBlockChecksumResponseProto();
2858 virtual ~OpBlockChecksumResponseProto();
2859
2860 OpBlockChecksumResponseProto(const OpBlockChecksumResponseProto& from);
2861
2862 inline OpBlockChecksumResponseProto& operator=(const OpBlockChecksumResponseProto& from) {
2863 CopyFrom(from);
2864 return *this;
2865 }
2866 #if LANG_CXX11
2867 OpBlockChecksumResponseProto(OpBlockChecksumResponseProto&& from) noexcept
2868 : OpBlockChecksumResponseProto() {
2869 *this = ::std::move(from);
2870 }
2871
2872 inline OpBlockChecksumResponseProto& operator=(OpBlockChecksumResponseProto&& from) noexcept {
2873 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2874 if (this != &from) InternalSwap(&from);
2875 } else {
2876 CopyFrom(from);
2877 }
2878 return *this;
2879 }
2880 #endif
2881 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2882 return _internal_metadata_.unknown_fields();
2883 }
2884 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2885 return _internal_metadata_.mutable_unknown_fields();
2886 }
2887
2888 static const ::google::protobuf::Descriptor* descriptor();
2889 static const OpBlockChecksumResponseProto& default_instance();
2890
2891 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2892 static inline const OpBlockChecksumResponseProto* internal_default_instance() {
2893 return reinterpret_cast<const OpBlockChecksumResponseProto*>(
2894 &_OpBlockChecksumResponseProto_default_instance_);
2895 }
2896 static constexpr int kIndexInFileMessages =
2897 18;
2898
2899 void Swap(OpBlockChecksumResponseProto* other);
2900 friend void swap(OpBlockChecksumResponseProto& a, OpBlockChecksumResponseProto& b) {
2901 a.Swap(&b);
2902 }
2903
2904 // implements Message ----------------------------------------------
2905
2906 inline OpBlockChecksumResponseProto* New() const final {
2907 return CreateMaybeMessage<OpBlockChecksumResponseProto>(NULL);
2908 }
2909
2910 OpBlockChecksumResponseProto* New(::google::protobuf::Arena* arena) const final {
2911 return CreateMaybeMessage<OpBlockChecksumResponseProto>(arena);
2912 }
2913 void CopyFrom(const ::google::protobuf::Message& from) final;
2914 void MergeFrom(const ::google::protobuf::Message& from) final;
2915 void CopyFrom(const OpBlockChecksumResponseProto& from);
2916 void MergeFrom(const OpBlockChecksumResponseProto& from);
2917 void Clear() final;
2918 bool IsInitialized() const final;
2919
2920 size_t ByteSizeLong() const final;
2921 bool MergePartialFromCodedStream(
2922 ::google::protobuf::io::CodedInputStream* input) final;
2923 void SerializeWithCachedSizes(
2924 ::google::protobuf::io::CodedOutputStream* output) const final;
2925 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2926 bool deterministic, ::google::protobuf::uint8* target) const final;
2927 int GetCachedSize() const final { return _cached_size_.Get(); }
2928
2929 private:
2930 void SharedCtor();
2931 void SharedDtor();
2932 void SetCachedSize(int size) const final;
2933 void InternalSwap(OpBlockChecksumResponseProto* other);
2934 private:
2935 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2936 return NULL;
2937 }
2938 inline void* MaybeArenaPtr() const {
2939 return NULL;
2940 }
2941 public:
2942
2943 ::google::protobuf::Metadata GetMetadata() const final;
2944
2945 // nested types ----------------------------------------------------
2946
2947 // accessors -------------------------------------------------------
2948
2949 // required bytes md5 = 3;
2950 bool has_md5() const;
2951 void clear_md5();
2952 static const int kMd5FieldNumber = 3;
2953 const ::std::string& md5() const;
2954 void set_md5(const ::std::string& value);
2955 #if LANG_CXX11
2956 void set_md5(::std::string&& value);
2957 #endif
2958 void set_md5(const char* value);
2959 void set_md5(const void* value, size_t size);
2960 ::std::string* mutable_md5();
2961 ::std::string* release_md5();
2962 void set_allocated_md5(::std::string* md5);
2963
2964 // required uint64 crcPerBlock = 2;
2965 bool has_crcperblock() const;
2966 void clear_crcperblock();
2967 static const int kCrcPerBlockFieldNumber = 2;
2968 ::google::protobuf::uint64 crcperblock() const;
2969 void set_crcperblock(::google::protobuf::uint64 value);
2970
2971 // required uint32 bytesPerCrc = 1;
2972 bool has_bytespercrc() const;
2973 void clear_bytespercrc();
2974 static const int kBytesPerCrcFieldNumber = 1;
2975 ::google::protobuf::uint32 bytespercrc() const;
2976 void set_bytespercrc(::google::protobuf::uint32 value);
2977
2978 // optional .Hdfs.Internal.ChecksumTypeProto crcType = 4;
2979 bool has_crctype() const;
2980 void clear_crctype();
2981 static const int kCrcTypeFieldNumber = 4;
2982 ::Hdfs::Internal::ChecksumTypeProto crctype() const;
2983 void set_crctype(::Hdfs::Internal::ChecksumTypeProto value);
2984
2985 // @@protoc_insertion_point(class_scope:Hdfs.Internal.OpBlockChecksumResponseProto)
2986 private:
2987 void set_has_bytespercrc();
2988 void clear_has_bytespercrc();
2989 void set_has_crcperblock();
2990 void clear_has_crcperblock();
2991 void set_has_md5();
2992 void clear_has_md5();
2993 void set_has_crctype();
2994 void clear_has_crctype();
2995
2996 // helper for ByteSizeLong()
2997 size_t RequiredFieldsByteSizeFallback() const;
2998
2999 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
3000 ::google::protobuf::internal::HasBits<1> _has_bits_;
3001 mutable ::google::protobuf::internal::CachedSize _cached_size_;
3002 ::google::protobuf::internal::ArenaStringPtr md5_;
3003 ::google::protobuf::uint64 crcperblock_;
3004 ::google::protobuf::uint32 bytespercrc_;
3005 int crctype_;
3006 friend struct ::protobuf_datatransfer_2eproto::TableStruct;
3007};
3008// ===================================================================
3009
3010
3011// ===================================================================
3012
3013#ifdef __GNUC__
3014 #pragma GCC diagnostic push
3015 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3016#endif // __GNUC__
3017// DataTransferEncryptorMessageProto
3018
3019// required .Hdfs.Internal.DataTransferEncryptorMessageProto.DataTransferEncryptorStatus status = 1;
3020inline bool DataTransferEncryptorMessageProto::has_status() const {
3021 return (_has_bits_[0] & 0x00000004u) != 0;
3022}
3023inline void DataTransferEncryptorMessageProto::set_has_status() {
3024 _has_bits_[0] |= 0x00000004u;
3025}
3026inline void DataTransferEncryptorMessageProto::clear_has_status() {
3027 _has_bits_[0] &= ~0x00000004u;
3028}
3029inline void DataTransferEncryptorMessageProto::clear_status() {
3030 status_ = 0;
3031 clear_has_status();
3032}
3033inline ::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorMessageProto::status() const {
3034 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataTransferEncryptorMessageProto.status)
3035 return static_cast< ::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus >(status_);
3036}
3037inline void DataTransferEncryptorMessageProto::set_status(::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus value) {
3038 assert(::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_IsValid(value));
3039 set_has_status();
3040 status_ = value;
3041 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataTransferEncryptorMessageProto.status)
3042}
3043
3044// optional bytes payload = 2;
3045inline bool DataTransferEncryptorMessageProto::has_payload() const {
3046 return (_has_bits_[0] & 0x00000001u) != 0;
3047}
3048inline void DataTransferEncryptorMessageProto::set_has_payload() {
3049 _has_bits_[0] |= 0x00000001u;
3050}
3051inline void DataTransferEncryptorMessageProto::clear_has_payload() {
3052 _has_bits_[0] &= ~0x00000001u;
3053}
3054inline void DataTransferEncryptorMessageProto::clear_payload() {
3055 payload_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3056 clear_has_payload();
3057}
3058inline const ::std::string& DataTransferEncryptorMessageProto::payload() const {
3059 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataTransferEncryptorMessageProto.payload)
3060 return payload_.GetNoArena();
3061}
3062inline void DataTransferEncryptorMessageProto::set_payload(const ::std::string& value) {
3063 set_has_payload();
3064 payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3065 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataTransferEncryptorMessageProto.payload)
3066}
3067#if LANG_CXX11
3068inline void DataTransferEncryptorMessageProto::set_payload(::std::string&& value) {
3069 set_has_payload();
3070 payload_.SetNoArena(
3071 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3072 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DataTransferEncryptorMessageProto.payload)
3073}
3074#endif
3075inline void DataTransferEncryptorMessageProto::set_payload(const char* value) {
3076 GOOGLE_DCHECK(value != NULL);
3077 set_has_payload();
3078 payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3079 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DataTransferEncryptorMessageProto.payload)
3080}
3081inline void DataTransferEncryptorMessageProto::set_payload(const void* value, size_t size) {
3082 set_has_payload();
3083 payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3084 ::std::string(reinterpret_cast<const char*>(value), size));
3085 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DataTransferEncryptorMessageProto.payload)
3086}
3087inline ::std::string* DataTransferEncryptorMessageProto::mutable_payload() {
3088 set_has_payload();
3089 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DataTransferEncryptorMessageProto.payload)
3090 return payload_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3091}
3092inline ::std::string* DataTransferEncryptorMessageProto::release_payload() {
3093 // @@protoc_insertion_point(field_release:Hdfs.Internal.DataTransferEncryptorMessageProto.payload)
3094 if (!has_payload()) {
3095 return NULL;
3096 }
3097 clear_has_payload();
3098 return payload_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3099}
3100inline void DataTransferEncryptorMessageProto::set_allocated_payload(::std::string* payload) {
3101 if (payload != NULL) {
3102 set_has_payload();
3103 } else {
3104 clear_has_payload();
3105 }
3106 payload_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), payload);
3107 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DataTransferEncryptorMessageProto.payload)
3108}
3109
3110// optional string message = 3;
3111inline bool DataTransferEncryptorMessageProto::has_message() const {
3112 return (_has_bits_[0] & 0x00000002u) != 0;
3113}
3114inline void DataTransferEncryptorMessageProto::set_has_message() {
3115 _has_bits_[0] |= 0x00000002u;
3116}
3117inline void DataTransferEncryptorMessageProto::clear_has_message() {
3118 _has_bits_[0] &= ~0x00000002u;
3119}
3120inline void DataTransferEncryptorMessageProto::clear_message() {
3121 message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3122 clear_has_message();
3123}
3124inline const ::std::string& DataTransferEncryptorMessageProto::message() const {
3125 // @@protoc_insertion_point(field_get:Hdfs.Internal.DataTransferEncryptorMessageProto.message)
3126 return message_.GetNoArena();
3127}
3128inline void DataTransferEncryptorMessageProto::set_message(const ::std::string& value) {
3129 set_has_message();
3130 message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3131 // @@protoc_insertion_point(field_set:Hdfs.Internal.DataTransferEncryptorMessageProto.message)
3132}
3133#if LANG_CXX11
3134inline void DataTransferEncryptorMessageProto::set_message(::std::string&& value) {
3135 set_has_message();
3136 message_.SetNoArena(
3137 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3138 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.DataTransferEncryptorMessageProto.message)
3139}
3140#endif
3141inline void DataTransferEncryptorMessageProto::set_message(const char* value) {
3142 GOOGLE_DCHECK(value != NULL);
3143 set_has_message();
3144 message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3145 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.DataTransferEncryptorMessageProto.message)
3146}
3147inline void DataTransferEncryptorMessageProto::set_message(const char* value, size_t size) {
3148 set_has_message();
3149 message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3150 ::std::string(reinterpret_cast<const char*>(value), size));
3151 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.DataTransferEncryptorMessageProto.message)
3152}
3153inline ::std::string* DataTransferEncryptorMessageProto::mutable_message() {
3154 set_has_message();
3155 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.DataTransferEncryptorMessageProto.message)
3156 return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3157}
3158inline ::std::string* DataTransferEncryptorMessageProto::release_message() {
3159 // @@protoc_insertion_point(field_release:Hdfs.Internal.DataTransferEncryptorMessageProto.message)
3160 if (!has_message()) {
3161 return NULL;
3162 }
3163 clear_has_message();
3164 return message_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3165}
3166inline void DataTransferEncryptorMessageProto::set_allocated_message(::std::string* message) {
3167 if (message != NULL) {
3168 set_has_message();
3169 } else {
3170 clear_has_message();
3171 }
3172 message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
3173 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.DataTransferEncryptorMessageProto.message)
3174}
3175
3176// -------------------------------------------------------------------
3177
3178// BaseHeaderProto
3179
3180// required .Hdfs.Internal.ExtendedBlockProto block = 1;
3181inline bool BaseHeaderProto::has_block() const {
3182 return (_has_bits_[0] & 0x00000001u) != 0;
3183}
3184inline void BaseHeaderProto::set_has_block() {
3185 _has_bits_[0] |= 0x00000001u;
3186}
3187inline void BaseHeaderProto::clear_has_block() {
3188 _has_bits_[0] &= ~0x00000001u;
3189}
3190inline const ::Hdfs::Internal::ExtendedBlockProto& BaseHeaderProto::_internal_block() const {
3191 return *block_;
3192}
3193inline const ::Hdfs::Internal::ExtendedBlockProto& BaseHeaderProto::block() const {
3194 const ::Hdfs::Internal::ExtendedBlockProto* p = block_;
3195 // @@protoc_insertion_point(field_get:Hdfs.Internal.BaseHeaderProto.block)
3196 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ExtendedBlockProto*>(
3197 &::Hdfs::Internal::_ExtendedBlockProto_default_instance_);
3198}
3199inline ::Hdfs::Internal::ExtendedBlockProto* BaseHeaderProto::release_block() {
3200 // @@protoc_insertion_point(field_release:Hdfs.Internal.BaseHeaderProto.block)
3201 clear_has_block();
3202 ::Hdfs::Internal::ExtendedBlockProto* temp = block_;
3203 block_ = NULL;
3204 return temp;
3205}
3206inline ::Hdfs::Internal::ExtendedBlockProto* BaseHeaderProto::mutable_block() {
3207 set_has_block();
3208 if (block_ == NULL) {
3209 auto* p = CreateMaybeMessage<::Hdfs::Internal::ExtendedBlockProto>(GetArenaNoVirtual());
3210 block_ = p;
3211 }
3212 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BaseHeaderProto.block)
3213 return block_;
3214}
3215inline void BaseHeaderProto::set_allocated_block(::Hdfs::Internal::ExtendedBlockProto* block) {
3216 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3217 if (message_arena == NULL) {
3218 delete reinterpret_cast< ::google::protobuf::MessageLite*>(block_);
3219 }
3220 if (block) {
3221 ::google::protobuf::Arena* submessage_arena = NULL;
3222 if (message_arena != submessage_arena) {
3223 block = ::google::protobuf::internal::GetOwnedMessage(
3224 message_arena, block, submessage_arena);
3225 }
3226 set_has_block();
3227 } else {
3228 clear_has_block();
3229 }
3230 block_ = block;
3231 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.BaseHeaderProto.block)
3232}
3233
3234// optional .Hdfs.Internal.TokenProto token = 2;
3235inline bool BaseHeaderProto::has_token() const {
3236 return (_has_bits_[0] & 0x00000002u) != 0;
3237}
3238inline void BaseHeaderProto::set_has_token() {
3239 _has_bits_[0] |= 0x00000002u;
3240}
3241inline void BaseHeaderProto::clear_has_token() {
3242 _has_bits_[0] &= ~0x00000002u;
3243}
3244inline const ::Hdfs::Internal::TokenProto& BaseHeaderProto::_internal_token() const {
3245 return *token_;
3246}
3247inline const ::Hdfs::Internal::TokenProto& BaseHeaderProto::token() const {
3248 const ::Hdfs::Internal::TokenProto* p = token_;
3249 // @@protoc_insertion_point(field_get:Hdfs.Internal.BaseHeaderProto.token)
3250 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::TokenProto*>(
3251 &::Hdfs::Internal::_TokenProto_default_instance_);
3252}
3253inline ::Hdfs::Internal::TokenProto* BaseHeaderProto::release_token() {
3254 // @@protoc_insertion_point(field_release:Hdfs.Internal.BaseHeaderProto.token)
3255 clear_has_token();
3256 ::Hdfs::Internal::TokenProto* temp = token_;
3257 token_ = NULL;
3258 return temp;
3259}
3260inline ::Hdfs::Internal::TokenProto* BaseHeaderProto::mutable_token() {
3261 set_has_token();
3262 if (token_ == NULL) {
3263 auto* p = CreateMaybeMessage<::Hdfs::Internal::TokenProto>(GetArenaNoVirtual());
3264 token_ = p;
3265 }
3266 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BaseHeaderProto.token)
3267 return token_;
3268}
3269inline void BaseHeaderProto::set_allocated_token(::Hdfs::Internal::TokenProto* token) {
3270 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3271 if (message_arena == NULL) {
3272 delete reinterpret_cast< ::google::protobuf::MessageLite*>(token_);
3273 }
3274 if (token) {
3275 ::google::protobuf::Arena* submessage_arena = NULL;
3276 if (message_arena != submessage_arena) {
3277 token = ::google::protobuf::internal::GetOwnedMessage(
3278 message_arena, token, submessage_arena);
3279 }
3280 set_has_token();
3281 } else {
3282 clear_has_token();
3283 }
3284 token_ = token;
3285 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.BaseHeaderProto.token)
3286}
3287
3288// -------------------------------------------------------------------
3289
3290// ClientOperationHeaderProto
3291
3292// required .Hdfs.Internal.BaseHeaderProto baseHeader = 1;
3293inline bool ClientOperationHeaderProto::has_baseheader() const {
3294 return (_has_bits_[0] & 0x00000002u) != 0;
3295}
3296inline void ClientOperationHeaderProto::set_has_baseheader() {
3297 _has_bits_[0] |= 0x00000002u;
3298}
3299inline void ClientOperationHeaderProto::clear_has_baseheader() {
3300 _has_bits_[0] &= ~0x00000002u;
3301}
3302inline void ClientOperationHeaderProto::clear_baseheader() {
3303 if (baseheader_ != NULL) baseheader_->Clear();
3304 clear_has_baseheader();
3305}
3306inline const ::Hdfs::Internal::BaseHeaderProto& ClientOperationHeaderProto::_internal_baseheader() const {
3307 return *baseheader_;
3308}
3309inline const ::Hdfs::Internal::BaseHeaderProto& ClientOperationHeaderProto::baseheader() const {
3310 const ::Hdfs::Internal::BaseHeaderProto* p = baseheader_;
3311 // @@protoc_insertion_point(field_get:Hdfs.Internal.ClientOperationHeaderProto.baseHeader)
3312 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::BaseHeaderProto*>(
3313 &::Hdfs::Internal::_BaseHeaderProto_default_instance_);
3314}
3315inline ::Hdfs::Internal::BaseHeaderProto* ClientOperationHeaderProto::release_baseheader() {
3316 // @@protoc_insertion_point(field_release:Hdfs.Internal.ClientOperationHeaderProto.baseHeader)
3317 clear_has_baseheader();
3318 ::Hdfs::Internal::BaseHeaderProto* temp = baseheader_;
3319 baseheader_ = NULL;
3320 return temp;
3321}
3322inline ::Hdfs::Internal::BaseHeaderProto* ClientOperationHeaderProto::mutable_baseheader() {
3323 set_has_baseheader();
3324 if (baseheader_ == NULL) {
3325 auto* p = CreateMaybeMessage<::Hdfs::Internal::BaseHeaderProto>(GetArenaNoVirtual());
3326 baseheader_ = p;
3327 }
3328 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.ClientOperationHeaderProto.baseHeader)
3329 return baseheader_;
3330}
3331inline void ClientOperationHeaderProto::set_allocated_baseheader(::Hdfs::Internal::BaseHeaderProto* baseheader) {
3332 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3333 if (message_arena == NULL) {
3334 delete baseheader_;
3335 }
3336 if (baseheader) {
3337 ::google::protobuf::Arena* submessage_arena = NULL;
3338 if (message_arena != submessage_arena) {
3339 baseheader = ::google::protobuf::internal::GetOwnedMessage(
3340 message_arena, baseheader, submessage_arena);
3341 }
3342 set_has_baseheader();
3343 } else {
3344 clear_has_baseheader();
3345 }
3346 baseheader_ = baseheader;
3347 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.ClientOperationHeaderProto.baseHeader)
3348}
3349
3350// required string clientName = 2;
3351inline bool ClientOperationHeaderProto::has_clientname() const {
3352 return (_has_bits_[0] & 0x00000001u) != 0;
3353}
3354inline void ClientOperationHeaderProto::set_has_clientname() {
3355 _has_bits_[0] |= 0x00000001u;
3356}
3357inline void ClientOperationHeaderProto::clear_has_clientname() {
3358 _has_bits_[0] &= ~0x00000001u;
3359}
3360inline void ClientOperationHeaderProto::clear_clientname() {
3361 clientname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3362 clear_has_clientname();
3363}
3364inline const ::std::string& ClientOperationHeaderProto::clientname() const {
3365 // @@protoc_insertion_point(field_get:Hdfs.Internal.ClientOperationHeaderProto.clientName)
3366 return clientname_.GetNoArena();
3367}
3368inline void ClientOperationHeaderProto::set_clientname(const ::std::string& value) {
3369 set_has_clientname();
3370 clientname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3371 // @@protoc_insertion_point(field_set:Hdfs.Internal.ClientOperationHeaderProto.clientName)
3372}
3373#if LANG_CXX11
3374inline void ClientOperationHeaderProto::set_clientname(::std::string&& value) {
3375 set_has_clientname();
3376 clientname_.SetNoArena(
3377 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3378 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.ClientOperationHeaderProto.clientName)
3379}
3380#endif
3381inline void ClientOperationHeaderProto::set_clientname(const char* value) {
3382 GOOGLE_DCHECK(value != NULL);
3383 set_has_clientname();
3384 clientname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3385 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.ClientOperationHeaderProto.clientName)
3386}
3387inline void ClientOperationHeaderProto::set_clientname(const char* value, size_t size) {
3388 set_has_clientname();
3389 clientname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3390 ::std::string(reinterpret_cast<const char*>(value), size));
3391 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.ClientOperationHeaderProto.clientName)
3392}
3393inline ::std::string* ClientOperationHeaderProto::mutable_clientname() {
3394 set_has_clientname();
3395 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.ClientOperationHeaderProto.clientName)
3396 return clientname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3397}
3398inline ::std::string* ClientOperationHeaderProto::release_clientname() {
3399 // @@protoc_insertion_point(field_release:Hdfs.Internal.ClientOperationHeaderProto.clientName)
3400 if (!has_clientname()) {
3401 return NULL;
3402 }
3403 clear_has_clientname();
3404 return clientname_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3405}
3406inline void ClientOperationHeaderProto::set_allocated_clientname(::std::string* clientname) {
3407 if (clientname != NULL) {
3408 set_has_clientname();
3409 } else {
3410 clear_has_clientname();
3411 }
3412 clientname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), clientname);
3413 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.ClientOperationHeaderProto.clientName)
3414}
3415
3416// -------------------------------------------------------------------
3417
3418// CachingStrategyProto
3419
3420// optional bool dropBehind = 1;
3421inline bool CachingStrategyProto::has_dropbehind() const {
3422 return (_has_bits_[0] & 0x00000002u) != 0;
3423}
3424inline void CachingStrategyProto::set_has_dropbehind() {
3425 _has_bits_[0] |= 0x00000002u;
3426}
3427inline void CachingStrategyProto::clear_has_dropbehind() {
3428 _has_bits_[0] &= ~0x00000002u;
3429}
3430inline void CachingStrategyProto::clear_dropbehind() {
3431 dropbehind_ = false;
3432 clear_has_dropbehind();
3433}
3434inline bool CachingStrategyProto::dropbehind() const {
3435 // @@protoc_insertion_point(field_get:Hdfs.Internal.CachingStrategyProto.dropBehind)
3436 return dropbehind_;
3437}
3438inline void CachingStrategyProto::set_dropbehind(bool value) {
3439 set_has_dropbehind();
3440 dropbehind_ = value;
3441 // @@protoc_insertion_point(field_set:Hdfs.Internal.CachingStrategyProto.dropBehind)
3442}
3443
3444// optional int64 readahead = 2;
3445inline bool CachingStrategyProto::has_readahead() const {
3446 return (_has_bits_[0] & 0x00000001u) != 0;
3447}
3448inline void CachingStrategyProto::set_has_readahead() {
3449 _has_bits_[0] |= 0x00000001u;
3450}
3451inline void CachingStrategyProto::clear_has_readahead() {
3452 _has_bits_[0] &= ~0x00000001u;
3453}
3454inline void CachingStrategyProto::clear_readahead() {
3455 readahead_ = GOOGLE_LONGLONG(0);
3456 clear_has_readahead();
3457}
3458inline ::google::protobuf::int64 CachingStrategyProto::readahead() const {
3459 // @@protoc_insertion_point(field_get:Hdfs.Internal.CachingStrategyProto.readahead)
3460 return readahead_;
3461}
3462inline void CachingStrategyProto::set_readahead(::google::protobuf::int64 value) {
3463 set_has_readahead();
3464 readahead_ = value;
3465 // @@protoc_insertion_point(field_set:Hdfs.Internal.CachingStrategyProto.readahead)
3466}
3467
3468// -------------------------------------------------------------------
3469
3470// OpReadBlockProto
3471
3472// required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3473inline bool OpReadBlockProto::has_header() const {
3474 return (_has_bits_[0] & 0x00000001u) != 0;
3475}
3476inline void OpReadBlockProto::set_has_header() {
3477 _has_bits_[0] |= 0x00000001u;
3478}
3479inline void OpReadBlockProto::clear_has_header() {
3480 _has_bits_[0] &= ~0x00000001u;
3481}
3482inline void OpReadBlockProto::clear_header() {
3483 if (header_ != NULL) header_->Clear();
3484 clear_has_header();
3485}
3486inline const ::Hdfs::Internal::ClientOperationHeaderProto& OpReadBlockProto::_internal_header() const {
3487 return *header_;
3488}
3489inline const ::Hdfs::Internal::ClientOperationHeaderProto& OpReadBlockProto::header() const {
3490 const ::Hdfs::Internal::ClientOperationHeaderProto* p = header_;
3491 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpReadBlockProto.header)
3492 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ClientOperationHeaderProto*>(
3493 &::Hdfs::Internal::_ClientOperationHeaderProto_default_instance_);
3494}
3495inline ::Hdfs::Internal::ClientOperationHeaderProto* OpReadBlockProto::release_header() {
3496 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpReadBlockProto.header)
3497 clear_has_header();
3498 ::Hdfs::Internal::ClientOperationHeaderProto* temp = header_;
3499 header_ = NULL;
3500 return temp;
3501}
3502inline ::Hdfs::Internal::ClientOperationHeaderProto* OpReadBlockProto::mutable_header() {
3503 set_has_header();
3504 if (header_ == NULL) {
3505 auto* p = CreateMaybeMessage<::Hdfs::Internal::ClientOperationHeaderProto>(GetArenaNoVirtual());
3506 header_ = p;
3507 }
3508 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpReadBlockProto.header)
3509 return header_;
3510}
3511inline void OpReadBlockProto::set_allocated_header(::Hdfs::Internal::ClientOperationHeaderProto* header) {
3512 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3513 if (message_arena == NULL) {
3514 delete header_;
3515 }
3516 if (header) {
3517 ::google::protobuf::Arena* submessage_arena = NULL;
3518 if (message_arena != submessage_arena) {
3519 header = ::google::protobuf::internal::GetOwnedMessage(
3520 message_arena, header, submessage_arena);
3521 }
3522 set_has_header();
3523 } else {
3524 clear_has_header();
3525 }
3526 header_ = header;
3527 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpReadBlockProto.header)
3528}
3529
3530// required uint64 offset = 2;
3531inline bool OpReadBlockProto::has_offset() const {
3532 return (_has_bits_[0] & 0x00000004u) != 0;
3533}
3534inline void OpReadBlockProto::set_has_offset() {
3535 _has_bits_[0] |= 0x00000004u;
3536}
3537inline void OpReadBlockProto::clear_has_offset() {
3538 _has_bits_[0] &= ~0x00000004u;
3539}
3540inline void OpReadBlockProto::clear_offset() {
3541 offset_ = GOOGLE_ULONGLONG(0);
3542 clear_has_offset();
3543}
3544inline ::google::protobuf::uint64 OpReadBlockProto::offset() const {
3545 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpReadBlockProto.offset)
3546 return offset_;
3547}
3548inline void OpReadBlockProto::set_offset(::google::protobuf::uint64 value) {
3549 set_has_offset();
3550 offset_ = value;
3551 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpReadBlockProto.offset)
3552}
3553
3554// required uint64 len = 3;
3555inline bool OpReadBlockProto::has_len() const {
3556 return (_has_bits_[0] & 0x00000008u) != 0;
3557}
3558inline void OpReadBlockProto::set_has_len() {
3559 _has_bits_[0] |= 0x00000008u;
3560}
3561inline void OpReadBlockProto::clear_has_len() {
3562 _has_bits_[0] &= ~0x00000008u;
3563}
3564inline void OpReadBlockProto::clear_len() {
3565 len_ = GOOGLE_ULONGLONG(0);
3566 clear_has_len();
3567}
3568inline ::google::protobuf::uint64 OpReadBlockProto::len() const {
3569 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpReadBlockProto.len)
3570 return len_;
3571}
3572inline void OpReadBlockProto::set_len(::google::protobuf::uint64 value) {
3573 set_has_len();
3574 len_ = value;
3575 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpReadBlockProto.len)
3576}
3577
3578// optional bool sendChecksums = 4 [default = true];
3579inline bool OpReadBlockProto::has_sendchecksums() const {
3580 return (_has_bits_[0] & 0x00000010u) != 0;
3581}
3582inline void OpReadBlockProto::set_has_sendchecksums() {
3583 _has_bits_[0] |= 0x00000010u;
3584}
3585inline void OpReadBlockProto::clear_has_sendchecksums() {
3586 _has_bits_[0] &= ~0x00000010u;
3587}
3588inline void OpReadBlockProto::clear_sendchecksums() {
3589 sendchecksums_ = true;
3590 clear_has_sendchecksums();
3591}
3592inline bool OpReadBlockProto::sendchecksums() const {
3593 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpReadBlockProto.sendChecksums)
3594 return sendchecksums_;
3595}
3596inline void OpReadBlockProto::set_sendchecksums(bool value) {
3597 set_has_sendchecksums();
3598 sendchecksums_ = value;
3599 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpReadBlockProto.sendChecksums)
3600}
3601
3602// optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 5;
3603inline bool OpReadBlockProto::has_cachingstrategy() const {
3604 return (_has_bits_[0] & 0x00000002u) != 0;
3605}
3606inline void OpReadBlockProto::set_has_cachingstrategy() {
3607 _has_bits_[0] |= 0x00000002u;
3608}
3609inline void OpReadBlockProto::clear_has_cachingstrategy() {
3610 _has_bits_[0] &= ~0x00000002u;
3611}
3612inline void OpReadBlockProto::clear_cachingstrategy() {
3613 if (cachingstrategy_ != NULL) cachingstrategy_->Clear();
3614 clear_has_cachingstrategy();
3615}
3616inline const ::Hdfs::Internal::CachingStrategyProto& OpReadBlockProto::_internal_cachingstrategy() const {
3617 return *cachingstrategy_;
3618}
3619inline const ::Hdfs::Internal::CachingStrategyProto& OpReadBlockProto::cachingstrategy() const {
3620 const ::Hdfs::Internal::CachingStrategyProto* p = cachingstrategy_;
3621 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpReadBlockProto.cachingStrategy)
3622 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::CachingStrategyProto*>(
3623 &::Hdfs::Internal::_CachingStrategyProto_default_instance_);
3624}
3625inline ::Hdfs::Internal::CachingStrategyProto* OpReadBlockProto::release_cachingstrategy() {
3626 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpReadBlockProto.cachingStrategy)
3627 clear_has_cachingstrategy();
3628 ::Hdfs::Internal::CachingStrategyProto* temp = cachingstrategy_;
3629 cachingstrategy_ = NULL;
3630 return temp;
3631}
3632inline ::Hdfs::Internal::CachingStrategyProto* OpReadBlockProto::mutable_cachingstrategy() {
3633 set_has_cachingstrategy();
3634 if (cachingstrategy_ == NULL) {
3635 auto* p = CreateMaybeMessage<::Hdfs::Internal::CachingStrategyProto>(GetArenaNoVirtual());
3636 cachingstrategy_ = p;
3637 }
3638 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpReadBlockProto.cachingStrategy)
3639 return cachingstrategy_;
3640}
3641inline void OpReadBlockProto::set_allocated_cachingstrategy(::Hdfs::Internal::CachingStrategyProto* cachingstrategy) {
3642 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3643 if (message_arena == NULL) {
3644 delete cachingstrategy_;
3645 }
3646 if (cachingstrategy) {
3647 ::google::protobuf::Arena* submessage_arena = NULL;
3648 if (message_arena != submessage_arena) {
3649 cachingstrategy = ::google::protobuf::internal::GetOwnedMessage(
3650 message_arena, cachingstrategy, submessage_arena);
3651 }
3652 set_has_cachingstrategy();
3653 } else {
3654 clear_has_cachingstrategy();
3655 }
3656 cachingstrategy_ = cachingstrategy;
3657 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpReadBlockProto.cachingStrategy)
3658}
3659
3660// -------------------------------------------------------------------
3661
3662// ChecksumProto
3663
3664// required .Hdfs.Internal.ChecksumTypeProto type = 1;
3665inline bool ChecksumProto::has_type() const {
3666 return (_has_bits_[0] & 0x00000001u) != 0;
3667}
3668inline void ChecksumProto::set_has_type() {
3669 _has_bits_[0] |= 0x00000001u;
3670}
3671inline void ChecksumProto::clear_has_type() {
3672 _has_bits_[0] &= ~0x00000001u;
3673}
3674inline void ChecksumProto::clear_type() {
3675 type_ = 0;
3676 clear_has_type();
3677}
3678inline ::Hdfs::Internal::ChecksumTypeProto ChecksumProto::type() const {
3679 // @@protoc_insertion_point(field_get:Hdfs.Internal.ChecksumProto.type)
3680 return static_cast< ::Hdfs::Internal::ChecksumTypeProto >(type_);
3681}
3682inline void ChecksumProto::set_type(::Hdfs::Internal::ChecksumTypeProto value) {
3683 assert(::Hdfs::Internal::ChecksumTypeProto_IsValid(value));
3684 set_has_type();
3685 type_ = value;
3686 // @@protoc_insertion_point(field_set:Hdfs.Internal.ChecksumProto.type)
3687}
3688
3689// required uint32 bytesPerChecksum = 2;
3690inline bool ChecksumProto::has_bytesperchecksum() const {
3691 return (_has_bits_[0] & 0x00000002u) != 0;
3692}
3693inline void ChecksumProto::set_has_bytesperchecksum() {
3694 _has_bits_[0] |= 0x00000002u;
3695}
3696inline void ChecksumProto::clear_has_bytesperchecksum() {
3697 _has_bits_[0] &= ~0x00000002u;
3698}
3699inline void ChecksumProto::clear_bytesperchecksum() {
3700 bytesperchecksum_ = 0u;
3701 clear_has_bytesperchecksum();
3702}
3703inline ::google::protobuf::uint32 ChecksumProto::bytesperchecksum() const {
3704 // @@protoc_insertion_point(field_get:Hdfs.Internal.ChecksumProto.bytesPerChecksum)
3705 return bytesperchecksum_;
3706}
3707inline void ChecksumProto::set_bytesperchecksum(::google::protobuf::uint32 value) {
3708 set_has_bytesperchecksum();
3709 bytesperchecksum_ = value;
3710 // @@protoc_insertion_point(field_set:Hdfs.Internal.ChecksumProto.bytesPerChecksum)
3711}
3712
3713// -------------------------------------------------------------------
3714
3715// OpWriteBlockProto
3716
3717// required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3718inline bool OpWriteBlockProto::has_header() const {
3719 return (_has_bits_[0] & 0x00000001u) != 0;
3720}
3721inline void OpWriteBlockProto::set_has_header() {
3722 _has_bits_[0] |= 0x00000001u;
3723}
3724inline void OpWriteBlockProto::clear_has_header() {
3725 _has_bits_[0] &= ~0x00000001u;
3726}
3727inline void OpWriteBlockProto::clear_header() {
3728 if (header_ != NULL) header_->Clear();
3729 clear_has_header();
3730}
3731inline const ::Hdfs::Internal::ClientOperationHeaderProto& OpWriteBlockProto::_internal_header() const {
3732 return *header_;
3733}
3734inline const ::Hdfs::Internal::ClientOperationHeaderProto& OpWriteBlockProto::header() const {
3735 const ::Hdfs::Internal::ClientOperationHeaderProto* p = header_;
3736 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.header)
3737 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ClientOperationHeaderProto*>(
3738 &::Hdfs::Internal::_ClientOperationHeaderProto_default_instance_);
3739}
3740inline ::Hdfs::Internal::ClientOperationHeaderProto* OpWriteBlockProto::release_header() {
3741 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpWriteBlockProto.header)
3742 clear_has_header();
3743 ::Hdfs::Internal::ClientOperationHeaderProto* temp = header_;
3744 header_ = NULL;
3745 return temp;
3746}
3747inline ::Hdfs::Internal::ClientOperationHeaderProto* OpWriteBlockProto::mutable_header() {
3748 set_has_header();
3749 if (header_ == NULL) {
3750 auto* p = CreateMaybeMessage<::Hdfs::Internal::ClientOperationHeaderProto>(GetArenaNoVirtual());
3751 header_ = p;
3752 }
3753 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpWriteBlockProto.header)
3754 return header_;
3755}
3756inline void OpWriteBlockProto::set_allocated_header(::Hdfs::Internal::ClientOperationHeaderProto* header) {
3757 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3758 if (message_arena == NULL) {
3759 delete header_;
3760 }
3761 if (header) {
3762 ::google::protobuf::Arena* submessage_arena = NULL;
3763 if (message_arena != submessage_arena) {
3764 header = ::google::protobuf::internal::GetOwnedMessage(
3765 message_arena, header, submessage_arena);
3766 }
3767 set_has_header();
3768 } else {
3769 clear_has_header();
3770 }
3771 header_ = header;
3772 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpWriteBlockProto.header)
3773}
3774
3775// repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3776inline int OpWriteBlockProto::targets_size() const {
3777 return targets_.size();
3778}
3779inline ::Hdfs::Internal::DatanodeInfoProto* OpWriteBlockProto::mutable_targets(int index) {
3780 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpWriteBlockProto.targets)
3781 return targets_.Mutable(index);
3782}
3783inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >*
3784OpWriteBlockProto::mutable_targets() {
3785 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.OpWriteBlockProto.targets)
3786 return &targets_;
3787}
3788inline const ::Hdfs::Internal::DatanodeInfoProto& OpWriteBlockProto::targets(int index) const {
3789 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.targets)
3790 return targets_.Get(index);
3791}
3792inline ::Hdfs::Internal::DatanodeInfoProto* OpWriteBlockProto::add_targets() {
3793 // @@protoc_insertion_point(field_add:Hdfs.Internal.OpWriteBlockProto.targets)
3794 return targets_.Add();
3795}
3796inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >&
3797OpWriteBlockProto::targets() const {
3798 // @@protoc_insertion_point(field_list:Hdfs.Internal.OpWriteBlockProto.targets)
3799 return targets_;
3800}
3801
3802// optional .Hdfs.Internal.DatanodeInfoProto source = 3;
3803inline bool OpWriteBlockProto::has_source() const {
3804 return (_has_bits_[0] & 0x00000002u) != 0;
3805}
3806inline void OpWriteBlockProto::set_has_source() {
3807 _has_bits_[0] |= 0x00000002u;
3808}
3809inline void OpWriteBlockProto::clear_has_source() {
3810 _has_bits_[0] &= ~0x00000002u;
3811}
3812inline const ::Hdfs::Internal::DatanodeInfoProto& OpWriteBlockProto::_internal_source() const {
3813 return *source_;
3814}
3815inline const ::Hdfs::Internal::DatanodeInfoProto& OpWriteBlockProto::source() const {
3816 const ::Hdfs::Internal::DatanodeInfoProto* p = source_;
3817 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.source)
3818 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::DatanodeInfoProto*>(
3819 &::Hdfs::Internal::_DatanodeInfoProto_default_instance_);
3820}
3821inline ::Hdfs::Internal::DatanodeInfoProto* OpWriteBlockProto::release_source() {
3822 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpWriteBlockProto.source)
3823 clear_has_source();
3824 ::Hdfs::Internal::DatanodeInfoProto* temp = source_;
3825 source_ = NULL;
3826 return temp;
3827}
3828inline ::Hdfs::Internal::DatanodeInfoProto* OpWriteBlockProto::mutable_source() {
3829 set_has_source();
3830 if (source_ == NULL) {
3831 auto* p = CreateMaybeMessage<::Hdfs::Internal::DatanodeInfoProto>(GetArenaNoVirtual());
3832 source_ = p;
3833 }
3834 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpWriteBlockProto.source)
3835 return source_;
3836}
3837inline void OpWriteBlockProto::set_allocated_source(::Hdfs::Internal::DatanodeInfoProto* source) {
3838 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3839 if (message_arena == NULL) {
3840 delete reinterpret_cast< ::google::protobuf::MessageLite*>(source_);
3841 }
3842 if (source) {
3843 ::google::protobuf::Arena* submessage_arena = NULL;
3844 if (message_arena != submessage_arena) {
3845 source = ::google::protobuf::internal::GetOwnedMessage(
3846 message_arena, source, submessage_arena);
3847 }
3848 set_has_source();
3849 } else {
3850 clear_has_source();
3851 }
3852 source_ = source;
3853 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpWriteBlockProto.source)
3854}
3855
3856// required .Hdfs.Internal.OpWriteBlockProto.BlockConstructionStage stage = 4;
3857inline bool OpWriteBlockProto::has_stage() const {
3858 return (_has_bits_[0] & 0x00000010u) != 0;
3859}
3860inline void OpWriteBlockProto::set_has_stage() {
3861 _has_bits_[0] |= 0x00000010u;
3862}
3863inline void OpWriteBlockProto::clear_has_stage() {
3864 _has_bits_[0] &= ~0x00000010u;
3865}
3866inline void OpWriteBlockProto::clear_stage() {
3867 stage_ = 0;
3868 clear_has_stage();
3869}
3870inline ::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::stage() const {
3871 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.stage)
3872 return static_cast< ::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage >(stage_);
3873}
3874inline void OpWriteBlockProto::set_stage(::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage value) {
3875 assert(::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage_IsValid(value));
3876 set_has_stage();
3877 stage_ = value;
3878 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpWriteBlockProto.stage)
3879}
3880
3881// required uint32 pipelineSize = 5;
3882inline bool OpWriteBlockProto::has_pipelinesize() const {
3883 return (_has_bits_[0] & 0x00000020u) != 0;
3884}
3885inline void OpWriteBlockProto::set_has_pipelinesize() {
3886 _has_bits_[0] |= 0x00000020u;
3887}
3888inline void OpWriteBlockProto::clear_has_pipelinesize() {
3889 _has_bits_[0] &= ~0x00000020u;
3890}
3891inline void OpWriteBlockProto::clear_pipelinesize() {
3892 pipelinesize_ = 0u;
3893 clear_has_pipelinesize();
3894}
3895inline ::google::protobuf::uint32 OpWriteBlockProto::pipelinesize() const {
3896 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.pipelineSize)
3897 return pipelinesize_;
3898}
3899inline void OpWriteBlockProto::set_pipelinesize(::google::protobuf::uint32 value) {
3900 set_has_pipelinesize();
3901 pipelinesize_ = value;
3902 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpWriteBlockProto.pipelineSize)
3903}
3904
3905// required uint64 minBytesRcvd = 6;
3906inline bool OpWriteBlockProto::has_minbytesrcvd() const {
3907 return (_has_bits_[0] & 0x00000040u) != 0;
3908}
3909inline void OpWriteBlockProto::set_has_minbytesrcvd() {
3910 _has_bits_[0] |= 0x00000040u;
3911}
3912inline void OpWriteBlockProto::clear_has_minbytesrcvd() {
3913 _has_bits_[0] &= ~0x00000040u;
3914}
3915inline void OpWriteBlockProto::clear_minbytesrcvd() {
3916 minbytesrcvd_ = GOOGLE_ULONGLONG(0);
3917 clear_has_minbytesrcvd();
3918}
3919inline ::google::protobuf::uint64 OpWriteBlockProto::minbytesrcvd() const {
3920 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.minBytesRcvd)
3921 return minbytesrcvd_;
3922}
3923inline void OpWriteBlockProto::set_minbytesrcvd(::google::protobuf::uint64 value) {
3924 set_has_minbytesrcvd();
3925 minbytesrcvd_ = value;
3926 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpWriteBlockProto.minBytesRcvd)
3927}
3928
3929// required uint64 maxBytesRcvd = 7;
3930inline bool OpWriteBlockProto::has_maxbytesrcvd() const {
3931 return (_has_bits_[0] & 0x00000080u) != 0;
3932}
3933inline void OpWriteBlockProto::set_has_maxbytesrcvd() {
3934 _has_bits_[0] |= 0x00000080u;
3935}
3936inline void OpWriteBlockProto::clear_has_maxbytesrcvd() {
3937 _has_bits_[0] &= ~0x00000080u;
3938}
3939inline void OpWriteBlockProto::clear_maxbytesrcvd() {
3940 maxbytesrcvd_ = GOOGLE_ULONGLONG(0);
3941 clear_has_maxbytesrcvd();
3942}
3943inline ::google::protobuf::uint64 OpWriteBlockProto::maxbytesrcvd() const {
3944 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.maxBytesRcvd)
3945 return maxbytesrcvd_;
3946}
3947inline void OpWriteBlockProto::set_maxbytesrcvd(::google::protobuf::uint64 value) {
3948 set_has_maxbytesrcvd();
3949 maxbytesrcvd_ = value;
3950 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpWriteBlockProto.maxBytesRcvd)
3951}
3952
3953// required uint64 latestGenerationStamp = 8;
3954inline bool OpWriteBlockProto::has_latestgenerationstamp() const {
3955 return (_has_bits_[0] & 0x00000100u) != 0;
3956}
3957inline void OpWriteBlockProto::set_has_latestgenerationstamp() {
3958 _has_bits_[0] |= 0x00000100u;
3959}
3960inline void OpWriteBlockProto::clear_has_latestgenerationstamp() {
3961 _has_bits_[0] &= ~0x00000100u;
3962}
3963inline void OpWriteBlockProto::clear_latestgenerationstamp() {
3964 latestgenerationstamp_ = GOOGLE_ULONGLONG(0);
3965 clear_has_latestgenerationstamp();
3966}
3967inline ::google::protobuf::uint64 OpWriteBlockProto::latestgenerationstamp() const {
3968 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.latestGenerationStamp)
3969 return latestgenerationstamp_;
3970}
3971inline void OpWriteBlockProto::set_latestgenerationstamp(::google::protobuf::uint64 value) {
3972 set_has_latestgenerationstamp();
3973 latestgenerationstamp_ = value;
3974 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpWriteBlockProto.latestGenerationStamp)
3975}
3976
3977// required .Hdfs.Internal.ChecksumProto requestedChecksum = 9;
3978inline bool OpWriteBlockProto::has_requestedchecksum() const {
3979 return (_has_bits_[0] & 0x00000004u) != 0;
3980}
3981inline void OpWriteBlockProto::set_has_requestedchecksum() {
3982 _has_bits_[0] |= 0x00000004u;
3983}
3984inline void OpWriteBlockProto::clear_has_requestedchecksum() {
3985 _has_bits_[0] &= ~0x00000004u;
3986}
3987inline void OpWriteBlockProto::clear_requestedchecksum() {
3988 if (requestedchecksum_ != NULL) requestedchecksum_->Clear();
3989 clear_has_requestedchecksum();
3990}
3991inline const ::Hdfs::Internal::ChecksumProto& OpWriteBlockProto::_internal_requestedchecksum() const {
3992 return *requestedchecksum_;
3993}
3994inline const ::Hdfs::Internal::ChecksumProto& OpWriteBlockProto::requestedchecksum() const {
3995 const ::Hdfs::Internal::ChecksumProto* p = requestedchecksum_;
3996 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.requestedChecksum)
3997 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ChecksumProto*>(
3998 &::Hdfs::Internal::_ChecksumProto_default_instance_);
3999}
4000inline ::Hdfs::Internal::ChecksumProto* OpWriteBlockProto::release_requestedchecksum() {
4001 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpWriteBlockProto.requestedChecksum)
4002 clear_has_requestedchecksum();
4003 ::Hdfs::Internal::ChecksumProto* temp = requestedchecksum_;
4004 requestedchecksum_ = NULL;
4005 return temp;
4006}
4007inline ::Hdfs::Internal::ChecksumProto* OpWriteBlockProto::mutable_requestedchecksum() {
4008 set_has_requestedchecksum();
4009 if (requestedchecksum_ == NULL) {
4010 auto* p = CreateMaybeMessage<::Hdfs::Internal::ChecksumProto>(GetArenaNoVirtual());
4011 requestedchecksum_ = p;
4012 }
4013 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpWriteBlockProto.requestedChecksum)
4014 return requestedchecksum_;
4015}
4016inline void OpWriteBlockProto::set_allocated_requestedchecksum(::Hdfs::Internal::ChecksumProto* requestedchecksum) {
4017 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4018 if (message_arena == NULL) {
4019 delete requestedchecksum_;
4020 }
4021 if (requestedchecksum) {
4022 ::google::protobuf::Arena* submessage_arena = NULL;
4023 if (message_arena != submessage_arena) {
4024 requestedchecksum = ::google::protobuf::internal::GetOwnedMessage(
4025 message_arena, requestedchecksum, submessage_arena);
4026 }
4027 set_has_requestedchecksum();
4028 } else {
4029 clear_has_requestedchecksum();
4030 }
4031 requestedchecksum_ = requestedchecksum;
4032 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpWriteBlockProto.requestedChecksum)
4033}
4034
4035// optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 10;
4036inline bool OpWriteBlockProto::has_cachingstrategy() const {
4037 return (_has_bits_[0] & 0x00000008u) != 0;
4038}
4039inline void OpWriteBlockProto::set_has_cachingstrategy() {
4040 _has_bits_[0] |= 0x00000008u;
4041}
4042inline void OpWriteBlockProto::clear_has_cachingstrategy() {
4043 _has_bits_[0] &= ~0x00000008u;
4044}
4045inline void OpWriteBlockProto::clear_cachingstrategy() {
4046 if (cachingstrategy_ != NULL) cachingstrategy_->Clear();
4047 clear_has_cachingstrategy();
4048}
4049inline const ::Hdfs::Internal::CachingStrategyProto& OpWriteBlockProto::_internal_cachingstrategy() const {
4050 return *cachingstrategy_;
4051}
4052inline const ::Hdfs::Internal::CachingStrategyProto& OpWriteBlockProto::cachingstrategy() const {
4053 const ::Hdfs::Internal::CachingStrategyProto* p = cachingstrategy_;
4054 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpWriteBlockProto.cachingStrategy)
4055 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::CachingStrategyProto*>(
4056 &::Hdfs::Internal::_CachingStrategyProto_default_instance_);
4057}
4058inline ::Hdfs::Internal::CachingStrategyProto* OpWriteBlockProto::release_cachingstrategy() {
4059 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpWriteBlockProto.cachingStrategy)
4060 clear_has_cachingstrategy();
4061 ::Hdfs::Internal::CachingStrategyProto* temp = cachingstrategy_;
4062 cachingstrategy_ = NULL;
4063 return temp;
4064}
4065inline ::Hdfs::Internal::CachingStrategyProto* OpWriteBlockProto::mutable_cachingstrategy() {
4066 set_has_cachingstrategy();
4067 if (cachingstrategy_ == NULL) {
4068 auto* p = CreateMaybeMessage<::Hdfs::Internal::CachingStrategyProto>(GetArenaNoVirtual());
4069 cachingstrategy_ = p;
4070 }
4071 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpWriteBlockProto.cachingStrategy)
4072 return cachingstrategy_;
4073}
4074inline void OpWriteBlockProto::set_allocated_cachingstrategy(::Hdfs::Internal::CachingStrategyProto* cachingstrategy) {
4075 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4076 if (message_arena == NULL) {
4077 delete cachingstrategy_;
4078 }
4079 if (cachingstrategy) {
4080 ::google::protobuf::Arena* submessage_arena = NULL;
4081 if (message_arena != submessage_arena) {
4082 cachingstrategy = ::google::protobuf::internal::GetOwnedMessage(
4083 message_arena, cachingstrategy, submessage_arena);
4084 }
4085 set_has_cachingstrategy();
4086 } else {
4087 clear_has_cachingstrategy();
4088 }
4089 cachingstrategy_ = cachingstrategy;
4090 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpWriteBlockProto.cachingStrategy)
4091}
4092
4093// -------------------------------------------------------------------
4094
4095// OpTransferBlockProto
4096
4097// required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
4098inline bool OpTransferBlockProto::has_header() const {
4099 return (_has_bits_[0] & 0x00000001u) != 0;
4100}
4101inline void OpTransferBlockProto::set_has_header() {
4102 _has_bits_[0] |= 0x00000001u;
4103}
4104inline void OpTransferBlockProto::clear_has_header() {
4105 _has_bits_[0] &= ~0x00000001u;
4106}
4107inline void OpTransferBlockProto::clear_header() {
4108 if (header_ != NULL) header_->Clear();
4109 clear_has_header();
4110}
4111inline const ::Hdfs::Internal::ClientOperationHeaderProto& OpTransferBlockProto::_internal_header() const {
4112 return *header_;
4113}
4114inline const ::Hdfs::Internal::ClientOperationHeaderProto& OpTransferBlockProto::header() const {
4115 const ::Hdfs::Internal::ClientOperationHeaderProto* p = header_;
4116 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpTransferBlockProto.header)
4117 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ClientOperationHeaderProto*>(
4118 &::Hdfs::Internal::_ClientOperationHeaderProto_default_instance_);
4119}
4120inline ::Hdfs::Internal::ClientOperationHeaderProto* OpTransferBlockProto::release_header() {
4121 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpTransferBlockProto.header)
4122 clear_has_header();
4123 ::Hdfs::Internal::ClientOperationHeaderProto* temp = header_;
4124 header_ = NULL;
4125 return temp;
4126}
4127inline ::Hdfs::Internal::ClientOperationHeaderProto* OpTransferBlockProto::mutable_header() {
4128 set_has_header();
4129 if (header_ == NULL) {
4130 auto* p = CreateMaybeMessage<::Hdfs::Internal::ClientOperationHeaderProto>(GetArenaNoVirtual());
4131 header_ = p;
4132 }
4133 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpTransferBlockProto.header)
4134 return header_;
4135}
4136inline void OpTransferBlockProto::set_allocated_header(::Hdfs::Internal::ClientOperationHeaderProto* header) {
4137 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4138 if (message_arena == NULL) {
4139 delete header_;
4140 }
4141 if (header) {
4142 ::google::protobuf::Arena* submessage_arena = NULL;
4143 if (message_arena != submessage_arena) {
4144 header = ::google::protobuf::internal::GetOwnedMessage(
4145 message_arena, header, submessage_arena);
4146 }
4147 set_has_header();
4148 } else {
4149 clear_has_header();
4150 }
4151 header_ = header;
4152 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpTransferBlockProto.header)
4153}
4154
4155// repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
4156inline int OpTransferBlockProto::targets_size() const {
4157 return targets_.size();
4158}
4159inline ::Hdfs::Internal::DatanodeInfoProto* OpTransferBlockProto::mutable_targets(int index) {
4160 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpTransferBlockProto.targets)
4161 return targets_.Mutable(index);
4162}
4163inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >*
4164OpTransferBlockProto::mutable_targets() {
4165 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.OpTransferBlockProto.targets)
4166 return &targets_;
4167}
4168inline const ::Hdfs::Internal::DatanodeInfoProto& OpTransferBlockProto::targets(int index) const {
4169 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpTransferBlockProto.targets)
4170 return targets_.Get(index);
4171}
4172inline ::Hdfs::Internal::DatanodeInfoProto* OpTransferBlockProto::add_targets() {
4173 // @@protoc_insertion_point(field_add:Hdfs.Internal.OpTransferBlockProto.targets)
4174 return targets_.Add();
4175}
4176inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::DatanodeInfoProto >&
4177OpTransferBlockProto::targets() const {
4178 // @@protoc_insertion_point(field_list:Hdfs.Internal.OpTransferBlockProto.targets)
4179 return targets_;
4180}
4181
4182// -------------------------------------------------------------------
4183
4184// OpReplaceBlockProto
4185
4186// required .Hdfs.Internal.BaseHeaderProto header = 1;
4187inline bool OpReplaceBlockProto::has_header() const {
4188 return (_has_bits_[0] & 0x00000002u) != 0;
4189}
4190inline void OpReplaceBlockProto::set_has_header() {
4191 _has_bits_[0] |= 0x00000002u;
4192}
4193inline void OpReplaceBlockProto::clear_has_header() {
4194 _has_bits_[0] &= ~0x00000002u;
4195}
4196inline void OpReplaceBlockProto::clear_header() {
4197 if (header_ != NULL) header_->Clear();
4198 clear_has_header();
4199}
4200inline const ::Hdfs::Internal::BaseHeaderProto& OpReplaceBlockProto::_internal_header() const {
4201 return *header_;
4202}
4203inline const ::Hdfs::Internal::BaseHeaderProto& OpReplaceBlockProto::header() const {
4204 const ::Hdfs::Internal::BaseHeaderProto* p = header_;
4205 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpReplaceBlockProto.header)
4206 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::BaseHeaderProto*>(
4207 &::Hdfs::Internal::_BaseHeaderProto_default_instance_);
4208}
4209inline ::Hdfs::Internal::BaseHeaderProto* OpReplaceBlockProto::release_header() {
4210 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpReplaceBlockProto.header)
4211 clear_has_header();
4212 ::Hdfs::Internal::BaseHeaderProto* temp = header_;
4213 header_ = NULL;
4214 return temp;
4215}
4216inline ::Hdfs::Internal::BaseHeaderProto* OpReplaceBlockProto::mutable_header() {
4217 set_has_header();
4218 if (header_ == NULL) {
4219 auto* p = CreateMaybeMessage<::Hdfs::Internal::BaseHeaderProto>(GetArenaNoVirtual());
4220 header_ = p;
4221 }
4222 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpReplaceBlockProto.header)
4223 return header_;
4224}
4225inline void OpReplaceBlockProto::set_allocated_header(::Hdfs::Internal::BaseHeaderProto* header) {
4226 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4227 if (message_arena == NULL) {
4228 delete header_;
4229 }
4230 if (header) {
4231 ::google::protobuf::Arena* submessage_arena = NULL;
4232 if (message_arena != submessage_arena) {
4233 header = ::google::protobuf::internal::GetOwnedMessage(
4234 message_arena, header, submessage_arena);
4235 }
4236 set_has_header();
4237 } else {
4238 clear_has_header();
4239 }
4240 header_ = header;
4241 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpReplaceBlockProto.header)
4242}
4243
4244// required string delHint = 2;
4245inline bool OpReplaceBlockProto::has_delhint() const {
4246 return (_has_bits_[0] & 0x00000001u) != 0;
4247}
4248inline void OpReplaceBlockProto::set_has_delhint() {
4249 _has_bits_[0] |= 0x00000001u;
4250}
4251inline void OpReplaceBlockProto::clear_has_delhint() {
4252 _has_bits_[0] &= ~0x00000001u;
4253}
4254inline void OpReplaceBlockProto::clear_delhint() {
4255 delhint_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4256 clear_has_delhint();
4257}
4258inline const ::std::string& OpReplaceBlockProto::delhint() const {
4259 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpReplaceBlockProto.delHint)
4260 return delhint_.GetNoArena();
4261}
4262inline void OpReplaceBlockProto::set_delhint(const ::std::string& value) {
4263 set_has_delhint();
4264 delhint_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4265 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpReplaceBlockProto.delHint)
4266}
4267#if LANG_CXX11
4268inline void OpReplaceBlockProto::set_delhint(::std::string&& value) {
4269 set_has_delhint();
4270 delhint_.SetNoArena(
4271 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4272 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.OpReplaceBlockProto.delHint)
4273}
4274#endif
4275inline void OpReplaceBlockProto::set_delhint(const char* value) {
4276 GOOGLE_DCHECK(value != NULL);
4277 set_has_delhint();
4278 delhint_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4279 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.OpReplaceBlockProto.delHint)
4280}
4281inline void OpReplaceBlockProto::set_delhint(const char* value, size_t size) {
4282 set_has_delhint();
4283 delhint_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4284 ::std::string(reinterpret_cast<const char*>(value), size));
4285 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.OpReplaceBlockProto.delHint)
4286}
4287inline ::std::string* OpReplaceBlockProto::mutable_delhint() {
4288 set_has_delhint();
4289 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpReplaceBlockProto.delHint)
4290 return delhint_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4291}
4292inline ::std::string* OpReplaceBlockProto::release_delhint() {
4293 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpReplaceBlockProto.delHint)
4294 if (!has_delhint()) {
4295 return NULL;
4296 }
4297 clear_has_delhint();
4298 return delhint_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4299}
4300inline void OpReplaceBlockProto::set_allocated_delhint(::std::string* delhint) {
4301 if (delhint != NULL) {
4302 set_has_delhint();
4303 } else {
4304 clear_has_delhint();
4305 }
4306 delhint_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), delhint);
4307 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpReplaceBlockProto.delHint)
4308}
4309
4310// required .Hdfs.Internal.DatanodeInfoProto source = 3;
4311inline bool OpReplaceBlockProto::has_source() const {
4312 return (_has_bits_[0] & 0x00000004u) != 0;
4313}
4314inline void OpReplaceBlockProto::set_has_source() {
4315 _has_bits_[0] |= 0x00000004u;
4316}
4317inline void OpReplaceBlockProto::clear_has_source() {
4318 _has_bits_[0] &= ~0x00000004u;
4319}
4320inline const ::Hdfs::Internal::DatanodeInfoProto& OpReplaceBlockProto::_internal_source() const {
4321 return *source_;
4322}
4323inline const ::Hdfs::Internal::DatanodeInfoProto& OpReplaceBlockProto::source() const {
4324 const ::Hdfs::Internal::DatanodeInfoProto* p = source_;
4325 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpReplaceBlockProto.source)
4326 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::DatanodeInfoProto*>(
4327 &::Hdfs::Internal::_DatanodeInfoProto_default_instance_);
4328}
4329inline ::Hdfs::Internal::DatanodeInfoProto* OpReplaceBlockProto::release_source() {
4330 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpReplaceBlockProto.source)
4331 clear_has_source();
4332 ::Hdfs::Internal::DatanodeInfoProto* temp = source_;
4333 source_ = NULL;
4334 return temp;
4335}
4336inline ::Hdfs::Internal::DatanodeInfoProto* OpReplaceBlockProto::mutable_source() {
4337 set_has_source();
4338 if (source_ == NULL) {
4339 auto* p = CreateMaybeMessage<::Hdfs::Internal::DatanodeInfoProto>(GetArenaNoVirtual());
4340 source_ = p;
4341 }
4342 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpReplaceBlockProto.source)
4343 return source_;
4344}
4345inline void OpReplaceBlockProto::set_allocated_source(::Hdfs::Internal::DatanodeInfoProto* source) {
4346 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4347 if (message_arena == NULL) {
4348 delete reinterpret_cast< ::google::protobuf::MessageLite*>(source_);
4349 }
4350 if (source) {
4351 ::google::protobuf::Arena* submessage_arena = NULL;
4352 if (message_arena != submessage_arena) {
4353 source = ::google::protobuf::internal::GetOwnedMessage(
4354 message_arena, source, submessage_arena);
4355 }
4356 set_has_source();
4357 } else {
4358 clear_has_source();
4359 }
4360 source_ = source;
4361 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpReplaceBlockProto.source)
4362}
4363
4364// -------------------------------------------------------------------
4365
4366// OpCopyBlockProto
4367
4368// required .Hdfs.Internal.BaseHeaderProto header = 1;
4369inline bool OpCopyBlockProto::has_header() const {
4370 return (_has_bits_[0] & 0x00000001u) != 0;
4371}
4372inline void OpCopyBlockProto::set_has_header() {
4373 _has_bits_[0] |= 0x00000001u;
4374}
4375inline void OpCopyBlockProto::clear_has_header() {
4376 _has_bits_[0] &= ~0x00000001u;
4377}
4378inline void OpCopyBlockProto::clear_header() {
4379 if (header_ != NULL) header_->Clear();
4380 clear_has_header();
4381}
4382inline const ::Hdfs::Internal::BaseHeaderProto& OpCopyBlockProto::_internal_header() const {
4383 return *header_;
4384}
4385inline const ::Hdfs::Internal::BaseHeaderProto& OpCopyBlockProto::header() const {
4386 const ::Hdfs::Internal::BaseHeaderProto* p = header_;
4387 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpCopyBlockProto.header)
4388 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::BaseHeaderProto*>(
4389 &::Hdfs::Internal::_BaseHeaderProto_default_instance_);
4390}
4391inline ::Hdfs::Internal::BaseHeaderProto* OpCopyBlockProto::release_header() {
4392 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpCopyBlockProto.header)
4393 clear_has_header();
4394 ::Hdfs::Internal::BaseHeaderProto* temp = header_;
4395 header_ = NULL;
4396 return temp;
4397}
4398inline ::Hdfs::Internal::BaseHeaderProto* OpCopyBlockProto::mutable_header() {
4399 set_has_header();
4400 if (header_ == NULL) {
4401 auto* p = CreateMaybeMessage<::Hdfs::Internal::BaseHeaderProto>(GetArenaNoVirtual());
4402 header_ = p;
4403 }
4404 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpCopyBlockProto.header)
4405 return header_;
4406}
4407inline void OpCopyBlockProto::set_allocated_header(::Hdfs::Internal::BaseHeaderProto* header) {
4408 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4409 if (message_arena == NULL) {
4410 delete header_;
4411 }
4412 if (header) {
4413 ::google::protobuf::Arena* submessage_arena = NULL;
4414 if (message_arena != submessage_arena) {
4415 header = ::google::protobuf::internal::GetOwnedMessage(
4416 message_arena, header, submessage_arena);
4417 }
4418 set_has_header();
4419 } else {
4420 clear_has_header();
4421 }
4422 header_ = header;
4423 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpCopyBlockProto.header)
4424}
4425
4426// -------------------------------------------------------------------
4427
4428// OpBlockChecksumProto
4429
4430// required .Hdfs.Internal.BaseHeaderProto header = 1;
4431inline bool OpBlockChecksumProto::has_header() const {
4432 return (_has_bits_[0] & 0x00000001u) != 0;
4433}
4434inline void OpBlockChecksumProto::set_has_header() {
4435 _has_bits_[0] |= 0x00000001u;
4436}
4437inline void OpBlockChecksumProto::clear_has_header() {
4438 _has_bits_[0] &= ~0x00000001u;
4439}
4440inline void OpBlockChecksumProto::clear_header() {
4441 if (header_ != NULL) header_->Clear();
4442 clear_has_header();
4443}
4444inline const ::Hdfs::Internal::BaseHeaderProto& OpBlockChecksumProto::_internal_header() const {
4445 return *header_;
4446}
4447inline const ::Hdfs::Internal::BaseHeaderProto& OpBlockChecksumProto::header() const {
4448 const ::Hdfs::Internal::BaseHeaderProto* p = header_;
4449 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpBlockChecksumProto.header)
4450 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::BaseHeaderProto*>(
4451 &::Hdfs::Internal::_BaseHeaderProto_default_instance_);
4452}
4453inline ::Hdfs::Internal::BaseHeaderProto* OpBlockChecksumProto::release_header() {
4454 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpBlockChecksumProto.header)
4455 clear_has_header();
4456 ::Hdfs::Internal::BaseHeaderProto* temp = header_;
4457 header_ = NULL;
4458 return temp;
4459}
4460inline ::Hdfs::Internal::BaseHeaderProto* OpBlockChecksumProto::mutable_header() {
4461 set_has_header();
4462 if (header_ == NULL) {
4463 auto* p = CreateMaybeMessage<::Hdfs::Internal::BaseHeaderProto>(GetArenaNoVirtual());
4464 header_ = p;
4465 }
4466 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpBlockChecksumProto.header)
4467 return header_;
4468}
4469inline void OpBlockChecksumProto::set_allocated_header(::Hdfs::Internal::BaseHeaderProto* header) {
4470 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4471 if (message_arena == NULL) {
4472 delete header_;
4473 }
4474 if (header) {
4475 ::google::protobuf::Arena* submessage_arena = NULL;
4476 if (message_arena != submessage_arena) {
4477 header = ::google::protobuf::internal::GetOwnedMessage(
4478 message_arena, header, submessage_arena);
4479 }
4480 set_has_header();
4481 } else {
4482 clear_has_header();
4483 }
4484 header_ = header;
4485 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpBlockChecksumProto.header)
4486}
4487
4488// -------------------------------------------------------------------
4489
4490// OpRequestShortCircuitAccessProto
4491
4492// required .Hdfs.Internal.BaseHeaderProto header = 1;
4493inline bool OpRequestShortCircuitAccessProto::has_header() const {
4494 return (_has_bits_[0] & 0x00000001u) != 0;
4495}
4496inline void OpRequestShortCircuitAccessProto::set_has_header() {
4497 _has_bits_[0] |= 0x00000001u;
4498}
4499inline void OpRequestShortCircuitAccessProto::clear_has_header() {
4500 _has_bits_[0] &= ~0x00000001u;
4501}
4502inline void OpRequestShortCircuitAccessProto::clear_header() {
4503 if (header_ != NULL) header_->Clear();
4504 clear_has_header();
4505}
4506inline const ::Hdfs::Internal::BaseHeaderProto& OpRequestShortCircuitAccessProto::_internal_header() const {
4507 return *header_;
4508}
4509inline const ::Hdfs::Internal::BaseHeaderProto& OpRequestShortCircuitAccessProto::header() const {
4510 const ::Hdfs::Internal::BaseHeaderProto* p = header_;
4511 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpRequestShortCircuitAccessProto.header)
4512 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::BaseHeaderProto*>(
4513 &::Hdfs::Internal::_BaseHeaderProto_default_instance_);
4514}
4515inline ::Hdfs::Internal::BaseHeaderProto* OpRequestShortCircuitAccessProto::release_header() {
4516 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpRequestShortCircuitAccessProto.header)
4517 clear_has_header();
4518 ::Hdfs::Internal::BaseHeaderProto* temp = header_;
4519 header_ = NULL;
4520 return temp;
4521}
4522inline ::Hdfs::Internal::BaseHeaderProto* OpRequestShortCircuitAccessProto::mutable_header() {
4523 set_has_header();
4524 if (header_ == NULL) {
4525 auto* p = CreateMaybeMessage<::Hdfs::Internal::BaseHeaderProto>(GetArenaNoVirtual());
4526 header_ = p;
4527 }
4528 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpRequestShortCircuitAccessProto.header)
4529 return header_;
4530}
4531inline void OpRequestShortCircuitAccessProto::set_allocated_header(::Hdfs::Internal::BaseHeaderProto* header) {
4532 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4533 if (message_arena == NULL) {
4534 delete header_;
4535 }
4536 if (header) {
4537 ::google::protobuf::Arena* submessage_arena = NULL;
4538 if (message_arena != submessage_arena) {
4539 header = ::google::protobuf::internal::GetOwnedMessage(
4540 message_arena, header, submessage_arena);
4541 }
4542 set_has_header();
4543 } else {
4544 clear_has_header();
4545 }
4546 header_ = header;
4547 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpRequestShortCircuitAccessProto.header)
4548}
4549
4550// required uint32 maxVersion = 2;
4551inline bool OpRequestShortCircuitAccessProto::has_maxversion() const {
4552 return (_has_bits_[0] & 0x00000002u) != 0;
4553}
4554inline void OpRequestShortCircuitAccessProto::set_has_maxversion() {
4555 _has_bits_[0] |= 0x00000002u;
4556}
4557inline void OpRequestShortCircuitAccessProto::clear_has_maxversion() {
4558 _has_bits_[0] &= ~0x00000002u;
4559}
4560inline void OpRequestShortCircuitAccessProto::clear_maxversion() {
4561 maxversion_ = 0u;
4562 clear_has_maxversion();
4563}
4564inline ::google::protobuf::uint32 OpRequestShortCircuitAccessProto::maxversion() const {
4565 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpRequestShortCircuitAccessProto.maxVersion)
4566 return maxversion_;
4567}
4568inline void OpRequestShortCircuitAccessProto::set_maxversion(::google::protobuf::uint32 value) {
4569 set_has_maxversion();
4570 maxversion_ = value;
4571 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpRequestShortCircuitAccessProto.maxVersion)
4572}
4573
4574// -------------------------------------------------------------------
4575
4576// PacketHeaderProto
4577
4578// required sfixed64 offsetInBlock = 1;
4579inline bool PacketHeaderProto::has_offsetinblock() const {
4580 return (_has_bits_[0] & 0x00000001u) != 0;
4581}
4582inline void PacketHeaderProto::set_has_offsetinblock() {
4583 _has_bits_[0] |= 0x00000001u;
4584}
4585inline void PacketHeaderProto::clear_has_offsetinblock() {
4586 _has_bits_[0] &= ~0x00000001u;
4587}
4588inline void PacketHeaderProto::clear_offsetinblock() {
4589 offsetinblock_ = GOOGLE_LONGLONG(0);
4590 clear_has_offsetinblock();
4591}
4592inline ::google::protobuf::int64 PacketHeaderProto::offsetinblock() const {
4593 // @@protoc_insertion_point(field_get:Hdfs.Internal.PacketHeaderProto.offsetInBlock)
4594 return offsetinblock_;
4595}
4596inline void PacketHeaderProto::set_offsetinblock(::google::protobuf::int64 value) {
4597 set_has_offsetinblock();
4598 offsetinblock_ = value;
4599 // @@protoc_insertion_point(field_set:Hdfs.Internal.PacketHeaderProto.offsetInBlock)
4600}
4601
4602// required sfixed64 seqno = 2;
4603inline bool PacketHeaderProto::has_seqno() const {
4604 return (_has_bits_[0] & 0x00000002u) != 0;
4605}
4606inline void PacketHeaderProto::set_has_seqno() {
4607 _has_bits_[0] |= 0x00000002u;
4608}
4609inline void PacketHeaderProto::clear_has_seqno() {
4610 _has_bits_[0] &= ~0x00000002u;
4611}
4612inline void PacketHeaderProto::clear_seqno() {
4613 seqno_ = GOOGLE_LONGLONG(0);
4614 clear_has_seqno();
4615}
4616inline ::google::protobuf::int64 PacketHeaderProto::seqno() const {
4617 // @@protoc_insertion_point(field_get:Hdfs.Internal.PacketHeaderProto.seqno)
4618 return seqno_;
4619}
4620inline void PacketHeaderProto::set_seqno(::google::protobuf::int64 value) {
4621 set_has_seqno();
4622 seqno_ = value;
4623 // @@protoc_insertion_point(field_set:Hdfs.Internal.PacketHeaderProto.seqno)
4624}
4625
4626// required bool lastPacketInBlock = 3;
4627inline bool PacketHeaderProto::has_lastpacketinblock() const {
4628 return (_has_bits_[0] & 0x00000008u) != 0;
4629}
4630inline void PacketHeaderProto::set_has_lastpacketinblock() {
4631 _has_bits_[0] |= 0x00000008u;
4632}
4633inline void PacketHeaderProto::clear_has_lastpacketinblock() {
4634 _has_bits_[0] &= ~0x00000008u;
4635}
4636inline void PacketHeaderProto::clear_lastpacketinblock() {
4637 lastpacketinblock_ = false;
4638 clear_has_lastpacketinblock();
4639}
4640inline bool PacketHeaderProto::lastpacketinblock() const {
4641 // @@protoc_insertion_point(field_get:Hdfs.Internal.PacketHeaderProto.lastPacketInBlock)
4642 return lastpacketinblock_;
4643}
4644inline void PacketHeaderProto::set_lastpacketinblock(bool value) {
4645 set_has_lastpacketinblock();
4646 lastpacketinblock_ = value;
4647 // @@protoc_insertion_point(field_set:Hdfs.Internal.PacketHeaderProto.lastPacketInBlock)
4648}
4649
4650// required sfixed32 dataLen = 4;
4651inline bool PacketHeaderProto::has_datalen() const {
4652 return (_has_bits_[0] & 0x00000004u) != 0;
4653}
4654inline void PacketHeaderProto::set_has_datalen() {
4655 _has_bits_[0] |= 0x00000004u;
4656}
4657inline void PacketHeaderProto::clear_has_datalen() {
4658 _has_bits_[0] &= ~0x00000004u;
4659}
4660inline void PacketHeaderProto::clear_datalen() {
4661 datalen_ = 0;
4662 clear_has_datalen();
4663}
4664inline ::google::protobuf::int32 PacketHeaderProto::datalen() const {
4665 // @@protoc_insertion_point(field_get:Hdfs.Internal.PacketHeaderProto.dataLen)
4666 return datalen_;
4667}
4668inline void PacketHeaderProto::set_datalen(::google::protobuf::int32 value) {
4669 set_has_datalen();
4670 datalen_ = value;
4671 // @@protoc_insertion_point(field_set:Hdfs.Internal.PacketHeaderProto.dataLen)
4672}
4673
4674// optional bool syncBlock = 5 [default = false];
4675inline bool PacketHeaderProto::has_syncblock() const {
4676 return (_has_bits_[0] & 0x00000010u) != 0;
4677}
4678inline void PacketHeaderProto::set_has_syncblock() {
4679 _has_bits_[0] |= 0x00000010u;
4680}
4681inline void PacketHeaderProto::clear_has_syncblock() {
4682 _has_bits_[0] &= ~0x00000010u;
4683}
4684inline void PacketHeaderProto::clear_syncblock() {
4685 syncblock_ = false;
4686 clear_has_syncblock();
4687}
4688inline bool PacketHeaderProto::syncblock() const {
4689 // @@protoc_insertion_point(field_get:Hdfs.Internal.PacketHeaderProto.syncBlock)
4690 return syncblock_;
4691}
4692inline void PacketHeaderProto::set_syncblock(bool value) {
4693 set_has_syncblock();
4694 syncblock_ = value;
4695 // @@protoc_insertion_point(field_set:Hdfs.Internal.PacketHeaderProto.syncBlock)
4696}
4697
4698// -------------------------------------------------------------------
4699
4700// PipelineAckProto
4701
4702// required sint64 seqno = 1;
4703inline bool PipelineAckProto::has_seqno() const {
4704 return (_has_bits_[0] & 0x00000001u) != 0;
4705}
4706inline void PipelineAckProto::set_has_seqno() {
4707 _has_bits_[0] |= 0x00000001u;
4708}
4709inline void PipelineAckProto::clear_has_seqno() {
4710 _has_bits_[0] &= ~0x00000001u;
4711}
4712inline void PipelineAckProto::clear_seqno() {
4713 seqno_ = GOOGLE_LONGLONG(0);
4714 clear_has_seqno();
4715}
4716inline ::google::protobuf::int64 PipelineAckProto::seqno() const {
4717 // @@protoc_insertion_point(field_get:Hdfs.Internal.PipelineAckProto.seqno)
4718 return seqno_;
4719}
4720inline void PipelineAckProto::set_seqno(::google::protobuf::int64 value) {
4721 set_has_seqno();
4722 seqno_ = value;
4723 // @@protoc_insertion_point(field_set:Hdfs.Internal.PipelineAckProto.seqno)
4724}
4725
4726// repeated .Hdfs.Internal.Status status = 2;
4727inline int PipelineAckProto::status_size() const {
4728 return status_.size();
4729}
4730inline void PipelineAckProto::clear_status() {
4731 status_.Clear();
4732}
4733inline ::Hdfs::Internal::Status PipelineAckProto::status(int index) const {
4734 // @@protoc_insertion_point(field_get:Hdfs.Internal.PipelineAckProto.status)
4735 return static_cast< ::Hdfs::Internal::Status >(status_.Get(index));
4736}
4737inline void PipelineAckProto::set_status(int index, ::Hdfs::Internal::Status value) {
4738 assert(::Hdfs::Internal::Status_IsValid(value));
4739 status_.Set(index, value);
4740 // @@protoc_insertion_point(field_set:Hdfs.Internal.PipelineAckProto.status)
4741}
4742inline void PipelineAckProto::add_status(::Hdfs::Internal::Status value) {
4743 assert(::Hdfs::Internal::Status_IsValid(value));
4744 status_.Add(value);
4745 // @@protoc_insertion_point(field_add:Hdfs.Internal.PipelineAckProto.status)
4746}
4747inline const ::google::protobuf::RepeatedField<int>&
4748PipelineAckProto::status() const {
4749 // @@protoc_insertion_point(field_list:Hdfs.Internal.PipelineAckProto.status)
4750 return status_;
4751}
4752inline ::google::protobuf::RepeatedField<int>*
4753PipelineAckProto::mutable_status() {
4754 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.PipelineAckProto.status)
4755 return &status_;
4756}
4757
4758// optional uint64 downstreamAckTimeNanos = 3 [default = 0];
4759inline bool PipelineAckProto::has_downstreamacktimenanos() const {
4760 return (_has_bits_[0] & 0x00000002u) != 0;
4761}
4762inline void PipelineAckProto::set_has_downstreamacktimenanos() {
4763 _has_bits_[0] |= 0x00000002u;
4764}
4765inline void PipelineAckProto::clear_has_downstreamacktimenanos() {
4766 _has_bits_[0] &= ~0x00000002u;
4767}
4768inline void PipelineAckProto::clear_downstreamacktimenanos() {
4769 downstreamacktimenanos_ = GOOGLE_ULONGLONG(0);
4770 clear_has_downstreamacktimenanos();
4771}
4772inline ::google::protobuf::uint64 PipelineAckProto::downstreamacktimenanos() const {
4773 // @@protoc_insertion_point(field_get:Hdfs.Internal.PipelineAckProto.downstreamAckTimeNanos)
4774 return downstreamacktimenanos_;
4775}
4776inline void PipelineAckProto::set_downstreamacktimenanos(::google::protobuf::uint64 value) {
4777 set_has_downstreamacktimenanos();
4778 downstreamacktimenanos_ = value;
4779 // @@protoc_insertion_point(field_set:Hdfs.Internal.PipelineAckProto.downstreamAckTimeNanos)
4780}
4781
4782// -------------------------------------------------------------------
4783
4784// ReadOpChecksumInfoProto
4785
4786// required .Hdfs.Internal.ChecksumProto checksum = 1;
4787inline bool ReadOpChecksumInfoProto::has_checksum() const {
4788 return (_has_bits_[0] & 0x00000001u) != 0;
4789}
4790inline void ReadOpChecksumInfoProto::set_has_checksum() {
4791 _has_bits_[0] |= 0x00000001u;
4792}
4793inline void ReadOpChecksumInfoProto::clear_has_checksum() {
4794 _has_bits_[0] &= ~0x00000001u;
4795}
4796inline void ReadOpChecksumInfoProto::clear_checksum() {
4797 if (checksum_ != NULL) checksum_->Clear();
4798 clear_has_checksum();
4799}
4800inline const ::Hdfs::Internal::ChecksumProto& ReadOpChecksumInfoProto::_internal_checksum() const {
4801 return *checksum_;
4802}
4803inline const ::Hdfs::Internal::ChecksumProto& ReadOpChecksumInfoProto::checksum() const {
4804 const ::Hdfs::Internal::ChecksumProto* p = checksum_;
4805 // @@protoc_insertion_point(field_get:Hdfs.Internal.ReadOpChecksumInfoProto.checksum)
4806 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ChecksumProto*>(
4807 &::Hdfs::Internal::_ChecksumProto_default_instance_);
4808}
4809inline ::Hdfs::Internal::ChecksumProto* ReadOpChecksumInfoProto::release_checksum() {
4810 // @@protoc_insertion_point(field_release:Hdfs.Internal.ReadOpChecksumInfoProto.checksum)
4811 clear_has_checksum();
4812 ::Hdfs::Internal::ChecksumProto* temp = checksum_;
4813 checksum_ = NULL;
4814 return temp;
4815}
4816inline ::Hdfs::Internal::ChecksumProto* ReadOpChecksumInfoProto::mutable_checksum() {
4817 set_has_checksum();
4818 if (checksum_ == NULL) {
4819 auto* p = CreateMaybeMessage<::Hdfs::Internal::ChecksumProto>(GetArenaNoVirtual());
4820 checksum_ = p;
4821 }
4822 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.ReadOpChecksumInfoProto.checksum)
4823 return checksum_;
4824}
4825inline void ReadOpChecksumInfoProto::set_allocated_checksum(::Hdfs::Internal::ChecksumProto* checksum) {
4826 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4827 if (message_arena == NULL) {
4828 delete checksum_;
4829 }
4830 if (checksum) {
4831 ::google::protobuf::Arena* submessage_arena = NULL;
4832 if (message_arena != submessage_arena) {
4833 checksum = ::google::protobuf::internal::GetOwnedMessage(
4834 message_arena, checksum, submessage_arena);
4835 }
4836 set_has_checksum();
4837 } else {
4838 clear_has_checksum();
4839 }
4840 checksum_ = checksum;
4841 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.ReadOpChecksumInfoProto.checksum)
4842}
4843
4844// required uint64 chunkOffset = 2;
4845inline bool ReadOpChecksumInfoProto::has_chunkoffset() const {
4846 return (_has_bits_[0] & 0x00000002u) != 0;
4847}
4848inline void ReadOpChecksumInfoProto::set_has_chunkoffset() {
4849 _has_bits_[0] |= 0x00000002u;
4850}
4851inline void ReadOpChecksumInfoProto::clear_has_chunkoffset() {
4852 _has_bits_[0] &= ~0x00000002u;
4853}
4854inline void ReadOpChecksumInfoProto::clear_chunkoffset() {
4855 chunkoffset_ = GOOGLE_ULONGLONG(0);
4856 clear_has_chunkoffset();
4857}
4858inline ::google::protobuf::uint64 ReadOpChecksumInfoProto::chunkoffset() const {
4859 // @@protoc_insertion_point(field_get:Hdfs.Internal.ReadOpChecksumInfoProto.chunkOffset)
4860 return chunkoffset_;
4861}
4862inline void ReadOpChecksumInfoProto::set_chunkoffset(::google::protobuf::uint64 value) {
4863 set_has_chunkoffset();
4864 chunkoffset_ = value;
4865 // @@protoc_insertion_point(field_set:Hdfs.Internal.ReadOpChecksumInfoProto.chunkOffset)
4866}
4867
4868// -------------------------------------------------------------------
4869
4870// BlockOpResponseProto
4871
4872// required .Hdfs.Internal.Status status = 1;
4873inline bool BlockOpResponseProto::has_status() const {
4874 return (_has_bits_[0] & 0x00000010u) != 0;
4875}
4876inline void BlockOpResponseProto::set_has_status() {
4877 _has_bits_[0] |= 0x00000010u;
4878}
4879inline void BlockOpResponseProto::clear_has_status() {
4880 _has_bits_[0] &= ~0x00000010u;
4881}
4882inline void BlockOpResponseProto::clear_status() {
4883 status_ = 0;
4884 clear_has_status();
4885}
4886inline ::Hdfs::Internal::Status BlockOpResponseProto::status() const {
4887 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockOpResponseProto.status)
4888 return static_cast< ::Hdfs::Internal::Status >(status_);
4889}
4890inline void BlockOpResponseProto::set_status(::Hdfs::Internal::Status value) {
4891 assert(::Hdfs::Internal::Status_IsValid(value));
4892 set_has_status();
4893 status_ = value;
4894 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockOpResponseProto.status)
4895}
4896
4897// optional string firstBadLink = 2;
4898inline bool BlockOpResponseProto::has_firstbadlink() const {
4899 return (_has_bits_[0] & 0x00000001u) != 0;
4900}
4901inline void BlockOpResponseProto::set_has_firstbadlink() {
4902 _has_bits_[0] |= 0x00000001u;
4903}
4904inline void BlockOpResponseProto::clear_has_firstbadlink() {
4905 _has_bits_[0] &= ~0x00000001u;
4906}
4907inline void BlockOpResponseProto::clear_firstbadlink() {
4908 firstbadlink_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4909 clear_has_firstbadlink();
4910}
4911inline const ::std::string& BlockOpResponseProto::firstbadlink() const {
4912 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockOpResponseProto.firstBadLink)
4913 return firstbadlink_.GetNoArena();
4914}
4915inline void BlockOpResponseProto::set_firstbadlink(const ::std::string& value) {
4916 set_has_firstbadlink();
4917 firstbadlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4918 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockOpResponseProto.firstBadLink)
4919}
4920#if LANG_CXX11
4921inline void BlockOpResponseProto::set_firstbadlink(::std::string&& value) {
4922 set_has_firstbadlink();
4923 firstbadlink_.SetNoArena(
4924 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4925 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.BlockOpResponseProto.firstBadLink)
4926}
4927#endif
4928inline void BlockOpResponseProto::set_firstbadlink(const char* value) {
4929 GOOGLE_DCHECK(value != NULL);
4930 set_has_firstbadlink();
4931 firstbadlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4932 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.BlockOpResponseProto.firstBadLink)
4933}
4934inline void BlockOpResponseProto::set_firstbadlink(const char* value, size_t size) {
4935 set_has_firstbadlink();
4936 firstbadlink_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4937 ::std::string(reinterpret_cast<const char*>(value), size));
4938 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.BlockOpResponseProto.firstBadLink)
4939}
4940inline ::std::string* BlockOpResponseProto::mutable_firstbadlink() {
4941 set_has_firstbadlink();
4942 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlockOpResponseProto.firstBadLink)
4943 return firstbadlink_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4944}
4945inline ::std::string* BlockOpResponseProto::release_firstbadlink() {
4946 // @@protoc_insertion_point(field_release:Hdfs.Internal.BlockOpResponseProto.firstBadLink)
4947 if (!has_firstbadlink()) {
4948 return NULL;
4949 }
4950 clear_has_firstbadlink();
4951 return firstbadlink_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4952}
4953inline void BlockOpResponseProto::set_allocated_firstbadlink(::std::string* firstbadlink) {
4954 if (firstbadlink != NULL) {
4955 set_has_firstbadlink();
4956 } else {
4957 clear_has_firstbadlink();
4958 }
4959 firstbadlink_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), firstbadlink);
4960 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.BlockOpResponseProto.firstBadLink)
4961}
4962
4963// optional .Hdfs.Internal.OpBlockChecksumResponseProto checksumResponse = 3;
4964inline bool BlockOpResponseProto::has_checksumresponse() const {
4965 return (_has_bits_[0] & 0x00000004u) != 0;
4966}
4967inline void BlockOpResponseProto::set_has_checksumresponse() {
4968 _has_bits_[0] |= 0x00000004u;
4969}
4970inline void BlockOpResponseProto::clear_has_checksumresponse() {
4971 _has_bits_[0] &= ~0x00000004u;
4972}
4973inline void BlockOpResponseProto::clear_checksumresponse() {
4974 if (checksumresponse_ != NULL) checksumresponse_->Clear();
4975 clear_has_checksumresponse();
4976}
4977inline const ::Hdfs::Internal::OpBlockChecksumResponseProto& BlockOpResponseProto::_internal_checksumresponse() const {
4978 return *checksumresponse_;
4979}
4980inline const ::Hdfs::Internal::OpBlockChecksumResponseProto& BlockOpResponseProto::checksumresponse() const {
4981 const ::Hdfs::Internal::OpBlockChecksumResponseProto* p = checksumresponse_;
4982 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockOpResponseProto.checksumResponse)
4983 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::OpBlockChecksumResponseProto*>(
4984 &::Hdfs::Internal::_OpBlockChecksumResponseProto_default_instance_);
4985}
4986inline ::Hdfs::Internal::OpBlockChecksumResponseProto* BlockOpResponseProto::release_checksumresponse() {
4987 // @@protoc_insertion_point(field_release:Hdfs.Internal.BlockOpResponseProto.checksumResponse)
4988 clear_has_checksumresponse();
4989 ::Hdfs::Internal::OpBlockChecksumResponseProto* temp = checksumresponse_;
4990 checksumresponse_ = NULL;
4991 return temp;
4992}
4993inline ::Hdfs::Internal::OpBlockChecksumResponseProto* BlockOpResponseProto::mutable_checksumresponse() {
4994 set_has_checksumresponse();
4995 if (checksumresponse_ == NULL) {
4996 auto* p = CreateMaybeMessage<::Hdfs::Internal::OpBlockChecksumResponseProto>(GetArenaNoVirtual());
4997 checksumresponse_ = p;
4998 }
4999 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlockOpResponseProto.checksumResponse)
5000 return checksumresponse_;
5001}
5002inline void BlockOpResponseProto::set_allocated_checksumresponse(::Hdfs::Internal::OpBlockChecksumResponseProto* checksumresponse) {
5003 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5004 if (message_arena == NULL) {
5005 delete checksumresponse_;
5006 }
5007 if (checksumresponse) {
5008 ::google::protobuf::Arena* submessage_arena = NULL;
5009 if (message_arena != submessage_arena) {
5010 checksumresponse = ::google::protobuf::internal::GetOwnedMessage(
5011 message_arena, checksumresponse, submessage_arena);
5012 }
5013 set_has_checksumresponse();
5014 } else {
5015 clear_has_checksumresponse();
5016 }
5017 checksumresponse_ = checksumresponse;
5018 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.BlockOpResponseProto.checksumResponse)
5019}
5020
5021// optional .Hdfs.Internal.ReadOpChecksumInfoProto readOpChecksumInfo = 4;
5022inline bool BlockOpResponseProto::has_readopchecksuminfo() const {
5023 return (_has_bits_[0] & 0x00000008u) != 0;
5024}
5025inline void BlockOpResponseProto::set_has_readopchecksuminfo() {
5026 _has_bits_[0] |= 0x00000008u;
5027}
5028inline void BlockOpResponseProto::clear_has_readopchecksuminfo() {
5029 _has_bits_[0] &= ~0x00000008u;
5030}
5031inline void BlockOpResponseProto::clear_readopchecksuminfo() {
5032 if (readopchecksuminfo_ != NULL) readopchecksuminfo_->Clear();
5033 clear_has_readopchecksuminfo();
5034}
5035inline const ::Hdfs::Internal::ReadOpChecksumInfoProto& BlockOpResponseProto::_internal_readopchecksuminfo() const {
5036 return *readopchecksuminfo_;
5037}
5038inline const ::Hdfs::Internal::ReadOpChecksumInfoProto& BlockOpResponseProto::readopchecksuminfo() const {
5039 const ::Hdfs::Internal::ReadOpChecksumInfoProto* p = readopchecksuminfo_;
5040 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockOpResponseProto.readOpChecksumInfo)
5041 return p != NULL ? *p : *reinterpret_cast<const ::Hdfs::Internal::ReadOpChecksumInfoProto*>(
5042 &::Hdfs::Internal::_ReadOpChecksumInfoProto_default_instance_);
5043}
5044inline ::Hdfs::Internal::ReadOpChecksumInfoProto* BlockOpResponseProto::release_readopchecksuminfo() {
5045 // @@protoc_insertion_point(field_release:Hdfs.Internal.BlockOpResponseProto.readOpChecksumInfo)
5046 clear_has_readopchecksuminfo();
5047 ::Hdfs::Internal::ReadOpChecksumInfoProto* temp = readopchecksuminfo_;
5048 readopchecksuminfo_ = NULL;
5049 return temp;
5050}
5051inline ::Hdfs::Internal::ReadOpChecksumInfoProto* BlockOpResponseProto::mutable_readopchecksuminfo() {
5052 set_has_readopchecksuminfo();
5053 if (readopchecksuminfo_ == NULL) {
5054 auto* p = CreateMaybeMessage<::Hdfs::Internal::ReadOpChecksumInfoProto>(GetArenaNoVirtual());
5055 readopchecksuminfo_ = p;
5056 }
5057 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlockOpResponseProto.readOpChecksumInfo)
5058 return readopchecksuminfo_;
5059}
5060inline void BlockOpResponseProto::set_allocated_readopchecksuminfo(::Hdfs::Internal::ReadOpChecksumInfoProto* readopchecksuminfo) {
5061 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5062 if (message_arena == NULL) {
5063 delete readopchecksuminfo_;
5064 }
5065 if (readopchecksuminfo) {
5066 ::google::protobuf::Arena* submessage_arena = NULL;
5067 if (message_arena != submessage_arena) {
5068 readopchecksuminfo = ::google::protobuf::internal::GetOwnedMessage(
5069 message_arena, readopchecksuminfo, submessage_arena);
5070 }
5071 set_has_readopchecksuminfo();
5072 } else {
5073 clear_has_readopchecksuminfo();
5074 }
5075 readopchecksuminfo_ = readopchecksuminfo;
5076 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.BlockOpResponseProto.readOpChecksumInfo)
5077}
5078
5079// optional string message = 5;
5080inline bool BlockOpResponseProto::has_message() const {
5081 return (_has_bits_[0] & 0x00000002u) != 0;
5082}
5083inline void BlockOpResponseProto::set_has_message() {
5084 _has_bits_[0] |= 0x00000002u;
5085}
5086inline void BlockOpResponseProto::clear_has_message() {
5087 _has_bits_[0] &= ~0x00000002u;
5088}
5089inline void BlockOpResponseProto::clear_message() {
5090 message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5091 clear_has_message();
5092}
5093inline const ::std::string& BlockOpResponseProto::message() const {
5094 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockOpResponseProto.message)
5095 return message_.GetNoArena();
5096}
5097inline void BlockOpResponseProto::set_message(const ::std::string& value) {
5098 set_has_message();
5099 message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5100 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockOpResponseProto.message)
5101}
5102#if LANG_CXX11
5103inline void BlockOpResponseProto::set_message(::std::string&& value) {
5104 set_has_message();
5105 message_.SetNoArena(
5106 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5107 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.BlockOpResponseProto.message)
5108}
5109#endif
5110inline void BlockOpResponseProto::set_message(const char* value) {
5111 GOOGLE_DCHECK(value != NULL);
5112 set_has_message();
5113 message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5114 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.BlockOpResponseProto.message)
5115}
5116inline void BlockOpResponseProto::set_message(const char* value, size_t size) {
5117 set_has_message();
5118 message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5119 ::std::string(reinterpret_cast<const char*>(value), size));
5120 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.BlockOpResponseProto.message)
5121}
5122inline ::std::string* BlockOpResponseProto::mutable_message() {
5123 set_has_message();
5124 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.BlockOpResponseProto.message)
5125 return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5126}
5127inline ::std::string* BlockOpResponseProto::release_message() {
5128 // @@protoc_insertion_point(field_release:Hdfs.Internal.BlockOpResponseProto.message)
5129 if (!has_message()) {
5130 return NULL;
5131 }
5132 clear_has_message();
5133 return message_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5134}
5135inline void BlockOpResponseProto::set_allocated_message(::std::string* message) {
5136 if (message != NULL) {
5137 set_has_message();
5138 } else {
5139 clear_has_message();
5140 }
5141 message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
5142 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.BlockOpResponseProto.message)
5143}
5144
5145// optional uint32 shortCircuitAccessVersion = 6;
5146inline bool BlockOpResponseProto::has_shortcircuitaccessversion() const {
5147 return (_has_bits_[0] & 0x00000020u) != 0;
5148}
5149inline void BlockOpResponseProto::set_has_shortcircuitaccessversion() {
5150 _has_bits_[0] |= 0x00000020u;
5151}
5152inline void BlockOpResponseProto::clear_has_shortcircuitaccessversion() {
5153 _has_bits_[0] &= ~0x00000020u;
5154}
5155inline void BlockOpResponseProto::clear_shortcircuitaccessversion() {
5156 shortcircuitaccessversion_ = 0u;
5157 clear_has_shortcircuitaccessversion();
5158}
5159inline ::google::protobuf::uint32 BlockOpResponseProto::shortcircuitaccessversion() const {
5160 // @@protoc_insertion_point(field_get:Hdfs.Internal.BlockOpResponseProto.shortCircuitAccessVersion)
5161 return shortcircuitaccessversion_;
5162}
5163inline void BlockOpResponseProto::set_shortcircuitaccessversion(::google::protobuf::uint32 value) {
5164 set_has_shortcircuitaccessversion();
5165 shortcircuitaccessversion_ = value;
5166 // @@protoc_insertion_point(field_set:Hdfs.Internal.BlockOpResponseProto.shortCircuitAccessVersion)
5167}
5168
5169// -------------------------------------------------------------------
5170
5171// ClientReadStatusProto
5172
5173// required .Hdfs.Internal.Status status = 1;
5174inline bool ClientReadStatusProto::has_status() const {
5175 return (_has_bits_[0] & 0x00000001u) != 0;
5176}
5177inline void ClientReadStatusProto::set_has_status() {
5178 _has_bits_[0] |= 0x00000001u;
5179}
5180inline void ClientReadStatusProto::clear_has_status() {
5181 _has_bits_[0] &= ~0x00000001u;
5182}
5183inline void ClientReadStatusProto::clear_status() {
5184 status_ = 0;
5185 clear_has_status();
5186}
5187inline ::Hdfs::Internal::Status ClientReadStatusProto::status() const {
5188 // @@protoc_insertion_point(field_get:Hdfs.Internal.ClientReadStatusProto.status)
5189 return static_cast< ::Hdfs::Internal::Status >(status_);
5190}
5191inline void ClientReadStatusProto::set_status(::Hdfs::Internal::Status value) {
5192 assert(::Hdfs::Internal::Status_IsValid(value));
5193 set_has_status();
5194 status_ = value;
5195 // @@protoc_insertion_point(field_set:Hdfs.Internal.ClientReadStatusProto.status)
5196}
5197
5198// -------------------------------------------------------------------
5199
5200// DNTransferAckProto
5201
5202// required .Hdfs.Internal.Status status = 1;
5203inline bool DNTransferAckProto::has_status() const {
5204 return (_has_bits_[0] & 0x00000001u) != 0;
5205}
5206inline void DNTransferAckProto::set_has_status() {
5207 _has_bits_[0] |= 0x00000001u;
5208}
5209inline void DNTransferAckProto::clear_has_status() {
5210 _has_bits_[0] &= ~0x00000001u;
5211}
5212inline void DNTransferAckProto::clear_status() {
5213 status_ = 0;
5214 clear_has_status();
5215}
5216inline ::Hdfs::Internal::Status DNTransferAckProto::status() const {
5217 // @@protoc_insertion_point(field_get:Hdfs.Internal.DNTransferAckProto.status)
5218 return static_cast< ::Hdfs::Internal::Status >(status_);
5219}
5220inline void DNTransferAckProto::set_status(::Hdfs::Internal::Status value) {
5221 assert(::Hdfs::Internal::Status_IsValid(value));
5222 set_has_status();
5223 status_ = value;
5224 // @@protoc_insertion_point(field_set:Hdfs.Internal.DNTransferAckProto.status)
5225}
5226
5227// -------------------------------------------------------------------
5228
5229// OpBlockChecksumResponseProto
5230
5231// required uint32 bytesPerCrc = 1;
5232inline bool OpBlockChecksumResponseProto::has_bytespercrc() const {
5233 return (_has_bits_[0] & 0x00000004u) != 0;
5234}
5235inline void OpBlockChecksumResponseProto::set_has_bytespercrc() {
5236 _has_bits_[0] |= 0x00000004u;
5237}
5238inline void OpBlockChecksumResponseProto::clear_has_bytespercrc() {
5239 _has_bits_[0] &= ~0x00000004u;
5240}
5241inline void OpBlockChecksumResponseProto::clear_bytespercrc() {
5242 bytespercrc_ = 0u;
5243 clear_has_bytespercrc();
5244}
5245inline ::google::protobuf::uint32 OpBlockChecksumResponseProto::bytespercrc() const {
5246 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpBlockChecksumResponseProto.bytesPerCrc)
5247 return bytespercrc_;
5248}
5249inline void OpBlockChecksumResponseProto::set_bytespercrc(::google::protobuf::uint32 value) {
5250 set_has_bytespercrc();
5251 bytespercrc_ = value;
5252 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpBlockChecksumResponseProto.bytesPerCrc)
5253}
5254
5255// required uint64 crcPerBlock = 2;
5256inline bool OpBlockChecksumResponseProto::has_crcperblock() const {
5257 return (_has_bits_[0] & 0x00000002u) != 0;
5258}
5259inline void OpBlockChecksumResponseProto::set_has_crcperblock() {
5260 _has_bits_[0] |= 0x00000002u;
5261}
5262inline void OpBlockChecksumResponseProto::clear_has_crcperblock() {
5263 _has_bits_[0] &= ~0x00000002u;
5264}
5265inline void OpBlockChecksumResponseProto::clear_crcperblock() {
5266 crcperblock_ = GOOGLE_ULONGLONG(0);
5267 clear_has_crcperblock();
5268}
5269inline ::google::protobuf::uint64 OpBlockChecksumResponseProto::crcperblock() const {
5270 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpBlockChecksumResponseProto.crcPerBlock)
5271 return crcperblock_;
5272}
5273inline void OpBlockChecksumResponseProto::set_crcperblock(::google::protobuf::uint64 value) {
5274 set_has_crcperblock();
5275 crcperblock_ = value;
5276 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpBlockChecksumResponseProto.crcPerBlock)
5277}
5278
5279// required bytes md5 = 3;
5280inline bool OpBlockChecksumResponseProto::has_md5() const {
5281 return (_has_bits_[0] & 0x00000001u) != 0;
5282}
5283inline void OpBlockChecksumResponseProto::set_has_md5() {
5284 _has_bits_[0] |= 0x00000001u;
5285}
5286inline void OpBlockChecksumResponseProto::clear_has_md5() {
5287 _has_bits_[0] &= ~0x00000001u;
5288}
5289inline void OpBlockChecksumResponseProto::clear_md5() {
5290 md5_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5291 clear_has_md5();
5292}
5293inline const ::std::string& OpBlockChecksumResponseProto::md5() const {
5294 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpBlockChecksumResponseProto.md5)
5295 return md5_.GetNoArena();
5296}
5297inline void OpBlockChecksumResponseProto::set_md5(const ::std::string& value) {
5298 set_has_md5();
5299 md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5300 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpBlockChecksumResponseProto.md5)
5301}
5302#if LANG_CXX11
5303inline void OpBlockChecksumResponseProto::set_md5(::std::string&& value) {
5304 set_has_md5();
5305 md5_.SetNoArena(
5306 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5307 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.OpBlockChecksumResponseProto.md5)
5308}
5309#endif
5310inline void OpBlockChecksumResponseProto::set_md5(const char* value) {
5311 GOOGLE_DCHECK(value != NULL);
5312 set_has_md5();
5313 md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5314 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.OpBlockChecksumResponseProto.md5)
5315}
5316inline void OpBlockChecksumResponseProto::set_md5(const void* value, size_t size) {
5317 set_has_md5();
5318 md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5319 ::std::string(reinterpret_cast<const char*>(value), size));
5320 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.OpBlockChecksumResponseProto.md5)
5321}
5322inline ::std::string* OpBlockChecksumResponseProto::mutable_md5() {
5323 set_has_md5();
5324 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.OpBlockChecksumResponseProto.md5)
5325 return md5_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5326}
5327inline ::std::string* OpBlockChecksumResponseProto::release_md5() {
5328 // @@protoc_insertion_point(field_release:Hdfs.Internal.OpBlockChecksumResponseProto.md5)
5329 if (!has_md5()) {
5330 return NULL;
5331 }
5332 clear_has_md5();
5333 return md5_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5334}
5335inline void OpBlockChecksumResponseProto::set_allocated_md5(::std::string* md5) {
5336 if (md5 != NULL) {
5337 set_has_md5();
5338 } else {
5339 clear_has_md5();
5340 }
5341 md5_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), md5);
5342 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.OpBlockChecksumResponseProto.md5)
5343}
5344
5345// optional .Hdfs.Internal.ChecksumTypeProto crcType = 4;
5346inline bool OpBlockChecksumResponseProto::has_crctype() const {
5347 return (_has_bits_[0] & 0x00000008u) != 0;
5348}
5349inline void OpBlockChecksumResponseProto::set_has_crctype() {
5350 _has_bits_[0] |= 0x00000008u;
5351}
5352inline void OpBlockChecksumResponseProto::clear_has_crctype() {
5353 _has_bits_[0] &= ~0x00000008u;
5354}
5355inline void OpBlockChecksumResponseProto::clear_crctype() {
5356 crctype_ = 0;
5357 clear_has_crctype();
5358}
5359inline ::Hdfs::Internal::ChecksumTypeProto OpBlockChecksumResponseProto::crctype() const {
5360 // @@protoc_insertion_point(field_get:Hdfs.Internal.OpBlockChecksumResponseProto.crcType)
5361 return static_cast< ::Hdfs::Internal::ChecksumTypeProto >(crctype_);
5362}
5363inline void OpBlockChecksumResponseProto::set_crctype(::Hdfs::Internal::ChecksumTypeProto value) {
5364 assert(::Hdfs::Internal::ChecksumTypeProto_IsValid(value));
5365 set_has_crctype();
5366 crctype_ = value;
5367 // @@protoc_insertion_point(field_set:Hdfs.Internal.OpBlockChecksumResponseProto.crcType)
5368}
5369
5370#ifdef __GNUC__
5371 #pragma GCC diagnostic pop
5372#endif // __GNUC__
5373// -------------------------------------------------------------------
5374
5375// -------------------------------------------------------------------
5376
5377// -------------------------------------------------------------------
5378
5379// -------------------------------------------------------------------
5380
5381// -------------------------------------------------------------------
5382
5383// -------------------------------------------------------------------
5384
5385// -------------------------------------------------------------------
5386
5387// -------------------------------------------------------------------
5388
5389// -------------------------------------------------------------------
5390
5391// -------------------------------------------------------------------
5392
5393// -------------------------------------------------------------------
5394
5395// -------------------------------------------------------------------
5396
5397// -------------------------------------------------------------------
5398
5399// -------------------------------------------------------------------
5400
5401// -------------------------------------------------------------------
5402
5403// -------------------------------------------------------------------
5404
5405// -------------------------------------------------------------------
5406
5407// -------------------------------------------------------------------
5408
5409
5410// @@protoc_insertion_point(namespace_scope)
5411
5412} // namespace Internal
5413} // namespace Hdfs
5414
5415namespace google {
5416namespace protobuf {
5417
5418template <> struct is_proto_enum< ::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus> : ::std::true_type {};
5419template <>
5420inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus>() {
5421 return ::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_descriptor();
5422}
5423template <> struct is_proto_enum< ::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage> : ::std::true_type {};
5424template <>
5425inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage>() {
5426 return ::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage_descriptor();
5427}
5428template <> struct is_proto_enum< ::Hdfs::Internal::Status> : ::std::true_type {};
5429template <>
5430inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::Status>() {
5431 return ::Hdfs::Internal::Status_descriptor();
5432}
5433
5434} // namespace protobuf
5435} // namespace google
5436
5437// @@protoc_insertion_point(global_scope)
5438
5439#endif // PROTOBUF_INCLUDED_datatransfer_2eproto
5440