1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: datatransfer.proto
3
4#include "datatransfer.pb.h"
5
6#include <algorithm>
7
8#include <google/protobuf/stubs/common.h>
9#include <google/protobuf/stubs/port.h>
10#include <google/protobuf/io/coded_stream.h>
11#include <google/protobuf/wire_format_lite_inl.h>
12#include <google/protobuf/descriptor.h>
13#include <google/protobuf/generated_message_reflection.h>
14#include <google/protobuf/reflection_ops.h>
15#include <google/protobuf/wire_format.h>
16// This is a temporary google only hack
17#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
18#include "third_party/protobuf/version.h"
19#endif
20// @@protoc_insertion_point(includes)
21
22namespace protobuf_Security_2eproto {
23extern PROTOBUF_INTERNAL_EXPORT_protobuf_Security_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_TokenProto;
24} // namespace protobuf_Security_2eproto
25namespace protobuf_datatransfer_2eproto {
26extern PROTOBUF_INTERNAL_EXPORT_protobuf_datatransfer_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_CachingStrategyProto;
27extern PROTOBUF_INTERNAL_EXPORT_protobuf_datatransfer_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_ChecksumProto;
28extern PROTOBUF_INTERNAL_EXPORT_protobuf_datatransfer_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_OpBlockChecksumResponseProto;
29extern PROTOBUF_INTERNAL_EXPORT_protobuf_datatransfer_2eproto ::google::protobuf::internal::SCCInfo<1> scc_info_ClientOperationHeaderProto;
30extern PROTOBUF_INTERNAL_EXPORT_protobuf_datatransfer_2eproto ::google::protobuf::internal::SCCInfo<1> scc_info_ReadOpChecksumInfoProto;
31extern PROTOBUF_INTERNAL_EXPORT_protobuf_datatransfer_2eproto ::google::protobuf::internal::SCCInfo<2> scc_info_BaseHeaderProto;
32} // namespace protobuf_datatransfer_2eproto
33namespace protobuf_hdfs_2eproto {
34extern PROTOBUF_INTERNAL_EXPORT_protobuf_hdfs_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_ExtendedBlockProto;
35extern PROTOBUF_INTERNAL_EXPORT_protobuf_hdfs_2eproto ::google::protobuf::internal::SCCInfo<1> scc_info_DatanodeInfoProto;
36} // namespace protobuf_hdfs_2eproto
37namespace Hdfs {
38namespace Internal {
39class DataTransferEncryptorMessageProtoDefaultTypeInternal {
40 public:
41 ::google::protobuf::internal::ExplicitlyConstructed<DataTransferEncryptorMessageProto>
42 _instance;
43} _DataTransferEncryptorMessageProto_default_instance_;
44class BaseHeaderProtoDefaultTypeInternal {
45 public:
46 ::google::protobuf::internal::ExplicitlyConstructed<BaseHeaderProto>
47 _instance;
48} _BaseHeaderProto_default_instance_;
49class ClientOperationHeaderProtoDefaultTypeInternal {
50 public:
51 ::google::protobuf::internal::ExplicitlyConstructed<ClientOperationHeaderProto>
52 _instance;
53} _ClientOperationHeaderProto_default_instance_;
54class CachingStrategyProtoDefaultTypeInternal {
55 public:
56 ::google::protobuf::internal::ExplicitlyConstructed<CachingStrategyProto>
57 _instance;
58} _CachingStrategyProto_default_instance_;
59class OpReadBlockProtoDefaultTypeInternal {
60 public:
61 ::google::protobuf::internal::ExplicitlyConstructed<OpReadBlockProto>
62 _instance;
63} _OpReadBlockProto_default_instance_;
64class ChecksumProtoDefaultTypeInternal {
65 public:
66 ::google::protobuf::internal::ExplicitlyConstructed<ChecksumProto>
67 _instance;
68} _ChecksumProto_default_instance_;
69class OpWriteBlockProtoDefaultTypeInternal {
70 public:
71 ::google::protobuf::internal::ExplicitlyConstructed<OpWriteBlockProto>
72 _instance;
73} _OpWriteBlockProto_default_instance_;
74class OpTransferBlockProtoDefaultTypeInternal {
75 public:
76 ::google::protobuf::internal::ExplicitlyConstructed<OpTransferBlockProto>
77 _instance;
78} _OpTransferBlockProto_default_instance_;
79class OpReplaceBlockProtoDefaultTypeInternal {
80 public:
81 ::google::protobuf::internal::ExplicitlyConstructed<OpReplaceBlockProto>
82 _instance;
83} _OpReplaceBlockProto_default_instance_;
84class OpCopyBlockProtoDefaultTypeInternal {
85 public:
86 ::google::protobuf::internal::ExplicitlyConstructed<OpCopyBlockProto>
87 _instance;
88} _OpCopyBlockProto_default_instance_;
89class OpBlockChecksumProtoDefaultTypeInternal {
90 public:
91 ::google::protobuf::internal::ExplicitlyConstructed<OpBlockChecksumProto>
92 _instance;
93} _OpBlockChecksumProto_default_instance_;
94class OpRequestShortCircuitAccessProtoDefaultTypeInternal {
95 public:
96 ::google::protobuf::internal::ExplicitlyConstructed<OpRequestShortCircuitAccessProto>
97 _instance;
98} _OpRequestShortCircuitAccessProto_default_instance_;
99class PacketHeaderProtoDefaultTypeInternal {
100 public:
101 ::google::protobuf::internal::ExplicitlyConstructed<PacketHeaderProto>
102 _instance;
103} _PacketHeaderProto_default_instance_;
104class PipelineAckProtoDefaultTypeInternal {
105 public:
106 ::google::protobuf::internal::ExplicitlyConstructed<PipelineAckProto>
107 _instance;
108} _PipelineAckProto_default_instance_;
109class ReadOpChecksumInfoProtoDefaultTypeInternal {
110 public:
111 ::google::protobuf::internal::ExplicitlyConstructed<ReadOpChecksumInfoProto>
112 _instance;
113} _ReadOpChecksumInfoProto_default_instance_;
114class BlockOpResponseProtoDefaultTypeInternal {
115 public:
116 ::google::protobuf::internal::ExplicitlyConstructed<BlockOpResponseProto>
117 _instance;
118} _BlockOpResponseProto_default_instance_;
119class ClientReadStatusProtoDefaultTypeInternal {
120 public:
121 ::google::protobuf::internal::ExplicitlyConstructed<ClientReadStatusProto>
122 _instance;
123} _ClientReadStatusProto_default_instance_;
124class DNTransferAckProtoDefaultTypeInternal {
125 public:
126 ::google::protobuf::internal::ExplicitlyConstructed<DNTransferAckProto>
127 _instance;
128} _DNTransferAckProto_default_instance_;
129class OpBlockChecksumResponseProtoDefaultTypeInternal {
130 public:
131 ::google::protobuf::internal::ExplicitlyConstructed<OpBlockChecksumResponseProto>
132 _instance;
133} _OpBlockChecksumResponseProto_default_instance_;
134} // namespace Internal
135} // namespace Hdfs
136namespace protobuf_datatransfer_2eproto {
137static void InitDefaultsDataTransferEncryptorMessageProto() {
138 GOOGLE_PROTOBUF_VERIFY_VERSION;
139
140 {
141 void* ptr = &::Hdfs::Internal::_DataTransferEncryptorMessageProto_default_instance_;
142 new (ptr) ::Hdfs::Internal::DataTransferEncryptorMessageProto();
143 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
144 }
145 ::Hdfs::Internal::DataTransferEncryptorMessageProto::InitAsDefaultInstance();
146}
147
148::google::protobuf::internal::SCCInfo<0> scc_info_DataTransferEncryptorMessageProto =
149 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsDataTransferEncryptorMessageProto}, {}};
150
151static void InitDefaultsBaseHeaderProto() {
152 GOOGLE_PROTOBUF_VERIFY_VERSION;
153
154 {
155 void* ptr = &::Hdfs::Internal::_BaseHeaderProto_default_instance_;
156 new (ptr) ::Hdfs::Internal::BaseHeaderProto();
157 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
158 }
159 ::Hdfs::Internal::BaseHeaderProto::InitAsDefaultInstance();
160}
161
162::google::protobuf::internal::SCCInfo<2> scc_info_BaseHeaderProto =
163 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsBaseHeaderProto}, {
164 &protobuf_hdfs_2eproto::scc_info_ExtendedBlockProto.base,
165 &protobuf_Security_2eproto::scc_info_TokenProto.base,}};
166
167static void InitDefaultsClientOperationHeaderProto() {
168 GOOGLE_PROTOBUF_VERIFY_VERSION;
169
170 {
171 void* ptr = &::Hdfs::Internal::_ClientOperationHeaderProto_default_instance_;
172 new (ptr) ::Hdfs::Internal::ClientOperationHeaderProto();
173 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
174 }
175 ::Hdfs::Internal::ClientOperationHeaderProto::InitAsDefaultInstance();
176}
177
178::google::protobuf::internal::SCCInfo<1> scc_info_ClientOperationHeaderProto =
179 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsClientOperationHeaderProto}, {
180 &protobuf_datatransfer_2eproto::scc_info_BaseHeaderProto.base,}};
181
182static void InitDefaultsCachingStrategyProto() {
183 GOOGLE_PROTOBUF_VERIFY_VERSION;
184
185 {
186 void* ptr = &::Hdfs::Internal::_CachingStrategyProto_default_instance_;
187 new (ptr) ::Hdfs::Internal::CachingStrategyProto();
188 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
189 }
190 ::Hdfs::Internal::CachingStrategyProto::InitAsDefaultInstance();
191}
192
193::google::protobuf::internal::SCCInfo<0> scc_info_CachingStrategyProto =
194 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsCachingStrategyProto}, {}};
195
196static void InitDefaultsOpReadBlockProto() {
197 GOOGLE_PROTOBUF_VERIFY_VERSION;
198
199 {
200 void* ptr = &::Hdfs::Internal::_OpReadBlockProto_default_instance_;
201 new (ptr) ::Hdfs::Internal::OpReadBlockProto();
202 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
203 }
204 ::Hdfs::Internal::OpReadBlockProto::InitAsDefaultInstance();
205}
206
207::google::protobuf::internal::SCCInfo<2> scc_info_OpReadBlockProto =
208 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsOpReadBlockProto}, {
209 &protobuf_datatransfer_2eproto::scc_info_ClientOperationHeaderProto.base,
210 &protobuf_datatransfer_2eproto::scc_info_CachingStrategyProto.base,}};
211
212static void InitDefaultsChecksumProto() {
213 GOOGLE_PROTOBUF_VERIFY_VERSION;
214
215 {
216 void* ptr = &::Hdfs::Internal::_ChecksumProto_default_instance_;
217 new (ptr) ::Hdfs::Internal::ChecksumProto();
218 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
219 }
220 ::Hdfs::Internal::ChecksumProto::InitAsDefaultInstance();
221}
222
223::google::protobuf::internal::SCCInfo<0> scc_info_ChecksumProto =
224 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsChecksumProto}, {}};
225
226static void InitDefaultsOpWriteBlockProto() {
227 GOOGLE_PROTOBUF_VERIFY_VERSION;
228
229 {
230 void* ptr = &::Hdfs::Internal::_OpWriteBlockProto_default_instance_;
231 new (ptr) ::Hdfs::Internal::OpWriteBlockProto();
232 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
233 }
234 ::Hdfs::Internal::OpWriteBlockProto::InitAsDefaultInstance();
235}
236
237::google::protobuf::internal::SCCInfo<4> scc_info_OpWriteBlockProto =
238 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 4, InitDefaultsOpWriteBlockProto}, {
239 &protobuf_datatransfer_2eproto::scc_info_ClientOperationHeaderProto.base,
240 &protobuf_hdfs_2eproto::scc_info_DatanodeInfoProto.base,
241 &protobuf_datatransfer_2eproto::scc_info_ChecksumProto.base,
242 &protobuf_datatransfer_2eproto::scc_info_CachingStrategyProto.base,}};
243
244static void InitDefaultsOpTransferBlockProto() {
245 GOOGLE_PROTOBUF_VERIFY_VERSION;
246
247 {
248 void* ptr = &::Hdfs::Internal::_OpTransferBlockProto_default_instance_;
249 new (ptr) ::Hdfs::Internal::OpTransferBlockProto();
250 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
251 }
252 ::Hdfs::Internal::OpTransferBlockProto::InitAsDefaultInstance();
253}
254
255::google::protobuf::internal::SCCInfo<2> scc_info_OpTransferBlockProto =
256 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsOpTransferBlockProto}, {
257 &protobuf_datatransfer_2eproto::scc_info_ClientOperationHeaderProto.base,
258 &protobuf_hdfs_2eproto::scc_info_DatanodeInfoProto.base,}};
259
260static void InitDefaultsOpReplaceBlockProto() {
261 GOOGLE_PROTOBUF_VERIFY_VERSION;
262
263 {
264 void* ptr = &::Hdfs::Internal::_OpReplaceBlockProto_default_instance_;
265 new (ptr) ::Hdfs::Internal::OpReplaceBlockProto();
266 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
267 }
268 ::Hdfs::Internal::OpReplaceBlockProto::InitAsDefaultInstance();
269}
270
271::google::protobuf::internal::SCCInfo<2> scc_info_OpReplaceBlockProto =
272 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsOpReplaceBlockProto}, {
273 &protobuf_datatransfer_2eproto::scc_info_BaseHeaderProto.base,
274 &protobuf_hdfs_2eproto::scc_info_DatanodeInfoProto.base,}};
275
276static void InitDefaultsOpCopyBlockProto() {
277 GOOGLE_PROTOBUF_VERIFY_VERSION;
278
279 {
280 void* ptr = &::Hdfs::Internal::_OpCopyBlockProto_default_instance_;
281 new (ptr) ::Hdfs::Internal::OpCopyBlockProto();
282 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
283 }
284 ::Hdfs::Internal::OpCopyBlockProto::InitAsDefaultInstance();
285}
286
287::google::protobuf::internal::SCCInfo<1> scc_info_OpCopyBlockProto =
288 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsOpCopyBlockProto}, {
289 &protobuf_datatransfer_2eproto::scc_info_BaseHeaderProto.base,}};
290
291static void InitDefaultsOpBlockChecksumProto() {
292 GOOGLE_PROTOBUF_VERIFY_VERSION;
293
294 {
295 void* ptr = &::Hdfs::Internal::_OpBlockChecksumProto_default_instance_;
296 new (ptr) ::Hdfs::Internal::OpBlockChecksumProto();
297 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
298 }
299 ::Hdfs::Internal::OpBlockChecksumProto::InitAsDefaultInstance();
300}
301
302::google::protobuf::internal::SCCInfo<1> scc_info_OpBlockChecksumProto =
303 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsOpBlockChecksumProto}, {
304 &protobuf_datatransfer_2eproto::scc_info_BaseHeaderProto.base,}};
305
306static void InitDefaultsOpRequestShortCircuitAccessProto() {
307 GOOGLE_PROTOBUF_VERIFY_VERSION;
308
309 {
310 void* ptr = &::Hdfs::Internal::_OpRequestShortCircuitAccessProto_default_instance_;
311 new (ptr) ::Hdfs::Internal::OpRequestShortCircuitAccessProto();
312 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
313 }
314 ::Hdfs::Internal::OpRequestShortCircuitAccessProto::InitAsDefaultInstance();
315}
316
317::google::protobuf::internal::SCCInfo<1> scc_info_OpRequestShortCircuitAccessProto =
318 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsOpRequestShortCircuitAccessProto}, {
319 &protobuf_datatransfer_2eproto::scc_info_BaseHeaderProto.base,}};
320
321static void InitDefaultsPacketHeaderProto() {
322 GOOGLE_PROTOBUF_VERIFY_VERSION;
323
324 {
325 void* ptr = &::Hdfs::Internal::_PacketHeaderProto_default_instance_;
326 new (ptr) ::Hdfs::Internal::PacketHeaderProto();
327 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
328 }
329 ::Hdfs::Internal::PacketHeaderProto::InitAsDefaultInstance();
330}
331
332::google::protobuf::internal::SCCInfo<0> scc_info_PacketHeaderProto =
333 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsPacketHeaderProto}, {}};
334
335static void InitDefaultsPipelineAckProto() {
336 GOOGLE_PROTOBUF_VERIFY_VERSION;
337
338 {
339 void* ptr = &::Hdfs::Internal::_PipelineAckProto_default_instance_;
340 new (ptr) ::Hdfs::Internal::PipelineAckProto();
341 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
342 }
343 ::Hdfs::Internal::PipelineAckProto::InitAsDefaultInstance();
344}
345
346::google::protobuf::internal::SCCInfo<0> scc_info_PipelineAckProto =
347 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsPipelineAckProto}, {}};
348
349static void InitDefaultsReadOpChecksumInfoProto() {
350 GOOGLE_PROTOBUF_VERIFY_VERSION;
351
352 {
353 void* ptr = &::Hdfs::Internal::_ReadOpChecksumInfoProto_default_instance_;
354 new (ptr) ::Hdfs::Internal::ReadOpChecksumInfoProto();
355 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
356 }
357 ::Hdfs::Internal::ReadOpChecksumInfoProto::InitAsDefaultInstance();
358}
359
360::google::protobuf::internal::SCCInfo<1> scc_info_ReadOpChecksumInfoProto =
361 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsReadOpChecksumInfoProto}, {
362 &protobuf_datatransfer_2eproto::scc_info_ChecksumProto.base,}};
363
364static void InitDefaultsBlockOpResponseProto() {
365 GOOGLE_PROTOBUF_VERIFY_VERSION;
366
367 {
368 void* ptr = &::Hdfs::Internal::_BlockOpResponseProto_default_instance_;
369 new (ptr) ::Hdfs::Internal::BlockOpResponseProto();
370 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
371 }
372 ::Hdfs::Internal::BlockOpResponseProto::InitAsDefaultInstance();
373}
374
375::google::protobuf::internal::SCCInfo<2> scc_info_BlockOpResponseProto =
376 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsBlockOpResponseProto}, {
377 &protobuf_datatransfer_2eproto::scc_info_OpBlockChecksumResponseProto.base,
378 &protobuf_datatransfer_2eproto::scc_info_ReadOpChecksumInfoProto.base,}};
379
380static void InitDefaultsClientReadStatusProto() {
381 GOOGLE_PROTOBUF_VERIFY_VERSION;
382
383 {
384 void* ptr = &::Hdfs::Internal::_ClientReadStatusProto_default_instance_;
385 new (ptr) ::Hdfs::Internal::ClientReadStatusProto();
386 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
387 }
388 ::Hdfs::Internal::ClientReadStatusProto::InitAsDefaultInstance();
389}
390
391::google::protobuf::internal::SCCInfo<0> scc_info_ClientReadStatusProto =
392 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsClientReadStatusProto}, {}};
393
394static void InitDefaultsDNTransferAckProto() {
395 GOOGLE_PROTOBUF_VERIFY_VERSION;
396
397 {
398 void* ptr = &::Hdfs::Internal::_DNTransferAckProto_default_instance_;
399 new (ptr) ::Hdfs::Internal::DNTransferAckProto();
400 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
401 }
402 ::Hdfs::Internal::DNTransferAckProto::InitAsDefaultInstance();
403}
404
405::google::protobuf::internal::SCCInfo<0> scc_info_DNTransferAckProto =
406 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsDNTransferAckProto}, {}};
407
408static void InitDefaultsOpBlockChecksumResponseProto() {
409 GOOGLE_PROTOBUF_VERIFY_VERSION;
410
411 {
412 void* ptr = &::Hdfs::Internal::_OpBlockChecksumResponseProto_default_instance_;
413 new (ptr) ::Hdfs::Internal::OpBlockChecksumResponseProto();
414 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
415 }
416 ::Hdfs::Internal::OpBlockChecksumResponseProto::InitAsDefaultInstance();
417}
418
419::google::protobuf::internal::SCCInfo<0> scc_info_OpBlockChecksumResponseProto =
420 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsOpBlockChecksumResponseProto}, {}};
421
422void InitDefaults() {
423 ::google::protobuf::internal::InitSCC(&scc_info_DataTransferEncryptorMessageProto.base);
424 ::google::protobuf::internal::InitSCC(&scc_info_BaseHeaderProto.base);
425 ::google::protobuf::internal::InitSCC(&scc_info_ClientOperationHeaderProto.base);
426 ::google::protobuf::internal::InitSCC(&scc_info_CachingStrategyProto.base);
427 ::google::protobuf::internal::InitSCC(&scc_info_OpReadBlockProto.base);
428 ::google::protobuf::internal::InitSCC(&scc_info_ChecksumProto.base);
429 ::google::protobuf::internal::InitSCC(&scc_info_OpWriteBlockProto.base);
430 ::google::protobuf::internal::InitSCC(&scc_info_OpTransferBlockProto.base);
431 ::google::protobuf::internal::InitSCC(&scc_info_OpReplaceBlockProto.base);
432 ::google::protobuf::internal::InitSCC(&scc_info_OpCopyBlockProto.base);
433 ::google::protobuf::internal::InitSCC(&scc_info_OpBlockChecksumProto.base);
434 ::google::protobuf::internal::InitSCC(&scc_info_OpRequestShortCircuitAccessProto.base);
435 ::google::protobuf::internal::InitSCC(&scc_info_PacketHeaderProto.base);
436 ::google::protobuf::internal::InitSCC(&scc_info_PipelineAckProto.base);
437 ::google::protobuf::internal::InitSCC(&scc_info_ReadOpChecksumInfoProto.base);
438 ::google::protobuf::internal::InitSCC(&scc_info_BlockOpResponseProto.base);
439 ::google::protobuf::internal::InitSCC(&scc_info_ClientReadStatusProto.base);
440 ::google::protobuf::internal::InitSCC(&scc_info_DNTransferAckProto.base);
441 ::google::protobuf::internal::InitSCC(&scc_info_OpBlockChecksumResponseProto.base);
442}
443
444::google::protobuf::Metadata file_level_metadata[19];
445const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[3];
446
447const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
448 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::DataTransferEncryptorMessageProto, _has_bits_),
449 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::DataTransferEncryptorMessageProto, _internal_metadata_),
450 ~0u, // no _extensions_
451 ~0u, // no _oneof_case_
452 ~0u, // no _weak_field_map_
453 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::DataTransferEncryptorMessageProto, status_),
454 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::DataTransferEncryptorMessageProto, payload_),
455 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::DataTransferEncryptorMessageProto, message_),
456 2,
457 0,
458 1,
459 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BaseHeaderProto, _has_bits_),
460 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BaseHeaderProto, _internal_metadata_),
461 ~0u, // no _extensions_
462 ~0u, // no _oneof_case_
463 ~0u, // no _weak_field_map_
464 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BaseHeaderProto, block_),
465 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BaseHeaderProto, token_),
466 0,
467 1,
468 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ClientOperationHeaderProto, _has_bits_),
469 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ClientOperationHeaderProto, _internal_metadata_),
470 ~0u, // no _extensions_
471 ~0u, // no _oneof_case_
472 ~0u, // no _weak_field_map_
473 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ClientOperationHeaderProto, baseheader_),
474 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ClientOperationHeaderProto, clientname_),
475 1,
476 0,
477 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::CachingStrategyProto, _has_bits_),
478 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::CachingStrategyProto, _internal_metadata_),
479 ~0u, // no _extensions_
480 ~0u, // no _oneof_case_
481 ~0u, // no _weak_field_map_
482 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::CachingStrategyProto, dropbehind_),
483 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::CachingStrategyProto, readahead_),
484 1,
485 0,
486 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReadBlockProto, _has_bits_),
487 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReadBlockProto, _internal_metadata_),
488 ~0u, // no _extensions_
489 ~0u, // no _oneof_case_
490 ~0u, // no _weak_field_map_
491 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReadBlockProto, header_),
492 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReadBlockProto, offset_),
493 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReadBlockProto, len_),
494 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReadBlockProto, sendchecksums_),
495 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReadBlockProto, cachingstrategy_),
496 0,
497 2,
498 3,
499 4,
500 1,
501 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ChecksumProto, _has_bits_),
502 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ChecksumProto, _internal_metadata_),
503 ~0u, // no _extensions_
504 ~0u, // no _oneof_case_
505 ~0u, // no _weak_field_map_
506 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ChecksumProto, type_),
507 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ChecksumProto, bytesperchecksum_),
508 0,
509 1,
510 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, _has_bits_),
511 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, _internal_metadata_),
512 ~0u, // no _extensions_
513 ~0u, // no _oneof_case_
514 ~0u, // no _weak_field_map_
515 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, header_),
516 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, targets_),
517 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, source_),
518 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, stage_),
519 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, pipelinesize_),
520 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, minbytesrcvd_),
521 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, maxbytesrcvd_),
522 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, latestgenerationstamp_),
523 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, requestedchecksum_),
524 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpWriteBlockProto, cachingstrategy_),
525 0,
526 ~0u,
527 1,
528 4,
529 5,
530 6,
531 7,
532 8,
533 2,
534 3,
535 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpTransferBlockProto, _has_bits_),
536 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpTransferBlockProto, _internal_metadata_),
537 ~0u, // no _extensions_
538 ~0u, // no _oneof_case_
539 ~0u, // no _weak_field_map_
540 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpTransferBlockProto, header_),
541 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpTransferBlockProto, targets_),
542 0,
543 ~0u,
544 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReplaceBlockProto, _has_bits_),
545 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReplaceBlockProto, _internal_metadata_),
546 ~0u, // no _extensions_
547 ~0u, // no _oneof_case_
548 ~0u, // no _weak_field_map_
549 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReplaceBlockProto, header_),
550 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReplaceBlockProto, delhint_),
551 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpReplaceBlockProto, source_),
552 1,
553 0,
554 2,
555 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpCopyBlockProto, _has_bits_),
556 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpCopyBlockProto, _internal_metadata_),
557 ~0u, // no _extensions_
558 ~0u, // no _oneof_case_
559 ~0u, // no _weak_field_map_
560 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpCopyBlockProto, header_),
561 0,
562 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumProto, _has_bits_),
563 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumProto, _internal_metadata_),
564 ~0u, // no _extensions_
565 ~0u, // no _oneof_case_
566 ~0u, // no _weak_field_map_
567 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumProto, header_),
568 0,
569 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpRequestShortCircuitAccessProto, _has_bits_),
570 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpRequestShortCircuitAccessProto, _internal_metadata_),
571 ~0u, // no _extensions_
572 ~0u, // no _oneof_case_
573 ~0u, // no _weak_field_map_
574 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpRequestShortCircuitAccessProto, header_),
575 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpRequestShortCircuitAccessProto, maxversion_),
576 0,
577 1,
578 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PacketHeaderProto, _has_bits_),
579 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PacketHeaderProto, _internal_metadata_),
580 ~0u, // no _extensions_
581 ~0u, // no _oneof_case_
582 ~0u, // no _weak_field_map_
583 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PacketHeaderProto, offsetinblock_),
584 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PacketHeaderProto, seqno_),
585 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PacketHeaderProto, lastpacketinblock_),
586 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PacketHeaderProto, datalen_),
587 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PacketHeaderProto, syncblock_),
588 0,
589 1,
590 3,
591 2,
592 4,
593 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PipelineAckProto, _has_bits_),
594 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PipelineAckProto, _internal_metadata_),
595 ~0u, // no _extensions_
596 ~0u, // no _oneof_case_
597 ~0u, // no _weak_field_map_
598 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PipelineAckProto, seqno_),
599 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PipelineAckProto, status_),
600 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::PipelineAckProto, downstreamacktimenanos_),
601 0,
602 ~0u,
603 1,
604 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ReadOpChecksumInfoProto, _has_bits_),
605 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ReadOpChecksumInfoProto, _internal_metadata_),
606 ~0u, // no _extensions_
607 ~0u, // no _oneof_case_
608 ~0u, // no _weak_field_map_
609 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ReadOpChecksumInfoProto, checksum_),
610 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ReadOpChecksumInfoProto, chunkoffset_),
611 0,
612 1,
613 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BlockOpResponseProto, _has_bits_),
614 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BlockOpResponseProto, _internal_metadata_),
615 ~0u, // no _extensions_
616 ~0u, // no _oneof_case_
617 ~0u, // no _weak_field_map_
618 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BlockOpResponseProto, status_),
619 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BlockOpResponseProto, firstbadlink_),
620 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BlockOpResponseProto, checksumresponse_),
621 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BlockOpResponseProto, readopchecksuminfo_),
622 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BlockOpResponseProto, message_),
623 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::BlockOpResponseProto, shortcircuitaccessversion_),
624 4,
625 0,
626 2,
627 3,
628 1,
629 5,
630 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ClientReadStatusProto, _has_bits_),
631 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ClientReadStatusProto, _internal_metadata_),
632 ~0u, // no _extensions_
633 ~0u, // no _oneof_case_
634 ~0u, // no _weak_field_map_
635 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::ClientReadStatusProto, status_),
636 0,
637 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::DNTransferAckProto, _has_bits_),
638 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::DNTransferAckProto, _internal_metadata_),
639 ~0u, // no _extensions_
640 ~0u, // no _oneof_case_
641 ~0u, // no _weak_field_map_
642 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::DNTransferAckProto, status_),
643 0,
644 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumResponseProto, _has_bits_),
645 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumResponseProto, _internal_metadata_),
646 ~0u, // no _extensions_
647 ~0u, // no _oneof_case_
648 ~0u, // no _weak_field_map_
649 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumResponseProto, bytespercrc_),
650 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumResponseProto, crcperblock_),
651 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumResponseProto, md5_),
652 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::OpBlockChecksumResponseProto, crctype_),
653 2,
654 1,
655 0,
656 3,
657};
658static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
659 { 0, 8, sizeof(::Hdfs::Internal::DataTransferEncryptorMessageProto)},
660 { 11, 18, sizeof(::Hdfs::Internal::BaseHeaderProto)},
661 { 20, 27, sizeof(::Hdfs::Internal::ClientOperationHeaderProto)},
662 { 29, 36, sizeof(::Hdfs::Internal::CachingStrategyProto)},
663 { 38, 48, sizeof(::Hdfs::Internal::OpReadBlockProto)},
664 { 53, 60, sizeof(::Hdfs::Internal::ChecksumProto)},
665 { 62, 77, sizeof(::Hdfs::Internal::OpWriteBlockProto)},
666 { 87, 94, sizeof(::Hdfs::Internal::OpTransferBlockProto)},
667 { 96, 104, sizeof(::Hdfs::Internal::OpReplaceBlockProto)},
668 { 107, 113, sizeof(::Hdfs::Internal::OpCopyBlockProto)},
669 { 114, 120, sizeof(::Hdfs::Internal::OpBlockChecksumProto)},
670 { 121, 128, sizeof(::Hdfs::Internal::OpRequestShortCircuitAccessProto)},
671 { 130, 140, sizeof(::Hdfs::Internal::PacketHeaderProto)},
672 { 145, 153, sizeof(::Hdfs::Internal::PipelineAckProto)},
673 { 156, 163, sizeof(::Hdfs::Internal::ReadOpChecksumInfoProto)},
674 { 165, 176, sizeof(::Hdfs::Internal::BlockOpResponseProto)},
675 { 182, 188, sizeof(::Hdfs::Internal::ClientReadStatusProto)},
676 { 189, 195, sizeof(::Hdfs::Internal::DNTransferAckProto)},
677 { 196, 205, sizeof(::Hdfs::Internal::OpBlockChecksumResponseProto)},
678};
679
680static ::google::protobuf::Message const * const file_default_instances[] = {
681 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_DataTransferEncryptorMessageProto_default_instance_),
682 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_BaseHeaderProto_default_instance_),
683 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_ClientOperationHeaderProto_default_instance_),
684 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_CachingStrategyProto_default_instance_),
685 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_OpReadBlockProto_default_instance_),
686 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_ChecksumProto_default_instance_),
687 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_OpWriteBlockProto_default_instance_),
688 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_OpTransferBlockProto_default_instance_),
689 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_OpReplaceBlockProto_default_instance_),
690 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_OpCopyBlockProto_default_instance_),
691 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_OpBlockChecksumProto_default_instance_),
692 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_OpRequestShortCircuitAccessProto_default_instance_),
693 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_PacketHeaderProto_default_instance_),
694 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_PipelineAckProto_default_instance_),
695 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_ReadOpChecksumInfoProto_default_instance_),
696 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_BlockOpResponseProto_default_instance_),
697 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_ClientReadStatusProto_default_instance_),
698 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_DNTransferAckProto_default_instance_),
699 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_OpBlockChecksumResponseProto_default_instance_),
700};
701
702void protobuf_AssignDescriptors() {
703 AddDescriptors();
704 AssignDescriptors(
705 "datatransfer.proto", schemas, file_default_instances, TableStruct::offsets,
706 file_level_metadata, file_level_enum_descriptors, NULL);
707}
708
709void protobuf_AssignDescriptorsOnce() {
710 static ::google::protobuf::internal::once_flag once;
711 ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors);
712}
713
714void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
715void protobuf_RegisterTypes(const ::std::string&) {
716 protobuf_AssignDescriptorsOnce();
717 ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 19);
718}
719
720void AddDescriptorsImpl() {
721 InitDefaults();
722 static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
723 "\n\022datatransfer.proto\022\rHdfs.Internal\032\016Sec"
724 "urity.proto\032\nhdfs.proto\"\361\001\n!DataTransfer"
725 "EncryptorMessageProto\022\\\n\006status\030\001 \002(\0162L."
726 "Hdfs.Internal.DataTransferEncryptorMessa"
727 "geProto.DataTransferEncryptorStatus\022\017\n\007p"
728 "ayload\030\002 \001(\014\022\017\n\007message\030\003 \001(\t\"L\n\033DataTra"
729 "nsferEncryptorStatus\022\013\n\007SUCCESS\020\000\022\025\n\021ERR"
730 "OR_UNKNOWN_KEY\020\001\022\t\n\005ERROR\020\002\"m\n\017BaseHeade"
731 "rProto\0220\n\005block\030\001 \002(\0132!.Hdfs.Internal.Ex"
732 "tendedBlockProto\022(\n\005token\030\002 \001(\0132\031.Hdfs.I"
733 "nternal.TokenProto\"d\n\032ClientOperationHea"
734 "derProto\0222\n\nbaseHeader\030\001 \002(\0132\036.Hdfs.Inte"
735 "rnal.BaseHeaderProto\022\022\n\nclientName\030\002 \002(\t"
736 "\"=\n\024CachingStrategyProto\022\022\n\ndropBehind\030\001"
737 " \001(\010\022\021\n\treadahead\030\002 \001(\003\"\305\001\n\020OpReadBlockP"
738 "roto\0229\n\006header\030\001 \002(\0132).Hdfs.Internal.Cli"
739 "entOperationHeaderProto\022\016\n\006offset\030\002 \002(\004\022"
740 "\013\n\003len\030\003 \002(\004\022\033\n\rsendChecksums\030\004 \001(\010:\004tru"
741 "e\022<\n\017cachingStrategy\030\005 \001(\0132#.Hdfs.Intern"
742 "al.CachingStrategyProto\"Y\n\rChecksumProto"
743 "\022.\n\004type\030\001 \002(\0162 .Hdfs.Internal.ChecksumT"
744 "ypeProto\022\030\n\020bytesPerChecksum\030\002 \002(\r\"\336\005\n\021O"
745 "pWriteBlockProto\0229\n\006header\030\001 \002(\0132).Hdfs."
746 "Internal.ClientOperationHeaderProto\0221\n\007t"
747 "argets\030\002 \003(\0132 .Hdfs.Internal.DatanodeInf"
748 "oProto\0220\n\006source\030\003 \001(\0132 .Hdfs.Internal.D"
749 "atanodeInfoProto\022F\n\005stage\030\004 \002(\01627.Hdfs.I"
750 "nternal.OpWriteBlockProto.BlockConstruct"
751 "ionStage\022\024\n\014pipelineSize\030\005 \002(\r\022\024\n\014minByt"
752 "esRcvd\030\006 \002(\004\022\024\n\014maxBytesRcvd\030\007 \002(\004\022\035\n\025la"
753 "testGenerationStamp\030\010 \002(\004\0227\n\021requestedCh"
754 "ecksum\030\t \002(\0132\034.Hdfs.Internal.ChecksumPro"
755 "to\022<\n\017cachingStrategy\030\n \001(\0132#.Hdfs.Inter"
756 "nal.CachingStrategyProto\"\210\002\n\026BlockConstr"
757 "uctionStage\022\031\n\025PIPELINE_SETUP_APPEND\020\000\022\""
758 "\n\036PIPELINE_SETUP_APPEND_RECOVERY\020\001\022\022\n\016DA"
759 "TA_STREAMING\020\002\022%\n!PIPELINE_SETUP_STREAMI"
760 "NG_RECOVERY\020\003\022\022\n\016PIPELINE_CLOSE\020\004\022\033\n\027PIP"
761 "ELINE_CLOSE_RECOVERY\020\005\022\031\n\025PIPELINE_SETUP"
762 "_CREATE\020\006\022\020\n\014TRANSFER_RBW\020\007\022\026\n\022TRANSFER_"
763 "FINALIZED\020\010\"\204\001\n\024OpTransferBlockProto\0229\n\006"
764 "header\030\001 \002(\0132).Hdfs.Internal.ClientOpera"
765 "tionHeaderProto\0221\n\007targets\030\002 \003(\0132 .Hdfs."
766 "Internal.DatanodeInfoProto\"\210\001\n\023OpReplace"
767 "BlockProto\022.\n\006header\030\001 \002(\0132\036.Hdfs.Intern"
768 "al.BaseHeaderProto\022\017\n\007delHint\030\002 \002(\t\0220\n\006s"
769 "ource\030\003 \002(\0132 .Hdfs.Internal.DatanodeInfo"
770 "Proto\"B\n\020OpCopyBlockProto\022.\n\006header\030\001 \002("
771 "\0132\036.Hdfs.Internal.BaseHeaderProto\"F\n\024OpB"
772 "lockChecksumProto\022.\n\006header\030\001 \002(\0132\036.Hdfs"
773 ".Internal.BaseHeaderProto\"f\n OpRequestSh"
774 "ortCircuitAccessProto\022.\n\006header\030\001 \002(\0132\036."
775 "Hdfs.Internal.BaseHeaderProto\022\022\n\nmaxVers"
776 "ion\030\002 \002(\r\"\177\n\021PacketHeaderProto\022\025\n\roffset"
777 "InBlock\030\001 \002(\020\022\r\n\005seqno\030\002 \002(\020\022\031\n\021lastPack"
778 "etInBlock\030\003 \002(\010\022\017\n\007dataLen\030\004 \002(\017\022\030\n\tsync"
779 "Block\030\005 \001(\010:\005false\"k\n\020PipelineAckProto\022\r"
780 "\n\005seqno\030\001 \002(\022\022%\n\006status\030\002 \003(\0162\025.Hdfs.Int"
781 "ernal.Status\022!\n\026downstreamAckTimeNanos\030\003"
782 " \001(\004:\0010\"^\n\027ReadOpChecksumInfoProto\022.\n\010ch"
783 "ecksum\030\001 \002(\0132\034.Hdfs.Internal.ChecksumPro"
784 "to\022\023\n\013chunkOffset\030\002 \002(\004\"\222\002\n\024BlockOpRespo"
785 "nseProto\022%\n\006status\030\001 \002(\0162\025.Hdfs.Internal"
786 ".Status\022\024\n\014firstBadLink\030\002 \001(\t\022E\n\020checksu"
787 "mResponse\030\003 \001(\0132+.Hdfs.Internal.OpBlockC"
788 "hecksumResponseProto\022B\n\022readOpChecksumIn"
789 "fo\030\004 \001(\0132&.Hdfs.Internal.ReadOpChecksumI"
790 "nfoProto\022\017\n\007message\030\005 \001(\t\022!\n\031shortCircui"
791 "tAccessVersion\030\006 \001(\r\">\n\025ClientReadStatus"
792 "Proto\022%\n\006status\030\001 \002(\0162\025.Hdfs.Internal.St"
793 "atus\";\n\022DNTransferAckProto\022%\n\006status\030\001 \002"
794 "(\0162\025.Hdfs.Internal.Status\"\210\001\n\034OpBlockChe"
795 "cksumResponseProto\022\023\n\013bytesPerCrc\030\001 \002(\r\022"
796 "\023\n\013crcPerBlock\030\002 \002(\004\022\013\n\003md5\030\003 \002(\014\0221\n\007crc"
797 "Type\030\004 \001(\0162 .Hdfs.Internal.ChecksumTypeP"
798 "roto*\351\002\n\006Status\022\024\n\020DT_PROTO_SUCCESS\020\000\022\022\n"
799 "\016DT_PROTO_ERROR\020\001\022\033\n\027DT_PROTO_ERROR_CHEC"
800 "KSUM\020\002\022\032\n\026DT_PROTO_ERROR_INVALID\020\003\022\031\n\025DT"
801 "_PROTO_ERROR_EXISTS\020\004\022\037\n\033DT_PROTO_ERROR_"
802 "ACCESS_TOKEN\020\005\022\030\n\024DT_PROTO_CHECKSUM_OK\020\006"
803 "\022\036\n\032DT_PROTO_ERROR_UNSUPPORTED\020\007\022\030\n\024DT_P"
804 "ROTO_OOB_RESTART\020\010\022\032\n\026DT_PROTO_OOB_RESER"
805 "VED1\020\t\022\032\n\026DT_PROTO_OOB_RESERVED2\020\n\022\032\n\026DT"
806 "_PROTO_OOB_RESERVED3\020\013\022\030\n\024DT_PROTO_IN_PR"
807 "OGRESS\020\014B>\n%org.apache.hadoop.hdfs.proto"
808 "col.protoB\022DataTransferProtos\240\001\001"
809 };
810 ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
811 descriptor, 3432);
812 ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
813 "datatransfer.proto", &protobuf_RegisterTypes);
814 ::protobuf_Security_2eproto::AddDescriptors();
815 ::protobuf_hdfs_2eproto::AddDescriptors();
816}
817
818void AddDescriptors() {
819 static ::google::protobuf::internal::once_flag once;
820 ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
821}
822// Force AddDescriptors() to be called at dynamic initialization time.
823struct StaticDescriptorInitializer {
824 StaticDescriptorInitializer() {
825 AddDescriptors();
826 }
827} static_descriptor_initializer;
828} // namespace protobuf_datatransfer_2eproto
829namespace Hdfs {
830namespace Internal {
831const ::google::protobuf::EnumDescriptor* DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_descriptor() {
832 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
833 return protobuf_datatransfer_2eproto::file_level_enum_descriptors[0];
834}
835bool DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_IsValid(int value) {
836 switch (value) {
837 case 0:
838 case 1:
839 case 2:
840 return true;
841 default:
842 return false;
843 }
844}
845
846#if !defined(_MSC_VER) || _MSC_VER >= 1900
847const DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorMessageProto::SUCCESS;
848const DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorMessageProto::ERROR_UNKNOWN_KEY;
849const DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorMessageProto::ERROR;
850const DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorMessageProto::DataTransferEncryptorStatus_MIN;
851const DataTransferEncryptorMessageProto_DataTransferEncryptorStatus DataTransferEncryptorMessageProto::DataTransferEncryptorStatus_MAX;
852const int DataTransferEncryptorMessageProto::DataTransferEncryptorStatus_ARRAYSIZE;
853#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
854const ::google::protobuf::EnumDescriptor* OpWriteBlockProto_BlockConstructionStage_descriptor() {
855 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
856 return protobuf_datatransfer_2eproto::file_level_enum_descriptors[1];
857}
858bool OpWriteBlockProto_BlockConstructionStage_IsValid(int value) {
859 switch (value) {
860 case 0:
861 case 1:
862 case 2:
863 case 3:
864 case 4:
865 case 5:
866 case 6:
867 case 7:
868 case 8:
869 return true;
870 default:
871 return false;
872 }
873}
874
875#if !defined(_MSC_VER) || _MSC_VER >= 1900
876const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::PIPELINE_SETUP_APPEND;
877const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::PIPELINE_SETUP_APPEND_RECOVERY;
878const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::DATA_STREAMING;
879const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::PIPELINE_SETUP_STREAMING_RECOVERY;
880const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::PIPELINE_CLOSE;
881const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::PIPELINE_CLOSE_RECOVERY;
882const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::PIPELINE_SETUP_CREATE;
883const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::TRANSFER_RBW;
884const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::TRANSFER_FINALIZED;
885const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::BlockConstructionStage_MIN;
886const OpWriteBlockProto_BlockConstructionStage OpWriteBlockProto::BlockConstructionStage_MAX;
887const int OpWriteBlockProto::BlockConstructionStage_ARRAYSIZE;
888#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
889const ::google::protobuf::EnumDescriptor* Status_descriptor() {
890 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
891 return protobuf_datatransfer_2eproto::file_level_enum_descriptors[2];
892}
893bool Status_IsValid(int value) {
894 switch (value) {
895 case 0:
896 case 1:
897 case 2:
898 case 3:
899 case 4:
900 case 5:
901 case 6:
902 case 7:
903 case 8:
904 case 9:
905 case 10:
906 case 11:
907 case 12:
908 return true;
909 default:
910 return false;
911 }
912}
913
914
915// ===================================================================
916
917void DataTransferEncryptorMessageProto::InitAsDefaultInstance() {
918}
919#if !defined(_MSC_VER) || _MSC_VER >= 1900
920const int DataTransferEncryptorMessageProto::kStatusFieldNumber;
921const int DataTransferEncryptorMessageProto::kPayloadFieldNumber;
922const int DataTransferEncryptorMessageProto::kMessageFieldNumber;
923#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
924
925DataTransferEncryptorMessageProto::DataTransferEncryptorMessageProto()
926 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
927 ::google::protobuf::internal::InitSCC(
928 &protobuf_datatransfer_2eproto::scc_info_DataTransferEncryptorMessageProto.base);
929 SharedCtor();
930 // @@protoc_insertion_point(constructor:Hdfs.Internal.DataTransferEncryptorMessageProto)
931}
932DataTransferEncryptorMessageProto::DataTransferEncryptorMessageProto(const DataTransferEncryptorMessageProto& from)
933 : ::google::protobuf::Message(),
934 _internal_metadata_(NULL),
935 _has_bits_(from._has_bits_) {
936 _internal_metadata_.MergeFrom(from._internal_metadata_);
937 payload_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
938 if (from.has_payload()) {
939 payload_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.payload_);
940 }
941 message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
942 if (from.has_message()) {
943 message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
944 }
945 status_ = from.status_;
946 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.DataTransferEncryptorMessageProto)
947}
948
949void DataTransferEncryptorMessageProto::SharedCtor() {
950 payload_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
951 message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
952 status_ = 0;
953}
954
955DataTransferEncryptorMessageProto::~DataTransferEncryptorMessageProto() {
956 // @@protoc_insertion_point(destructor:Hdfs.Internal.DataTransferEncryptorMessageProto)
957 SharedDtor();
958}
959
960void DataTransferEncryptorMessageProto::SharedDtor() {
961 payload_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
962 message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
963}
964
965void DataTransferEncryptorMessageProto::SetCachedSize(int size) const {
966 _cached_size_.Set(size);
967}
968const ::google::protobuf::Descriptor* DataTransferEncryptorMessageProto::descriptor() {
969 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
970 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
971}
972
973const DataTransferEncryptorMessageProto& DataTransferEncryptorMessageProto::default_instance() {
974 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_DataTransferEncryptorMessageProto.base);
975 return *internal_default_instance();
976}
977
978
979void DataTransferEncryptorMessageProto::Clear() {
980// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
981 ::google::protobuf::uint32 cached_has_bits = 0;
982 // Prevent compiler warnings about cached_has_bits being unused
983 (void) cached_has_bits;
984
985 cached_has_bits = _has_bits_[0];
986 if (cached_has_bits & 3u) {
987 if (cached_has_bits & 0x00000001u) {
988 payload_.ClearNonDefaultToEmptyNoArena();
989 }
990 if (cached_has_bits & 0x00000002u) {
991 message_.ClearNonDefaultToEmptyNoArena();
992 }
993 }
994 status_ = 0;
995 _has_bits_.Clear();
996 _internal_metadata_.Clear();
997}
998
999bool DataTransferEncryptorMessageProto::MergePartialFromCodedStream(
1000 ::google::protobuf::io::CodedInputStream* input) {
1001#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
1002 ::google::protobuf::uint32 tag;
1003 // @@protoc_insertion_point(parse_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
1004 for (;;) {
1005 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
1006 tag = p.first;
1007 if (!p.second) goto handle_unusual;
1008 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1009 // required .Hdfs.Internal.DataTransferEncryptorMessageProto.DataTransferEncryptorStatus status = 1;
1010 case 1: {
1011 if (static_cast< ::google::protobuf::uint8>(tag) ==
1012 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
1013 int value;
1014 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1015 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1016 input, &value)));
1017 if (::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_IsValid(value)) {
1018 set_status(static_cast< ::Hdfs::Internal::DataTransferEncryptorMessageProto_DataTransferEncryptorStatus >(value));
1019 } else {
1020 mutable_unknown_fields()->AddVarint(
1021 1, static_cast< ::google::protobuf::uint64>(value));
1022 }
1023 } else {
1024 goto handle_unusual;
1025 }
1026 break;
1027 }
1028
1029 // optional bytes payload = 2;
1030 case 2: {
1031 if (static_cast< ::google::protobuf::uint8>(tag) ==
1032 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
1033 DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
1034 input, this->mutable_payload()));
1035 } else {
1036 goto handle_unusual;
1037 }
1038 break;
1039 }
1040
1041 // optional string message = 3;
1042 case 3: {
1043 if (static_cast< ::google::protobuf::uint8>(tag) ==
1044 static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
1045 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1046 input, this->mutable_message()));
1047 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1048 this->message().data(), static_cast<int>(this->message().length()),
1049 ::google::protobuf::internal::WireFormat::PARSE,
1050 "Hdfs.Internal.DataTransferEncryptorMessageProto.message");
1051 } else {
1052 goto handle_unusual;
1053 }
1054 break;
1055 }
1056
1057 default: {
1058 handle_unusual:
1059 if (tag == 0) {
1060 goto success;
1061 }
1062 DO_(::google::protobuf::internal::WireFormat::SkipField(
1063 input, tag, _internal_metadata_.mutable_unknown_fields()));
1064 break;
1065 }
1066 }
1067 }
1068success:
1069 // @@protoc_insertion_point(parse_success:Hdfs.Internal.DataTransferEncryptorMessageProto)
1070 return true;
1071failure:
1072 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.DataTransferEncryptorMessageProto)
1073 return false;
1074#undef DO_
1075}
1076
1077void DataTransferEncryptorMessageProto::SerializeWithCachedSizes(
1078 ::google::protobuf::io::CodedOutputStream* output) const {
1079 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
1080 ::google::protobuf::uint32 cached_has_bits = 0;
1081 (void) cached_has_bits;
1082
1083 cached_has_bits = _has_bits_[0];
1084 // required .Hdfs.Internal.DataTransferEncryptorMessageProto.DataTransferEncryptorStatus status = 1;
1085 if (cached_has_bits & 0x00000004u) {
1086 ::google::protobuf::internal::WireFormatLite::WriteEnum(
1087 1, this->status(), output);
1088 }
1089
1090 // optional bytes payload = 2;
1091 if (cached_has_bits & 0x00000001u) {
1092 ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
1093 2, this->payload(), output);
1094 }
1095
1096 // optional string message = 3;
1097 if (cached_has_bits & 0x00000002u) {
1098 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1099 this->message().data(), static_cast<int>(this->message().length()),
1100 ::google::protobuf::internal::WireFormat::SERIALIZE,
1101 "Hdfs.Internal.DataTransferEncryptorMessageProto.message");
1102 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1103 3, this->message(), output);
1104 }
1105
1106 if (_internal_metadata_.have_unknown_fields()) {
1107 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1108 _internal_metadata_.unknown_fields(), output);
1109 }
1110 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.DataTransferEncryptorMessageProto)
1111}
1112
1113::google::protobuf::uint8* DataTransferEncryptorMessageProto::InternalSerializeWithCachedSizesToArray(
1114 bool deterministic, ::google::protobuf::uint8* target) const {
1115 (void)deterministic; // Unused
1116 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
1117 ::google::protobuf::uint32 cached_has_bits = 0;
1118 (void) cached_has_bits;
1119
1120 cached_has_bits = _has_bits_[0];
1121 // required .Hdfs.Internal.DataTransferEncryptorMessageProto.DataTransferEncryptorStatus status = 1;
1122 if (cached_has_bits & 0x00000004u) {
1123 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1124 1, this->status(), target);
1125 }
1126
1127 // optional bytes payload = 2;
1128 if (cached_has_bits & 0x00000001u) {
1129 target =
1130 ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
1131 2, this->payload(), target);
1132 }
1133
1134 // optional string message = 3;
1135 if (cached_has_bits & 0x00000002u) {
1136 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1137 this->message().data(), static_cast<int>(this->message().length()),
1138 ::google::protobuf::internal::WireFormat::SERIALIZE,
1139 "Hdfs.Internal.DataTransferEncryptorMessageProto.message");
1140 target =
1141 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1142 3, this->message(), target);
1143 }
1144
1145 if (_internal_metadata_.have_unknown_fields()) {
1146 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1147 _internal_metadata_.unknown_fields(), target);
1148 }
1149 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.DataTransferEncryptorMessageProto)
1150 return target;
1151}
1152
1153size_t DataTransferEncryptorMessageProto::ByteSizeLong() const {
1154// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
1155 size_t total_size = 0;
1156
1157 if (_internal_metadata_.have_unknown_fields()) {
1158 total_size +=
1159 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1160 _internal_metadata_.unknown_fields());
1161 }
1162 // required .Hdfs.Internal.DataTransferEncryptorMessageProto.DataTransferEncryptorStatus status = 1;
1163 if (has_status()) {
1164 total_size += 1 +
1165 ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
1166 }
1167 if (_has_bits_[0 / 32] & 3u) {
1168 // optional bytes payload = 2;
1169 if (has_payload()) {
1170 total_size += 1 +
1171 ::google::protobuf::internal::WireFormatLite::BytesSize(
1172 this->payload());
1173 }
1174
1175 // optional string message = 3;
1176 if (has_message()) {
1177 total_size += 1 +
1178 ::google::protobuf::internal::WireFormatLite::StringSize(
1179 this->message());
1180 }
1181
1182 }
1183 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
1184 SetCachedSize(cached_size);
1185 return total_size;
1186}
1187
1188void DataTransferEncryptorMessageProto::MergeFrom(const ::google::protobuf::Message& from) {
1189// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
1190 GOOGLE_DCHECK_NE(&from, this);
1191 const DataTransferEncryptorMessageProto* source =
1192 ::google::protobuf::internal::DynamicCastToGenerated<const DataTransferEncryptorMessageProto>(
1193 &from);
1194 if (source == NULL) {
1195 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.DataTransferEncryptorMessageProto)
1196 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1197 } else {
1198 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.DataTransferEncryptorMessageProto)
1199 MergeFrom(*source);
1200 }
1201}
1202
1203void DataTransferEncryptorMessageProto::MergeFrom(const DataTransferEncryptorMessageProto& from) {
1204// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
1205 GOOGLE_DCHECK_NE(&from, this);
1206 _internal_metadata_.MergeFrom(from._internal_metadata_);
1207 ::google::protobuf::uint32 cached_has_bits = 0;
1208 (void) cached_has_bits;
1209
1210 cached_has_bits = from._has_bits_[0];
1211 if (cached_has_bits & 7u) {
1212 if (cached_has_bits & 0x00000001u) {
1213 set_has_payload();
1214 payload_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.payload_);
1215 }
1216 if (cached_has_bits & 0x00000002u) {
1217 set_has_message();
1218 message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
1219 }
1220 if (cached_has_bits & 0x00000004u) {
1221 status_ = from.status_;
1222 }
1223 _has_bits_[0] |= cached_has_bits;
1224 }
1225}
1226
1227void DataTransferEncryptorMessageProto::CopyFrom(const ::google::protobuf::Message& from) {
1228// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
1229 if (&from == this) return;
1230 Clear();
1231 MergeFrom(from);
1232}
1233
1234void DataTransferEncryptorMessageProto::CopyFrom(const DataTransferEncryptorMessageProto& from) {
1235// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.DataTransferEncryptorMessageProto)
1236 if (&from == this) return;
1237 Clear();
1238 MergeFrom(from);
1239}
1240
1241bool DataTransferEncryptorMessageProto::IsInitialized() const {
1242 if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;
1243 return true;
1244}
1245
1246void DataTransferEncryptorMessageProto::Swap(DataTransferEncryptorMessageProto* other) {
1247 if (other == this) return;
1248 InternalSwap(other);
1249}
1250void DataTransferEncryptorMessageProto::InternalSwap(DataTransferEncryptorMessageProto* other) {
1251 using std::swap;
1252 payload_.Swap(&other->payload_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1253 GetArenaNoVirtual());
1254 message_.Swap(&other->message_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1255 GetArenaNoVirtual());
1256 swap(status_, other->status_);
1257 swap(_has_bits_[0], other->_has_bits_[0]);
1258 _internal_metadata_.Swap(&other->_internal_metadata_);
1259}
1260
1261::google::protobuf::Metadata DataTransferEncryptorMessageProto::GetMetadata() const {
1262 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
1263 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
1264}
1265
1266
1267// ===================================================================
1268
1269void BaseHeaderProto::InitAsDefaultInstance() {
1270 ::Hdfs::Internal::_BaseHeaderProto_default_instance_._instance.get_mutable()->block_ = const_cast< ::Hdfs::Internal::ExtendedBlockProto*>(
1271 ::Hdfs::Internal::ExtendedBlockProto::internal_default_instance());
1272 ::Hdfs::Internal::_BaseHeaderProto_default_instance_._instance.get_mutable()->token_ = const_cast< ::Hdfs::Internal::TokenProto*>(
1273 ::Hdfs::Internal::TokenProto::internal_default_instance());
1274}
1275void BaseHeaderProto::clear_block() {
1276 if (block_ != NULL) block_->Clear();
1277 clear_has_block();
1278}
1279void BaseHeaderProto::clear_token() {
1280 if (token_ != NULL) token_->Clear();
1281 clear_has_token();
1282}
1283#if !defined(_MSC_VER) || _MSC_VER >= 1900
1284const int BaseHeaderProto::kBlockFieldNumber;
1285const int BaseHeaderProto::kTokenFieldNumber;
1286#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
1287
1288BaseHeaderProto::BaseHeaderProto()
1289 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
1290 ::google::protobuf::internal::InitSCC(
1291 &protobuf_datatransfer_2eproto::scc_info_BaseHeaderProto.base);
1292 SharedCtor();
1293 // @@protoc_insertion_point(constructor:Hdfs.Internal.BaseHeaderProto)
1294}
1295BaseHeaderProto::BaseHeaderProto(const BaseHeaderProto& from)
1296 : ::google::protobuf::Message(),
1297 _internal_metadata_(NULL),
1298 _has_bits_(from._has_bits_) {
1299 _internal_metadata_.MergeFrom(from._internal_metadata_);
1300 if (from.has_block()) {
1301 block_ = new ::Hdfs::Internal::ExtendedBlockProto(*from.block_);
1302 } else {
1303 block_ = NULL;
1304 }
1305 if (from.has_token()) {
1306 token_ = new ::Hdfs::Internal::TokenProto(*from.token_);
1307 } else {
1308 token_ = NULL;
1309 }
1310 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.BaseHeaderProto)
1311}
1312
1313void BaseHeaderProto::SharedCtor() {
1314 ::memset(&block_, 0, static_cast<size_t>(
1315 reinterpret_cast<char*>(&token_) -
1316 reinterpret_cast<char*>(&block_)) + sizeof(token_));
1317}
1318
1319BaseHeaderProto::~BaseHeaderProto() {
1320 // @@protoc_insertion_point(destructor:Hdfs.Internal.BaseHeaderProto)
1321 SharedDtor();
1322}
1323
1324void BaseHeaderProto::SharedDtor() {
1325 if (this != internal_default_instance()) delete block_;
1326 if (this != internal_default_instance()) delete token_;
1327}
1328
1329void BaseHeaderProto::SetCachedSize(int size) const {
1330 _cached_size_.Set(size);
1331}
1332const ::google::protobuf::Descriptor* BaseHeaderProto::descriptor() {
1333 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
1334 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
1335}
1336
1337const BaseHeaderProto& BaseHeaderProto::default_instance() {
1338 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_BaseHeaderProto.base);
1339 return *internal_default_instance();
1340}
1341
1342
1343void BaseHeaderProto::Clear() {
1344// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.BaseHeaderProto)
1345 ::google::protobuf::uint32 cached_has_bits = 0;
1346 // Prevent compiler warnings about cached_has_bits being unused
1347 (void) cached_has_bits;
1348
1349 cached_has_bits = _has_bits_[0];
1350 if (cached_has_bits & 3u) {
1351 if (cached_has_bits & 0x00000001u) {
1352 GOOGLE_DCHECK(block_ != NULL);
1353 block_->Clear();
1354 }
1355 if (cached_has_bits & 0x00000002u) {
1356 GOOGLE_DCHECK(token_ != NULL);
1357 token_->Clear();
1358 }
1359 }
1360 _has_bits_.Clear();
1361 _internal_metadata_.Clear();
1362}
1363
1364bool BaseHeaderProto::MergePartialFromCodedStream(
1365 ::google::protobuf::io::CodedInputStream* input) {
1366#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
1367 ::google::protobuf::uint32 tag;
1368 // @@protoc_insertion_point(parse_start:Hdfs.Internal.BaseHeaderProto)
1369 for (;;) {
1370 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
1371 tag = p.first;
1372 if (!p.second) goto handle_unusual;
1373 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1374 // required .Hdfs.Internal.ExtendedBlockProto block = 1;
1375 case 1: {
1376 if (static_cast< ::google::protobuf::uint8>(tag) ==
1377 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
1378 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
1379 input, mutable_block()));
1380 } else {
1381 goto handle_unusual;
1382 }
1383 break;
1384 }
1385
1386 // optional .Hdfs.Internal.TokenProto token = 2;
1387 case 2: {
1388 if (static_cast< ::google::protobuf::uint8>(tag) ==
1389 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
1390 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
1391 input, mutable_token()));
1392 } else {
1393 goto handle_unusual;
1394 }
1395 break;
1396 }
1397
1398 default: {
1399 handle_unusual:
1400 if (tag == 0) {
1401 goto success;
1402 }
1403 DO_(::google::protobuf::internal::WireFormat::SkipField(
1404 input, tag, _internal_metadata_.mutable_unknown_fields()));
1405 break;
1406 }
1407 }
1408 }
1409success:
1410 // @@protoc_insertion_point(parse_success:Hdfs.Internal.BaseHeaderProto)
1411 return true;
1412failure:
1413 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.BaseHeaderProto)
1414 return false;
1415#undef DO_
1416}
1417
1418void BaseHeaderProto::SerializeWithCachedSizes(
1419 ::google::protobuf::io::CodedOutputStream* output) const {
1420 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.BaseHeaderProto)
1421 ::google::protobuf::uint32 cached_has_bits = 0;
1422 (void) cached_has_bits;
1423
1424 cached_has_bits = _has_bits_[0];
1425 // required .Hdfs.Internal.ExtendedBlockProto block = 1;
1426 if (cached_has_bits & 0x00000001u) {
1427 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1428 1, this->_internal_block(), output);
1429 }
1430
1431 // optional .Hdfs.Internal.TokenProto token = 2;
1432 if (cached_has_bits & 0x00000002u) {
1433 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1434 2, this->_internal_token(), output);
1435 }
1436
1437 if (_internal_metadata_.have_unknown_fields()) {
1438 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1439 _internal_metadata_.unknown_fields(), output);
1440 }
1441 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.BaseHeaderProto)
1442}
1443
1444::google::protobuf::uint8* BaseHeaderProto::InternalSerializeWithCachedSizesToArray(
1445 bool deterministic, ::google::protobuf::uint8* target) const {
1446 (void)deterministic; // Unused
1447 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.BaseHeaderProto)
1448 ::google::protobuf::uint32 cached_has_bits = 0;
1449 (void) cached_has_bits;
1450
1451 cached_has_bits = _has_bits_[0];
1452 // required .Hdfs.Internal.ExtendedBlockProto block = 1;
1453 if (cached_has_bits & 0x00000001u) {
1454 target = ::google::protobuf::internal::WireFormatLite::
1455 InternalWriteMessageToArray(
1456 1, this->_internal_block(), deterministic, target);
1457 }
1458
1459 // optional .Hdfs.Internal.TokenProto token = 2;
1460 if (cached_has_bits & 0x00000002u) {
1461 target = ::google::protobuf::internal::WireFormatLite::
1462 InternalWriteMessageToArray(
1463 2, this->_internal_token(), deterministic, target);
1464 }
1465
1466 if (_internal_metadata_.have_unknown_fields()) {
1467 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1468 _internal_metadata_.unknown_fields(), target);
1469 }
1470 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.BaseHeaderProto)
1471 return target;
1472}
1473
1474size_t BaseHeaderProto::ByteSizeLong() const {
1475// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.BaseHeaderProto)
1476 size_t total_size = 0;
1477
1478 if (_internal_metadata_.have_unknown_fields()) {
1479 total_size +=
1480 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1481 _internal_metadata_.unknown_fields());
1482 }
1483 // required .Hdfs.Internal.ExtendedBlockProto block = 1;
1484 if (has_block()) {
1485 total_size += 1 +
1486 ::google::protobuf::internal::WireFormatLite::MessageSize(
1487 *block_);
1488 }
1489 // optional .Hdfs.Internal.TokenProto token = 2;
1490 if (has_token()) {
1491 total_size += 1 +
1492 ::google::protobuf::internal::WireFormatLite::MessageSize(
1493 *token_);
1494 }
1495
1496 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
1497 SetCachedSize(cached_size);
1498 return total_size;
1499}
1500
1501void BaseHeaderProto::MergeFrom(const ::google::protobuf::Message& from) {
1502// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.BaseHeaderProto)
1503 GOOGLE_DCHECK_NE(&from, this);
1504 const BaseHeaderProto* source =
1505 ::google::protobuf::internal::DynamicCastToGenerated<const BaseHeaderProto>(
1506 &from);
1507 if (source == NULL) {
1508 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.BaseHeaderProto)
1509 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1510 } else {
1511 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.BaseHeaderProto)
1512 MergeFrom(*source);
1513 }
1514}
1515
1516void BaseHeaderProto::MergeFrom(const BaseHeaderProto& from) {
1517// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.BaseHeaderProto)
1518 GOOGLE_DCHECK_NE(&from, this);
1519 _internal_metadata_.MergeFrom(from._internal_metadata_);
1520 ::google::protobuf::uint32 cached_has_bits = 0;
1521 (void) cached_has_bits;
1522
1523 cached_has_bits = from._has_bits_[0];
1524 if (cached_has_bits & 3u) {
1525 if (cached_has_bits & 0x00000001u) {
1526 mutable_block()->::Hdfs::Internal::ExtendedBlockProto::MergeFrom(from.block());
1527 }
1528 if (cached_has_bits & 0x00000002u) {
1529 mutable_token()->::Hdfs::Internal::TokenProto::MergeFrom(from.token());
1530 }
1531 }
1532}
1533
1534void BaseHeaderProto::CopyFrom(const ::google::protobuf::Message& from) {
1535// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.BaseHeaderProto)
1536 if (&from == this) return;
1537 Clear();
1538 MergeFrom(from);
1539}
1540
1541void BaseHeaderProto::CopyFrom(const BaseHeaderProto& from) {
1542// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.BaseHeaderProto)
1543 if (&from == this) return;
1544 Clear();
1545 MergeFrom(from);
1546}
1547
1548bool BaseHeaderProto::IsInitialized() const {
1549 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
1550 if (has_block()) {
1551 if (!this->block_->IsInitialized()) return false;
1552 }
1553 if (has_token()) {
1554 if (!this->token_->IsInitialized()) return false;
1555 }
1556 return true;
1557}
1558
1559void BaseHeaderProto::Swap(BaseHeaderProto* other) {
1560 if (other == this) return;
1561 InternalSwap(other);
1562}
1563void BaseHeaderProto::InternalSwap(BaseHeaderProto* other) {
1564 using std::swap;
1565 swap(block_, other->block_);
1566 swap(token_, other->token_);
1567 swap(_has_bits_[0], other->_has_bits_[0]);
1568 _internal_metadata_.Swap(&other->_internal_metadata_);
1569}
1570
1571::google::protobuf::Metadata BaseHeaderProto::GetMetadata() const {
1572 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
1573 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
1574}
1575
1576
1577// ===================================================================
1578
1579void ClientOperationHeaderProto::InitAsDefaultInstance() {
1580 ::Hdfs::Internal::_ClientOperationHeaderProto_default_instance_._instance.get_mutable()->baseheader_ = const_cast< ::Hdfs::Internal::BaseHeaderProto*>(
1581 ::Hdfs::Internal::BaseHeaderProto::internal_default_instance());
1582}
1583#if !defined(_MSC_VER) || _MSC_VER >= 1900
1584const int ClientOperationHeaderProto::kBaseHeaderFieldNumber;
1585const int ClientOperationHeaderProto::kClientNameFieldNumber;
1586#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
1587
1588ClientOperationHeaderProto::ClientOperationHeaderProto()
1589 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
1590 ::google::protobuf::internal::InitSCC(
1591 &protobuf_datatransfer_2eproto::scc_info_ClientOperationHeaderProto.base);
1592 SharedCtor();
1593 // @@protoc_insertion_point(constructor:Hdfs.Internal.ClientOperationHeaderProto)
1594}
1595ClientOperationHeaderProto::ClientOperationHeaderProto(const ClientOperationHeaderProto& from)
1596 : ::google::protobuf::Message(),
1597 _internal_metadata_(NULL),
1598 _has_bits_(from._has_bits_) {
1599 _internal_metadata_.MergeFrom(from._internal_metadata_);
1600 clientname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1601 if (from.has_clientname()) {
1602 clientname_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.clientname_);
1603 }
1604 if (from.has_baseheader()) {
1605 baseheader_ = new ::Hdfs::Internal::BaseHeaderProto(*from.baseheader_);
1606 } else {
1607 baseheader_ = NULL;
1608 }
1609 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.ClientOperationHeaderProto)
1610}
1611
1612void ClientOperationHeaderProto::SharedCtor() {
1613 clientname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1614 baseheader_ = NULL;
1615}
1616
1617ClientOperationHeaderProto::~ClientOperationHeaderProto() {
1618 // @@protoc_insertion_point(destructor:Hdfs.Internal.ClientOperationHeaderProto)
1619 SharedDtor();
1620}
1621
1622void ClientOperationHeaderProto::SharedDtor() {
1623 clientname_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1624 if (this != internal_default_instance()) delete baseheader_;
1625}
1626
1627void ClientOperationHeaderProto::SetCachedSize(int size) const {
1628 _cached_size_.Set(size);
1629}
1630const ::google::protobuf::Descriptor* ClientOperationHeaderProto::descriptor() {
1631 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
1632 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
1633}
1634
1635const ClientOperationHeaderProto& ClientOperationHeaderProto::default_instance() {
1636 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_ClientOperationHeaderProto.base);
1637 return *internal_default_instance();
1638}
1639
1640
1641void ClientOperationHeaderProto::Clear() {
1642// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.ClientOperationHeaderProto)
1643 ::google::protobuf::uint32 cached_has_bits = 0;
1644 // Prevent compiler warnings about cached_has_bits being unused
1645 (void) cached_has_bits;
1646
1647 cached_has_bits = _has_bits_[0];
1648 if (cached_has_bits & 3u) {
1649 if (cached_has_bits & 0x00000001u) {
1650 clientname_.ClearNonDefaultToEmptyNoArena();
1651 }
1652 if (cached_has_bits & 0x00000002u) {
1653 GOOGLE_DCHECK(baseheader_ != NULL);
1654 baseheader_->Clear();
1655 }
1656 }
1657 _has_bits_.Clear();
1658 _internal_metadata_.Clear();
1659}
1660
1661bool ClientOperationHeaderProto::MergePartialFromCodedStream(
1662 ::google::protobuf::io::CodedInputStream* input) {
1663#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
1664 ::google::protobuf::uint32 tag;
1665 // @@protoc_insertion_point(parse_start:Hdfs.Internal.ClientOperationHeaderProto)
1666 for (;;) {
1667 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
1668 tag = p.first;
1669 if (!p.second) goto handle_unusual;
1670 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1671 // required .Hdfs.Internal.BaseHeaderProto baseHeader = 1;
1672 case 1: {
1673 if (static_cast< ::google::protobuf::uint8>(tag) ==
1674 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
1675 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
1676 input, mutable_baseheader()));
1677 } else {
1678 goto handle_unusual;
1679 }
1680 break;
1681 }
1682
1683 // required string clientName = 2;
1684 case 2: {
1685 if (static_cast< ::google::protobuf::uint8>(tag) ==
1686 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
1687 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1688 input, this->mutable_clientname()));
1689 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1690 this->clientname().data(), static_cast<int>(this->clientname().length()),
1691 ::google::protobuf::internal::WireFormat::PARSE,
1692 "Hdfs.Internal.ClientOperationHeaderProto.clientName");
1693 } else {
1694 goto handle_unusual;
1695 }
1696 break;
1697 }
1698
1699 default: {
1700 handle_unusual:
1701 if (tag == 0) {
1702 goto success;
1703 }
1704 DO_(::google::protobuf::internal::WireFormat::SkipField(
1705 input, tag, _internal_metadata_.mutable_unknown_fields()));
1706 break;
1707 }
1708 }
1709 }
1710success:
1711 // @@protoc_insertion_point(parse_success:Hdfs.Internal.ClientOperationHeaderProto)
1712 return true;
1713failure:
1714 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.ClientOperationHeaderProto)
1715 return false;
1716#undef DO_
1717}
1718
1719void ClientOperationHeaderProto::SerializeWithCachedSizes(
1720 ::google::protobuf::io::CodedOutputStream* output) const {
1721 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.ClientOperationHeaderProto)
1722 ::google::protobuf::uint32 cached_has_bits = 0;
1723 (void) cached_has_bits;
1724
1725 cached_has_bits = _has_bits_[0];
1726 // required .Hdfs.Internal.BaseHeaderProto baseHeader = 1;
1727 if (cached_has_bits & 0x00000002u) {
1728 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1729 1, this->_internal_baseheader(), output);
1730 }
1731
1732 // required string clientName = 2;
1733 if (cached_has_bits & 0x00000001u) {
1734 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1735 this->clientname().data(), static_cast<int>(this->clientname().length()),
1736 ::google::protobuf::internal::WireFormat::SERIALIZE,
1737 "Hdfs.Internal.ClientOperationHeaderProto.clientName");
1738 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1739 2, this->clientname(), output);
1740 }
1741
1742 if (_internal_metadata_.have_unknown_fields()) {
1743 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1744 _internal_metadata_.unknown_fields(), output);
1745 }
1746 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.ClientOperationHeaderProto)
1747}
1748
1749::google::protobuf::uint8* ClientOperationHeaderProto::InternalSerializeWithCachedSizesToArray(
1750 bool deterministic, ::google::protobuf::uint8* target) const {
1751 (void)deterministic; // Unused
1752 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.ClientOperationHeaderProto)
1753 ::google::protobuf::uint32 cached_has_bits = 0;
1754 (void) cached_has_bits;
1755
1756 cached_has_bits = _has_bits_[0];
1757 // required .Hdfs.Internal.BaseHeaderProto baseHeader = 1;
1758 if (cached_has_bits & 0x00000002u) {
1759 target = ::google::protobuf::internal::WireFormatLite::
1760 InternalWriteMessageToArray(
1761 1, this->_internal_baseheader(), deterministic, target);
1762 }
1763
1764 // required string clientName = 2;
1765 if (cached_has_bits & 0x00000001u) {
1766 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1767 this->clientname().data(), static_cast<int>(this->clientname().length()),
1768 ::google::protobuf::internal::WireFormat::SERIALIZE,
1769 "Hdfs.Internal.ClientOperationHeaderProto.clientName");
1770 target =
1771 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1772 2, this->clientname(), target);
1773 }
1774
1775 if (_internal_metadata_.have_unknown_fields()) {
1776 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1777 _internal_metadata_.unknown_fields(), target);
1778 }
1779 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.ClientOperationHeaderProto)
1780 return target;
1781}
1782
1783size_t ClientOperationHeaderProto::RequiredFieldsByteSizeFallback() const {
1784// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.ClientOperationHeaderProto)
1785 size_t total_size = 0;
1786
1787 if (has_clientname()) {
1788 // required string clientName = 2;
1789 total_size += 1 +
1790 ::google::protobuf::internal::WireFormatLite::StringSize(
1791 this->clientname());
1792 }
1793
1794 if (has_baseheader()) {
1795 // required .Hdfs.Internal.BaseHeaderProto baseHeader = 1;
1796 total_size += 1 +
1797 ::google::protobuf::internal::WireFormatLite::MessageSize(
1798 *baseheader_);
1799 }
1800
1801 return total_size;
1802}
1803size_t ClientOperationHeaderProto::ByteSizeLong() const {
1804// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.ClientOperationHeaderProto)
1805 size_t total_size = 0;
1806
1807 if (_internal_metadata_.have_unknown_fields()) {
1808 total_size +=
1809 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1810 _internal_metadata_.unknown_fields());
1811 }
1812 if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present.
1813 // required string clientName = 2;
1814 total_size += 1 +
1815 ::google::protobuf::internal::WireFormatLite::StringSize(
1816 this->clientname());
1817
1818 // required .Hdfs.Internal.BaseHeaderProto baseHeader = 1;
1819 total_size += 1 +
1820 ::google::protobuf::internal::WireFormatLite::MessageSize(
1821 *baseheader_);
1822
1823 } else {
1824 total_size += RequiredFieldsByteSizeFallback();
1825 }
1826 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
1827 SetCachedSize(cached_size);
1828 return total_size;
1829}
1830
1831void ClientOperationHeaderProto::MergeFrom(const ::google::protobuf::Message& from) {
1832// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.ClientOperationHeaderProto)
1833 GOOGLE_DCHECK_NE(&from, this);
1834 const ClientOperationHeaderProto* source =
1835 ::google::protobuf::internal::DynamicCastToGenerated<const ClientOperationHeaderProto>(
1836 &from);
1837 if (source == NULL) {
1838 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.ClientOperationHeaderProto)
1839 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1840 } else {
1841 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.ClientOperationHeaderProto)
1842 MergeFrom(*source);
1843 }
1844}
1845
1846void ClientOperationHeaderProto::MergeFrom(const ClientOperationHeaderProto& from) {
1847// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.ClientOperationHeaderProto)
1848 GOOGLE_DCHECK_NE(&from, this);
1849 _internal_metadata_.MergeFrom(from._internal_metadata_);
1850 ::google::protobuf::uint32 cached_has_bits = 0;
1851 (void) cached_has_bits;
1852
1853 cached_has_bits = from._has_bits_[0];
1854 if (cached_has_bits & 3u) {
1855 if (cached_has_bits & 0x00000001u) {
1856 set_has_clientname();
1857 clientname_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.clientname_);
1858 }
1859 if (cached_has_bits & 0x00000002u) {
1860 mutable_baseheader()->::Hdfs::Internal::BaseHeaderProto::MergeFrom(from.baseheader());
1861 }
1862 }
1863}
1864
1865void ClientOperationHeaderProto::CopyFrom(const ::google::protobuf::Message& from) {
1866// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.ClientOperationHeaderProto)
1867 if (&from == this) return;
1868 Clear();
1869 MergeFrom(from);
1870}
1871
1872void ClientOperationHeaderProto::CopyFrom(const ClientOperationHeaderProto& from) {
1873// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.ClientOperationHeaderProto)
1874 if (&from == this) return;
1875 Clear();
1876 MergeFrom(from);
1877}
1878
1879bool ClientOperationHeaderProto::IsInitialized() const {
1880 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
1881 if (has_baseheader()) {
1882 if (!this->baseheader_->IsInitialized()) return false;
1883 }
1884 return true;
1885}
1886
1887void ClientOperationHeaderProto::Swap(ClientOperationHeaderProto* other) {
1888 if (other == this) return;
1889 InternalSwap(other);
1890}
1891void ClientOperationHeaderProto::InternalSwap(ClientOperationHeaderProto* other) {
1892 using std::swap;
1893 clientname_.Swap(&other->clientname_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1894 GetArenaNoVirtual());
1895 swap(baseheader_, other->baseheader_);
1896 swap(_has_bits_[0], other->_has_bits_[0]);
1897 _internal_metadata_.Swap(&other->_internal_metadata_);
1898}
1899
1900::google::protobuf::Metadata ClientOperationHeaderProto::GetMetadata() const {
1901 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
1902 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
1903}
1904
1905
1906// ===================================================================
1907
1908void CachingStrategyProto::InitAsDefaultInstance() {
1909}
1910#if !defined(_MSC_VER) || _MSC_VER >= 1900
1911const int CachingStrategyProto::kDropBehindFieldNumber;
1912const int CachingStrategyProto::kReadaheadFieldNumber;
1913#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
1914
1915CachingStrategyProto::CachingStrategyProto()
1916 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
1917 ::google::protobuf::internal::InitSCC(
1918 &protobuf_datatransfer_2eproto::scc_info_CachingStrategyProto.base);
1919 SharedCtor();
1920 // @@protoc_insertion_point(constructor:Hdfs.Internal.CachingStrategyProto)
1921}
1922CachingStrategyProto::CachingStrategyProto(const CachingStrategyProto& from)
1923 : ::google::protobuf::Message(),
1924 _internal_metadata_(NULL),
1925 _has_bits_(from._has_bits_) {
1926 _internal_metadata_.MergeFrom(from._internal_metadata_);
1927 ::memcpy(&readahead_, &from.readahead_,
1928 static_cast<size_t>(reinterpret_cast<char*>(&dropbehind_) -
1929 reinterpret_cast<char*>(&readahead_)) + sizeof(dropbehind_));
1930 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.CachingStrategyProto)
1931}
1932
1933void CachingStrategyProto::SharedCtor() {
1934 ::memset(&readahead_, 0, static_cast<size_t>(
1935 reinterpret_cast<char*>(&dropbehind_) -
1936 reinterpret_cast<char*>(&readahead_)) + sizeof(dropbehind_));
1937}
1938
1939CachingStrategyProto::~CachingStrategyProto() {
1940 // @@protoc_insertion_point(destructor:Hdfs.Internal.CachingStrategyProto)
1941 SharedDtor();
1942}
1943
1944void CachingStrategyProto::SharedDtor() {
1945}
1946
1947void CachingStrategyProto::SetCachedSize(int size) const {
1948 _cached_size_.Set(size);
1949}
1950const ::google::protobuf::Descriptor* CachingStrategyProto::descriptor() {
1951 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
1952 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
1953}
1954
1955const CachingStrategyProto& CachingStrategyProto::default_instance() {
1956 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_CachingStrategyProto.base);
1957 return *internal_default_instance();
1958}
1959
1960
1961void CachingStrategyProto::Clear() {
1962// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.CachingStrategyProto)
1963 ::google::protobuf::uint32 cached_has_bits = 0;
1964 // Prevent compiler warnings about cached_has_bits being unused
1965 (void) cached_has_bits;
1966
1967 cached_has_bits = _has_bits_[0];
1968 if (cached_has_bits & 3u) {
1969 ::memset(&readahead_, 0, static_cast<size_t>(
1970 reinterpret_cast<char*>(&dropbehind_) -
1971 reinterpret_cast<char*>(&readahead_)) + sizeof(dropbehind_));
1972 }
1973 _has_bits_.Clear();
1974 _internal_metadata_.Clear();
1975}
1976
1977bool CachingStrategyProto::MergePartialFromCodedStream(
1978 ::google::protobuf::io::CodedInputStream* input) {
1979#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
1980 ::google::protobuf::uint32 tag;
1981 // @@protoc_insertion_point(parse_start:Hdfs.Internal.CachingStrategyProto)
1982 for (;;) {
1983 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
1984 tag = p.first;
1985 if (!p.second) goto handle_unusual;
1986 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1987 // optional bool dropBehind = 1;
1988 case 1: {
1989 if (static_cast< ::google::protobuf::uint8>(tag) ==
1990 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
1991 set_has_dropbehind();
1992 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1993 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
1994 input, &dropbehind_)));
1995 } else {
1996 goto handle_unusual;
1997 }
1998 break;
1999 }
2000
2001 // optional int64 readahead = 2;
2002 case 2: {
2003 if (static_cast< ::google::protobuf::uint8>(tag) ==
2004 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
2005 set_has_readahead();
2006 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2007 ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
2008 input, &readahead_)));
2009 } else {
2010 goto handle_unusual;
2011 }
2012 break;
2013 }
2014
2015 default: {
2016 handle_unusual:
2017 if (tag == 0) {
2018 goto success;
2019 }
2020 DO_(::google::protobuf::internal::WireFormat::SkipField(
2021 input, tag, _internal_metadata_.mutable_unknown_fields()));
2022 break;
2023 }
2024 }
2025 }
2026success:
2027 // @@protoc_insertion_point(parse_success:Hdfs.Internal.CachingStrategyProto)
2028 return true;
2029failure:
2030 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.CachingStrategyProto)
2031 return false;
2032#undef DO_
2033}
2034
2035void CachingStrategyProto::SerializeWithCachedSizes(
2036 ::google::protobuf::io::CodedOutputStream* output) const {
2037 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.CachingStrategyProto)
2038 ::google::protobuf::uint32 cached_has_bits = 0;
2039 (void) cached_has_bits;
2040
2041 cached_has_bits = _has_bits_[0];
2042 // optional bool dropBehind = 1;
2043 if (cached_has_bits & 0x00000002u) {
2044 ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->dropbehind(), output);
2045 }
2046
2047 // optional int64 readahead = 2;
2048 if (cached_has_bits & 0x00000001u) {
2049 ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->readahead(), output);
2050 }
2051
2052 if (_internal_metadata_.have_unknown_fields()) {
2053 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2054 _internal_metadata_.unknown_fields(), output);
2055 }
2056 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.CachingStrategyProto)
2057}
2058
2059::google::protobuf::uint8* CachingStrategyProto::InternalSerializeWithCachedSizesToArray(
2060 bool deterministic, ::google::protobuf::uint8* target) const {
2061 (void)deterministic; // Unused
2062 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.CachingStrategyProto)
2063 ::google::protobuf::uint32 cached_has_bits = 0;
2064 (void) cached_has_bits;
2065
2066 cached_has_bits = _has_bits_[0];
2067 // optional bool dropBehind = 1;
2068 if (cached_has_bits & 0x00000002u) {
2069 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->dropbehind(), target);
2070 }
2071
2072 // optional int64 readahead = 2;
2073 if (cached_has_bits & 0x00000001u) {
2074 target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->readahead(), target);
2075 }
2076
2077 if (_internal_metadata_.have_unknown_fields()) {
2078 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2079 _internal_metadata_.unknown_fields(), target);
2080 }
2081 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.CachingStrategyProto)
2082 return target;
2083}
2084
2085size_t CachingStrategyProto::ByteSizeLong() const {
2086// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.CachingStrategyProto)
2087 size_t total_size = 0;
2088
2089 if (_internal_metadata_.have_unknown_fields()) {
2090 total_size +=
2091 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2092 _internal_metadata_.unknown_fields());
2093 }
2094 if (_has_bits_[0 / 32] & 3u) {
2095 // optional int64 readahead = 2;
2096 if (has_readahead()) {
2097 total_size += 1 +
2098 ::google::protobuf::internal::WireFormatLite::Int64Size(
2099 this->readahead());
2100 }
2101
2102 // optional bool dropBehind = 1;
2103 if (has_dropbehind()) {
2104 total_size += 1 + 1;
2105 }
2106
2107 }
2108 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
2109 SetCachedSize(cached_size);
2110 return total_size;
2111}
2112
2113void CachingStrategyProto::MergeFrom(const ::google::protobuf::Message& from) {
2114// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.CachingStrategyProto)
2115 GOOGLE_DCHECK_NE(&from, this);
2116 const CachingStrategyProto* source =
2117 ::google::protobuf::internal::DynamicCastToGenerated<const CachingStrategyProto>(
2118 &from);
2119 if (source == NULL) {
2120 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.CachingStrategyProto)
2121 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2122 } else {
2123 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.CachingStrategyProto)
2124 MergeFrom(*source);
2125 }
2126}
2127
2128void CachingStrategyProto::MergeFrom(const CachingStrategyProto& from) {
2129// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.CachingStrategyProto)
2130 GOOGLE_DCHECK_NE(&from, this);
2131 _internal_metadata_.MergeFrom(from._internal_metadata_);
2132 ::google::protobuf::uint32 cached_has_bits = 0;
2133 (void) cached_has_bits;
2134
2135 cached_has_bits = from._has_bits_[0];
2136 if (cached_has_bits & 3u) {
2137 if (cached_has_bits & 0x00000001u) {
2138 readahead_ = from.readahead_;
2139 }
2140 if (cached_has_bits & 0x00000002u) {
2141 dropbehind_ = from.dropbehind_;
2142 }
2143 _has_bits_[0] |= cached_has_bits;
2144 }
2145}
2146
2147void CachingStrategyProto::CopyFrom(const ::google::protobuf::Message& from) {
2148// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.CachingStrategyProto)
2149 if (&from == this) return;
2150 Clear();
2151 MergeFrom(from);
2152}
2153
2154void CachingStrategyProto::CopyFrom(const CachingStrategyProto& from) {
2155// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.CachingStrategyProto)
2156 if (&from == this) return;
2157 Clear();
2158 MergeFrom(from);
2159}
2160
2161bool CachingStrategyProto::IsInitialized() const {
2162 return true;
2163}
2164
2165void CachingStrategyProto::Swap(CachingStrategyProto* other) {
2166 if (other == this) return;
2167 InternalSwap(other);
2168}
2169void CachingStrategyProto::InternalSwap(CachingStrategyProto* other) {
2170 using std::swap;
2171 swap(readahead_, other->readahead_);
2172 swap(dropbehind_, other->dropbehind_);
2173 swap(_has_bits_[0], other->_has_bits_[0]);
2174 _internal_metadata_.Swap(&other->_internal_metadata_);
2175}
2176
2177::google::protobuf::Metadata CachingStrategyProto::GetMetadata() const {
2178 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
2179 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
2180}
2181
2182
2183// ===================================================================
2184
2185void OpReadBlockProto::InitAsDefaultInstance() {
2186 ::Hdfs::Internal::_OpReadBlockProto_default_instance_._instance.get_mutable()->header_ = const_cast< ::Hdfs::Internal::ClientOperationHeaderProto*>(
2187 ::Hdfs::Internal::ClientOperationHeaderProto::internal_default_instance());
2188 ::Hdfs::Internal::_OpReadBlockProto_default_instance_._instance.get_mutable()->cachingstrategy_ = const_cast< ::Hdfs::Internal::CachingStrategyProto*>(
2189 ::Hdfs::Internal::CachingStrategyProto::internal_default_instance());
2190}
2191#if !defined(_MSC_VER) || _MSC_VER >= 1900
2192const int OpReadBlockProto::kHeaderFieldNumber;
2193const int OpReadBlockProto::kOffsetFieldNumber;
2194const int OpReadBlockProto::kLenFieldNumber;
2195const int OpReadBlockProto::kSendChecksumsFieldNumber;
2196const int OpReadBlockProto::kCachingStrategyFieldNumber;
2197#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
2198
2199OpReadBlockProto::OpReadBlockProto()
2200 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
2201 ::google::protobuf::internal::InitSCC(
2202 &protobuf_datatransfer_2eproto::scc_info_OpReadBlockProto.base);
2203 SharedCtor();
2204 // @@protoc_insertion_point(constructor:Hdfs.Internal.OpReadBlockProto)
2205}
2206OpReadBlockProto::OpReadBlockProto(const OpReadBlockProto& from)
2207 : ::google::protobuf::Message(),
2208 _internal_metadata_(NULL),
2209 _has_bits_(from._has_bits_) {
2210 _internal_metadata_.MergeFrom(from._internal_metadata_);
2211 if (from.has_header()) {
2212 header_ = new ::Hdfs::Internal::ClientOperationHeaderProto(*from.header_);
2213 } else {
2214 header_ = NULL;
2215 }
2216 if (from.has_cachingstrategy()) {
2217 cachingstrategy_ = new ::Hdfs::Internal::CachingStrategyProto(*from.cachingstrategy_);
2218 } else {
2219 cachingstrategy_ = NULL;
2220 }
2221 ::memcpy(&offset_, &from.offset_,
2222 static_cast<size_t>(reinterpret_cast<char*>(&sendchecksums_) -
2223 reinterpret_cast<char*>(&offset_)) + sizeof(sendchecksums_));
2224 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.OpReadBlockProto)
2225}
2226
2227void OpReadBlockProto::SharedCtor() {
2228 ::memset(&header_, 0, static_cast<size_t>(
2229 reinterpret_cast<char*>(&len_) -
2230 reinterpret_cast<char*>(&header_)) + sizeof(len_));
2231 sendchecksums_ = true;
2232}
2233
2234OpReadBlockProto::~OpReadBlockProto() {
2235 // @@protoc_insertion_point(destructor:Hdfs.Internal.OpReadBlockProto)
2236 SharedDtor();
2237}
2238
2239void OpReadBlockProto::SharedDtor() {
2240 if (this != internal_default_instance()) delete header_;
2241 if (this != internal_default_instance()) delete cachingstrategy_;
2242}
2243
2244void OpReadBlockProto::SetCachedSize(int size) const {
2245 _cached_size_.Set(size);
2246}
2247const ::google::protobuf::Descriptor* OpReadBlockProto::descriptor() {
2248 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
2249 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
2250}
2251
2252const OpReadBlockProto& OpReadBlockProto::default_instance() {
2253 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_OpReadBlockProto.base);
2254 return *internal_default_instance();
2255}
2256
2257
2258void OpReadBlockProto::Clear() {
2259// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.OpReadBlockProto)
2260 ::google::protobuf::uint32 cached_has_bits = 0;
2261 // Prevent compiler warnings about cached_has_bits being unused
2262 (void) cached_has_bits;
2263
2264 cached_has_bits = _has_bits_[0];
2265 if (cached_has_bits & 3u) {
2266 if (cached_has_bits & 0x00000001u) {
2267 GOOGLE_DCHECK(header_ != NULL);
2268 header_->Clear();
2269 }
2270 if (cached_has_bits & 0x00000002u) {
2271 GOOGLE_DCHECK(cachingstrategy_ != NULL);
2272 cachingstrategy_->Clear();
2273 }
2274 }
2275 if (cached_has_bits & 28u) {
2276 ::memset(&offset_, 0, static_cast<size_t>(
2277 reinterpret_cast<char*>(&len_) -
2278 reinterpret_cast<char*>(&offset_)) + sizeof(len_));
2279 sendchecksums_ = true;
2280 }
2281 _has_bits_.Clear();
2282 _internal_metadata_.Clear();
2283}
2284
2285bool OpReadBlockProto::MergePartialFromCodedStream(
2286 ::google::protobuf::io::CodedInputStream* input) {
2287#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
2288 ::google::protobuf::uint32 tag;
2289 // @@protoc_insertion_point(parse_start:Hdfs.Internal.OpReadBlockProto)
2290 for (;;) {
2291 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
2292 tag = p.first;
2293 if (!p.second) goto handle_unusual;
2294 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2295 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
2296 case 1: {
2297 if (static_cast< ::google::protobuf::uint8>(tag) ==
2298 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
2299 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
2300 input, mutable_header()));
2301 } else {
2302 goto handle_unusual;
2303 }
2304 break;
2305 }
2306
2307 // required uint64 offset = 2;
2308 case 2: {
2309 if (static_cast< ::google::protobuf::uint8>(tag) ==
2310 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
2311 set_has_offset();
2312 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2313 ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
2314 input, &offset_)));
2315 } else {
2316 goto handle_unusual;
2317 }
2318 break;
2319 }
2320
2321 // required uint64 len = 3;
2322 case 3: {
2323 if (static_cast< ::google::protobuf::uint8>(tag) ==
2324 static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
2325 set_has_len();
2326 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2327 ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
2328 input, &len_)));
2329 } else {
2330 goto handle_unusual;
2331 }
2332 break;
2333 }
2334
2335 // optional bool sendChecksums = 4 [default = true];
2336 case 4: {
2337 if (static_cast< ::google::protobuf::uint8>(tag) ==
2338 static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
2339 set_has_sendchecksums();
2340 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2341 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
2342 input, &sendchecksums_)));
2343 } else {
2344 goto handle_unusual;
2345 }
2346 break;
2347 }
2348
2349 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 5;
2350 case 5: {
2351 if (static_cast< ::google::protobuf::uint8>(tag) ==
2352 static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
2353 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
2354 input, mutable_cachingstrategy()));
2355 } else {
2356 goto handle_unusual;
2357 }
2358 break;
2359 }
2360
2361 default: {
2362 handle_unusual:
2363 if (tag == 0) {
2364 goto success;
2365 }
2366 DO_(::google::protobuf::internal::WireFormat::SkipField(
2367 input, tag, _internal_metadata_.mutable_unknown_fields()));
2368 break;
2369 }
2370 }
2371 }
2372success:
2373 // @@protoc_insertion_point(parse_success:Hdfs.Internal.OpReadBlockProto)
2374 return true;
2375failure:
2376 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.OpReadBlockProto)
2377 return false;
2378#undef DO_
2379}
2380
2381void OpReadBlockProto::SerializeWithCachedSizes(
2382 ::google::protobuf::io::CodedOutputStream* output) const {
2383 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.OpReadBlockProto)
2384 ::google::protobuf::uint32 cached_has_bits = 0;
2385 (void) cached_has_bits;
2386
2387 cached_has_bits = _has_bits_[0];
2388 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
2389 if (cached_has_bits & 0x00000001u) {
2390 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2391 1, this->_internal_header(), output);
2392 }
2393
2394 // required uint64 offset = 2;
2395 if (cached_has_bits & 0x00000004u) {
2396 ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->offset(), output);
2397 }
2398
2399 // required uint64 len = 3;
2400 if (cached_has_bits & 0x00000008u) {
2401 ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->len(), output);
2402 }
2403
2404 // optional bool sendChecksums = 4 [default = true];
2405 if (cached_has_bits & 0x00000010u) {
2406 ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->sendchecksums(), output);
2407 }
2408
2409 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 5;
2410 if (cached_has_bits & 0x00000002u) {
2411 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2412 5, this->_internal_cachingstrategy(), output);
2413 }
2414
2415 if (_internal_metadata_.have_unknown_fields()) {
2416 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2417 _internal_metadata_.unknown_fields(), output);
2418 }
2419 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.OpReadBlockProto)
2420}
2421
2422::google::protobuf::uint8* OpReadBlockProto::InternalSerializeWithCachedSizesToArray(
2423 bool deterministic, ::google::protobuf::uint8* target) const {
2424 (void)deterministic; // Unused
2425 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.OpReadBlockProto)
2426 ::google::protobuf::uint32 cached_has_bits = 0;
2427 (void) cached_has_bits;
2428
2429 cached_has_bits = _has_bits_[0];
2430 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
2431 if (cached_has_bits & 0x00000001u) {
2432 target = ::google::protobuf::internal::WireFormatLite::
2433 InternalWriteMessageToArray(
2434 1, this->_internal_header(), deterministic, target);
2435 }
2436
2437 // required uint64 offset = 2;
2438 if (cached_has_bits & 0x00000004u) {
2439 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->offset(), target);
2440 }
2441
2442 // required uint64 len = 3;
2443 if (cached_has_bits & 0x00000008u) {
2444 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->len(), target);
2445 }
2446
2447 // optional bool sendChecksums = 4 [default = true];
2448 if (cached_has_bits & 0x00000010u) {
2449 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->sendchecksums(), target);
2450 }
2451
2452 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 5;
2453 if (cached_has_bits & 0x00000002u) {
2454 target = ::google::protobuf::internal::WireFormatLite::
2455 InternalWriteMessageToArray(
2456 5, this->_internal_cachingstrategy(), deterministic, target);
2457 }
2458
2459 if (_internal_metadata_.have_unknown_fields()) {
2460 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2461 _internal_metadata_.unknown_fields(), target);
2462 }
2463 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.OpReadBlockProto)
2464 return target;
2465}
2466
2467size_t OpReadBlockProto::RequiredFieldsByteSizeFallback() const {
2468// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.OpReadBlockProto)
2469 size_t total_size = 0;
2470
2471 if (has_header()) {
2472 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
2473 total_size += 1 +
2474 ::google::protobuf::internal::WireFormatLite::MessageSize(
2475 *header_);
2476 }
2477
2478 if (has_offset()) {
2479 // required uint64 offset = 2;
2480 total_size += 1 +
2481 ::google::protobuf::internal::WireFormatLite::UInt64Size(
2482 this->offset());
2483 }
2484
2485 if (has_len()) {
2486 // required uint64 len = 3;
2487 total_size += 1 +
2488 ::google::protobuf::internal::WireFormatLite::UInt64Size(
2489 this->len());
2490 }
2491
2492 return total_size;
2493}
2494size_t OpReadBlockProto::ByteSizeLong() const {
2495// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.OpReadBlockProto)
2496 size_t total_size = 0;
2497
2498 if (_internal_metadata_.have_unknown_fields()) {
2499 total_size +=
2500 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2501 _internal_metadata_.unknown_fields());
2502 }
2503 if (((_has_bits_[0] & 0x0000000d) ^ 0x0000000d) == 0) { // All required fields are present.
2504 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
2505 total_size += 1 +
2506 ::google::protobuf::internal::WireFormatLite::MessageSize(
2507 *header_);
2508
2509 // required uint64 offset = 2;
2510 total_size += 1 +
2511 ::google::protobuf::internal::WireFormatLite::UInt64Size(
2512 this->offset());
2513
2514 // required uint64 len = 3;
2515 total_size += 1 +
2516 ::google::protobuf::internal::WireFormatLite::UInt64Size(
2517 this->len());
2518
2519 } else {
2520 total_size += RequiredFieldsByteSizeFallback();
2521 }
2522 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 5;
2523 if (has_cachingstrategy()) {
2524 total_size += 1 +
2525 ::google::protobuf::internal::WireFormatLite::MessageSize(
2526 *cachingstrategy_);
2527 }
2528
2529 // optional bool sendChecksums = 4 [default = true];
2530 if (has_sendchecksums()) {
2531 total_size += 1 + 1;
2532 }
2533
2534 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
2535 SetCachedSize(cached_size);
2536 return total_size;
2537}
2538
2539void OpReadBlockProto::MergeFrom(const ::google::protobuf::Message& from) {
2540// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.OpReadBlockProto)
2541 GOOGLE_DCHECK_NE(&from, this);
2542 const OpReadBlockProto* source =
2543 ::google::protobuf::internal::DynamicCastToGenerated<const OpReadBlockProto>(
2544 &from);
2545 if (source == NULL) {
2546 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.OpReadBlockProto)
2547 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2548 } else {
2549 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.OpReadBlockProto)
2550 MergeFrom(*source);
2551 }
2552}
2553
2554void OpReadBlockProto::MergeFrom(const OpReadBlockProto& from) {
2555// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.OpReadBlockProto)
2556 GOOGLE_DCHECK_NE(&from, this);
2557 _internal_metadata_.MergeFrom(from._internal_metadata_);
2558 ::google::protobuf::uint32 cached_has_bits = 0;
2559 (void) cached_has_bits;
2560
2561 cached_has_bits = from._has_bits_[0];
2562 if (cached_has_bits & 31u) {
2563 if (cached_has_bits & 0x00000001u) {
2564 mutable_header()->::Hdfs::Internal::ClientOperationHeaderProto::MergeFrom(from.header());
2565 }
2566 if (cached_has_bits & 0x00000002u) {
2567 mutable_cachingstrategy()->::Hdfs::Internal::CachingStrategyProto::MergeFrom(from.cachingstrategy());
2568 }
2569 if (cached_has_bits & 0x00000004u) {
2570 offset_ = from.offset_;
2571 }
2572 if (cached_has_bits & 0x00000008u) {
2573 len_ = from.len_;
2574 }
2575 if (cached_has_bits & 0x00000010u) {
2576 sendchecksums_ = from.sendchecksums_;
2577 }
2578 _has_bits_[0] |= cached_has_bits;
2579 }
2580}
2581
2582void OpReadBlockProto::CopyFrom(const ::google::protobuf::Message& from) {
2583// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.OpReadBlockProto)
2584 if (&from == this) return;
2585 Clear();
2586 MergeFrom(from);
2587}
2588
2589void OpReadBlockProto::CopyFrom(const OpReadBlockProto& from) {
2590// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.OpReadBlockProto)
2591 if (&from == this) return;
2592 Clear();
2593 MergeFrom(from);
2594}
2595
2596bool OpReadBlockProto::IsInitialized() const {
2597 if ((_has_bits_[0] & 0x0000000d) != 0x0000000d) return false;
2598 if (has_header()) {
2599 if (!this->header_->IsInitialized()) return false;
2600 }
2601 return true;
2602}
2603
2604void OpReadBlockProto::Swap(OpReadBlockProto* other) {
2605 if (other == this) return;
2606 InternalSwap(other);
2607}
2608void OpReadBlockProto::InternalSwap(OpReadBlockProto* other) {
2609 using std::swap;
2610 swap(header_, other->header_);
2611 swap(cachingstrategy_, other->cachingstrategy_);
2612 swap(offset_, other->offset_);
2613 swap(len_, other->len_);
2614 swap(sendchecksums_, other->sendchecksums_);
2615 swap(_has_bits_[0], other->_has_bits_[0]);
2616 _internal_metadata_.Swap(&other->_internal_metadata_);
2617}
2618
2619::google::protobuf::Metadata OpReadBlockProto::GetMetadata() const {
2620 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
2621 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
2622}
2623
2624
2625// ===================================================================
2626
2627void ChecksumProto::InitAsDefaultInstance() {
2628}
2629#if !defined(_MSC_VER) || _MSC_VER >= 1900
2630const int ChecksumProto::kTypeFieldNumber;
2631const int ChecksumProto::kBytesPerChecksumFieldNumber;
2632#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
2633
2634ChecksumProto::ChecksumProto()
2635 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
2636 ::google::protobuf::internal::InitSCC(
2637 &protobuf_datatransfer_2eproto::scc_info_ChecksumProto.base);
2638 SharedCtor();
2639 // @@protoc_insertion_point(constructor:Hdfs.Internal.ChecksumProto)
2640}
2641ChecksumProto::ChecksumProto(const ChecksumProto& from)
2642 : ::google::protobuf::Message(),
2643 _internal_metadata_(NULL),
2644 _has_bits_(from._has_bits_) {
2645 _internal_metadata_.MergeFrom(from._internal_metadata_);
2646 ::memcpy(&type_, &from.type_,
2647 static_cast<size_t>(reinterpret_cast<char*>(&bytesperchecksum_) -
2648 reinterpret_cast<char*>(&type_)) + sizeof(bytesperchecksum_));
2649 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.ChecksumProto)
2650}
2651
2652void ChecksumProto::SharedCtor() {
2653 ::memset(&type_, 0, static_cast<size_t>(
2654 reinterpret_cast<char*>(&bytesperchecksum_) -
2655 reinterpret_cast<char*>(&type_)) + sizeof(bytesperchecksum_));
2656}
2657
2658ChecksumProto::~ChecksumProto() {
2659 // @@protoc_insertion_point(destructor:Hdfs.Internal.ChecksumProto)
2660 SharedDtor();
2661}
2662
2663void ChecksumProto::SharedDtor() {
2664}
2665
2666void ChecksumProto::SetCachedSize(int size) const {
2667 _cached_size_.Set(size);
2668}
2669const ::google::protobuf::Descriptor* ChecksumProto::descriptor() {
2670 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
2671 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
2672}
2673
2674const ChecksumProto& ChecksumProto::default_instance() {
2675 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_ChecksumProto.base);
2676 return *internal_default_instance();
2677}
2678
2679
2680void ChecksumProto::Clear() {
2681// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.ChecksumProto)
2682 ::google::protobuf::uint32 cached_has_bits = 0;
2683 // Prevent compiler warnings about cached_has_bits being unused
2684 (void) cached_has_bits;
2685
2686 cached_has_bits = _has_bits_[0];
2687 if (cached_has_bits & 3u) {
2688 ::memset(&type_, 0, static_cast<size_t>(
2689 reinterpret_cast<char*>(&bytesperchecksum_) -
2690 reinterpret_cast<char*>(&type_)) + sizeof(bytesperchecksum_));
2691 }
2692 _has_bits_.Clear();
2693 _internal_metadata_.Clear();
2694}
2695
2696bool ChecksumProto::MergePartialFromCodedStream(
2697 ::google::protobuf::io::CodedInputStream* input) {
2698#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
2699 ::google::protobuf::uint32 tag;
2700 // @@protoc_insertion_point(parse_start:Hdfs.Internal.ChecksumProto)
2701 for (;;) {
2702 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
2703 tag = p.first;
2704 if (!p.second) goto handle_unusual;
2705 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2706 // required .Hdfs.Internal.ChecksumTypeProto type = 1;
2707 case 1: {
2708 if (static_cast< ::google::protobuf::uint8>(tag) ==
2709 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
2710 int value;
2711 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2712 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
2713 input, &value)));
2714 if (::Hdfs::Internal::ChecksumTypeProto_IsValid(value)) {
2715 set_type(static_cast< ::Hdfs::Internal::ChecksumTypeProto >(value));
2716 } else {
2717 mutable_unknown_fields()->AddVarint(
2718 1, static_cast< ::google::protobuf::uint64>(value));
2719 }
2720 } else {
2721 goto handle_unusual;
2722 }
2723 break;
2724 }
2725
2726 // required uint32 bytesPerChecksum = 2;
2727 case 2: {
2728 if (static_cast< ::google::protobuf::uint8>(tag) ==
2729 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
2730 set_has_bytesperchecksum();
2731 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2732 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
2733 input, &bytesperchecksum_)));
2734 } else {
2735 goto handle_unusual;
2736 }
2737 break;
2738 }
2739
2740 default: {
2741 handle_unusual:
2742 if (tag == 0) {
2743 goto success;
2744 }
2745 DO_(::google::protobuf::internal::WireFormat::SkipField(
2746 input, tag, _internal_metadata_.mutable_unknown_fields()));
2747 break;
2748 }
2749 }
2750 }
2751success:
2752 // @@protoc_insertion_point(parse_success:Hdfs.Internal.ChecksumProto)
2753 return true;
2754failure:
2755 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.ChecksumProto)
2756 return false;
2757#undef DO_
2758}
2759
2760void ChecksumProto::SerializeWithCachedSizes(
2761 ::google::protobuf::io::CodedOutputStream* output) const {
2762 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.ChecksumProto)
2763 ::google::protobuf::uint32 cached_has_bits = 0;
2764 (void) cached_has_bits;
2765
2766 cached_has_bits = _has_bits_[0];
2767 // required .Hdfs.Internal.ChecksumTypeProto type = 1;
2768 if (cached_has_bits & 0x00000001u) {
2769 ::google::protobuf::internal::WireFormatLite::WriteEnum(
2770 1, this->type(), output);
2771 }
2772
2773 // required uint32 bytesPerChecksum = 2;
2774 if (cached_has_bits & 0x00000002u) {
2775 ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->bytesperchecksum(), output);
2776 }
2777
2778 if (_internal_metadata_.have_unknown_fields()) {
2779 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2780 _internal_metadata_.unknown_fields(), output);
2781 }
2782 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.ChecksumProto)
2783}
2784
2785::google::protobuf::uint8* ChecksumProto::InternalSerializeWithCachedSizesToArray(
2786 bool deterministic, ::google::protobuf::uint8* target) const {
2787 (void)deterministic; // Unused
2788 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.ChecksumProto)
2789 ::google::protobuf::uint32 cached_has_bits = 0;
2790 (void) cached_has_bits;
2791
2792 cached_has_bits = _has_bits_[0];
2793 // required .Hdfs.Internal.ChecksumTypeProto type = 1;
2794 if (cached_has_bits & 0x00000001u) {
2795 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
2796 1, this->type(), target);
2797 }
2798
2799 // required uint32 bytesPerChecksum = 2;
2800 if (cached_has_bits & 0x00000002u) {
2801 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->bytesperchecksum(), target);
2802 }
2803
2804 if (_internal_metadata_.have_unknown_fields()) {
2805 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2806 _internal_metadata_.unknown_fields(), target);
2807 }
2808 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.ChecksumProto)
2809 return target;
2810}
2811
2812size_t ChecksumProto::RequiredFieldsByteSizeFallback() const {
2813// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.ChecksumProto)
2814 size_t total_size = 0;
2815
2816 if (has_type()) {
2817 // required .Hdfs.Internal.ChecksumTypeProto type = 1;
2818 total_size += 1 +
2819 ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
2820 }
2821
2822 if (has_bytesperchecksum()) {
2823 // required uint32 bytesPerChecksum = 2;
2824 total_size += 1 +
2825 ::google::protobuf::internal::WireFormatLite::UInt32Size(
2826 this->bytesperchecksum());
2827 }
2828
2829 return total_size;
2830}
2831size_t ChecksumProto::ByteSizeLong() const {
2832// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.ChecksumProto)
2833 size_t total_size = 0;
2834
2835 if (_internal_metadata_.have_unknown_fields()) {
2836 total_size +=
2837 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2838 _internal_metadata_.unknown_fields());
2839 }
2840 if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present.
2841 // required .Hdfs.Internal.ChecksumTypeProto type = 1;
2842 total_size += 1 +
2843 ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
2844
2845 // required uint32 bytesPerChecksum = 2;
2846 total_size += 1 +
2847 ::google::protobuf::internal::WireFormatLite::UInt32Size(
2848 this->bytesperchecksum());
2849
2850 } else {
2851 total_size += RequiredFieldsByteSizeFallback();
2852 }
2853 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
2854 SetCachedSize(cached_size);
2855 return total_size;
2856}
2857
2858void ChecksumProto::MergeFrom(const ::google::protobuf::Message& from) {
2859// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.ChecksumProto)
2860 GOOGLE_DCHECK_NE(&from, this);
2861 const ChecksumProto* source =
2862 ::google::protobuf::internal::DynamicCastToGenerated<const ChecksumProto>(
2863 &from);
2864 if (source == NULL) {
2865 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.ChecksumProto)
2866 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2867 } else {
2868 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.ChecksumProto)
2869 MergeFrom(*source);
2870 }
2871}
2872
2873void ChecksumProto::MergeFrom(const ChecksumProto& from) {
2874// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.ChecksumProto)
2875 GOOGLE_DCHECK_NE(&from, this);
2876 _internal_metadata_.MergeFrom(from._internal_metadata_);
2877 ::google::protobuf::uint32 cached_has_bits = 0;
2878 (void) cached_has_bits;
2879
2880 cached_has_bits = from._has_bits_[0];
2881 if (cached_has_bits & 3u) {
2882 if (cached_has_bits & 0x00000001u) {
2883 type_ = from.type_;
2884 }
2885 if (cached_has_bits & 0x00000002u) {
2886 bytesperchecksum_ = from.bytesperchecksum_;
2887 }
2888 _has_bits_[0] |= cached_has_bits;
2889 }
2890}
2891
2892void ChecksumProto::CopyFrom(const ::google::protobuf::Message& from) {
2893// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.ChecksumProto)
2894 if (&from == this) return;
2895 Clear();
2896 MergeFrom(from);
2897}
2898
2899void ChecksumProto::CopyFrom(const ChecksumProto& from) {
2900// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.ChecksumProto)
2901 if (&from == this) return;
2902 Clear();
2903 MergeFrom(from);
2904}
2905
2906bool ChecksumProto::IsInitialized() const {
2907 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
2908 return true;
2909}
2910
2911void ChecksumProto::Swap(ChecksumProto* other) {
2912 if (other == this) return;
2913 InternalSwap(other);
2914}
2915void ChecksumProto::InternalSwap(ChecksumProto* other) {
2916 using std::swap;
2917 swap(type_, other->type_);
2918 swap(bytesperchecksum_, other->bytesperchecksum_);
2919 swap(_has_bits_[0], other->_has_bits_[0]);
2920 _internal_metadata_.Swap(&other->_internal_metadata_);
2921}
2922
2923::google::protobuf::Metadata ChecksumProto::GetMetadata() const {
2924 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
2925 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
2926}
2927
2928
2929// ===================================================================
2930
2931void OpWriteBlockProto::InitAsDefaultInstance() {
2932 ::Hdfs::Internal::_OpWriteBlockProto_default_instance_._instance.get_mutable()->header_ = const_cast< ::Hdfs::Internal::ClientOperationHeaderProto*>(
2933 ::Hdfs::Internal::ClientOperationHeaderProto::internal_default_instance());
2934 ::Hdfs::Internal::_OpWriteBlockProto_default_instance_._instance.get_mutable()->source_ = const_cast< ::Hdfs::Internal::DatanodeInfoProto*>(
2935 ::Hdfs::Internal::DatanodeInfoProto::internal_default_instance());
2936 ::Hdfs::Internal::_OpWriteBlockProto_default_instance_._instance.get_mutable()->requestedchecksum_ = const_cast< ::Hdfs::Internal::ChecksumProto*>(
2937 ::Hdfs::Internal::ChecksumProto::internal_default_instance());
2938 ::Hdfs::Internal::_OpWriteBlockProto_default_instance_._instance.get_mutable()->cachingstrategy_ = const_cast< ::Hdfs::Internal::CachingStrategyProto*>(
2939 ::Hdfs::Internal::CachingStrategyProto::internal_default_instance());
2940}
2941void OpWriteBlockProto::clear_targets() {
2942 targets_.Clear();
2943}
2944void OpWriteBlockProto::clear_source() {
2945 if (source_ != NULL) source_->Clear();
2946 clear_has_source();
2947}
2948#if !defined(_MSC_VER) || _MSC_VER >= 1900
2949const int OpWriteBlockProto::kHeaderFieldNumber;
2950const int OpWriteBlockProto::kTargetsFieldNumber;
2951const int OpWriteBlockProto::kSourceFieldNumber;
2952const int OpWriteBlockProto::kStageFieldNumber;
2953const int OpWriteBlockProto::kPipelineSizeFieldNumber;
2954const int OpWriteBlockProto::kMinBytesRcvdFieldNumber;
2955const int OpWriteBlockProto::kMaxBytesRcvdFieldNumber;
2956const int OpWriteBlockProto::kLatestGenerationStampFieldNumber;
2957const int OpWriteBlockProto::kRequestedChecksumFieldNumber;
2958const int OpWriteBlockProto::kCachingStrategyFieldNumber;
2959#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
2960
2961OpWriteBlockProto::OpWriteBlockProto()
2962 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
2963 ::google::protobuf::internal::InitSCC(
2964 &protobuf_datatransfer_2eproto::scc_info_OpWriteBlockProto.base);
2965 SharedCtor();
2966 // @@protoc_insertion_point(constructor:Hdfs.Internal.OpWriteBlockProto)
2967}
2968OpWriteBlockProto::OpWriteBlockProto(const OpWriteBlockProto& from)
2969 : ::google::protobuf::Message(),
2970 _internal_metadata_(NULL),
2971 _has_bits_(from._has_bits_),
2972 targets_(from.targets_) {
2973 _internal_metadata_.MergeFrom(from._internal_metadata_);
2974 if (from.has_header()) {
2975 header_ = new ::Hdfs::Internal::ClientOperationHeaderProto(*from.header_);
2976 } else {
2977 header_ = NULL;
2978 }
2979 if (from.has_source()) {
2980 source_ = new ::Hdfs::Internal::DatanodeInfoProto(*from.source_);
2981 } else {
2982 source_ = NULL;
2983 }
2984 if (from.has_requestedchecksum()) {
2985 requestedchecksum_ = new ::Hdfs::Internal::ChecksumProto(*from.requestedchecksum_);
2986 } else {
2987 requestedchecksum_ = NULL;
2988 }
2989 if (from.has_cachingstrategy()) {
2990 cachingstrategy_ = new ::Hdfs::Internal::CachingStrategyProto(*from.cachingstrategy_);
2991 } else {
2992 cachingstrategy_ = NULL;
2993 }
2994 ::memcpy(&stage_, &from.stage_,
2995 static_cast<size_t>(reinterpret_cast<char*>(&latestgenerationstamp_) -
2996 reinterpret_cast<char*>(&stage_)) + sizeof(latestgenerationstamp_));
2997 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.OpWriteBlockProto)
2998}
2999
3000void OpWriteBlockProto::SharedCtor() {
3001 ::memset(&header_, 0, static_cast<size_t>(
3002 reinterpret_cast<char*>(&latestgenerationstamp_) -
3003 reinterpret_cast<char*>(&header_)) + sizeof(latestgenerationstamp_));
3004}
3005
3006OpWriteBlockProto::~OpWriteBlockProto() {
3007 // @@protoc_insertion_point(destructor:Hdfs.Internal.OpWriteBlockProto)
3008 SharedDtor();
3009}
3010
3011void OpWriteBlockProto::SharedDtor() {
3012 if (this != internal_default_instance()) delete header_;
3013 if (this != internal_default_instance()) delete source_;
3014 if (this != internal_default_instance()) delete requestedchecksum_;
3015 if (this != internal_default_instance()) delete cachingstrategy_;
3016}
3017
3018void OpWriteBlockProto::SetCachedSize(int size) const {
3019 _cached_size_.Set(size);
3020}
3021const ::google::protobuf::Descriptor* OpWriteBlockProto::descriptor() {
3022 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
3023 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
3024}
3025
3026const OpWriteBlockProto& OpWriteBlockProto::default_instance() {
3027 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_OpWriteBlockProto.base);
3028 return *internal_default_instance();
3029}
3030
3031
3032void OpWriteBlockProto::Clear() {
3033// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.OpWriteBlockProto)
3034 ::google::protobuf::uint32 cached_has_bits = 0;
3035 // Prevent compiler warnings about cached_has_bits being unused
3036 (void) cached_has_bits;
3037
3038 targets_.Clear();
3039 cached_has_bits = _has_bits_[0];
3040 if (cached_has_bits & 15u) {
3041 if (cached_has_bits & 0x00000001u) {
3042 GOOGLE_DCHECK(header_ != NULL);
3043 header_->Clear();
3044 }
3045 if (cached_has_bits & 0x00000002u) {
3046 GOOGLE_DCHECK(source_ != NULL);
3047 source_->Clear();
3048 }
3049 if (cached_has_bits & 0x00000004u) {
3050 GOOGLE_DCHECK(requestedchecksum_ != NULL);
3051 requestedchecksum_->Clear();
3052 }
3053 if (cached_has_bits & 0x00000008u) {
3054 GOOGLE_DCHECK(cachingstrategy_ != NULL);
3055 cachingstrategy_->Clear();
3056 }
3057 }
3058 if (cached_has_bits & 240u) {
3059 ::memset(&stage_, 0, static_cast<size_t>(
3060 reinterpret_cast<char*>(&maxbytesrcvd_) -
3061 reinterpret_cast<char*>(&stage_)) + sizeof(maxbytesrcvd_));
3062 }
3063 latestgenerationstamp_ = GOOGLE_ULONGLONG(0);
3064 _has_bits_.Clear();
3065 _internal_metadata_.Clear();
3066}
3067
3068bool OpWriteBlockProto::MergePartialFromCodedStream(
3069 ::google::protobuf::io::CodedInputStream* input) {
3070#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
3071 ::google::protobuf::uint32 tag;
3072 // @@protoc_insertion_point(parse_start:Hdfs.Internal.OpWriteBlockProto)
3073 for (;;) {
3074 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
3075 tag = p.first;
3076 if (!p.second) goto handle_unusual;
3077 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3078 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3079 case 1: {
3080 if (static_cast< ::google::protobuf::uint8>(tag) ==
3081 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
3082 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
3083 input, mutable_header()));
3084 } else {
3085 goto handle_unusual;
3086 }
3087 break;
3088 }
3089
3090 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3091 case 2: {
3092 if (static_cast< ::google::protobuf::uint8>(tag) ==
3093 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
3094 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
3095 input, add_targets()));
3096 } else {
3097 goto handle_unusual;
3098 }
3099 break;
3100 }
3101
3102 // optional .Hdfs.Internal.DatanodeInfoProto source = 3;
3103 case 3: {
3104 if (static_cast< ::google::protobuf::uint8>(tag) ==
3105 static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
3106 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
3107 input, mutable_source()));
3108 } else {
3109 goto handle_unusual;
3110 }
3111 break;
3112 }
3113
3114 // required .Hdfs.Internal.OpWriteBlockProto.BlockConstructionStage stage = 4;
3115 case 4: {
3116 if (static_cast< ::google::protobuf::uint8>(tag) ==
3117 static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
3118 int value;
3119 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3120 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
3121 input, &value)));
3122 if (::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage_IsValid(value)) {
3123 set_stage(static_cast< ::Hdfs::Internal::OpWriteBlockProto_BlockConstructionStage >(value));
3124 } else {
3125 mutable_unknown_fields()->AddVarint(
3126 4, static_cast< ::google::protobuf::uint64>(value));
3127 }
3128 } else {
3129 goto handle_unusual;
3130 }
3131 break;
3132 }
3133
3134 // required uint32 pipelineSize = 5;
3135 case 5: {
3136 if (static_cast< ::google::protobuf::uint8>(tag) ==
3137 static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
3138 set_has_pipelinesize();
3139 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3140 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
3141 input, &pipelinesize_)));
3142 } else {
3143 goto handle_unusual;
3144 }
3145 break;
3146 }
3147
3148 // required uint64 minBytesRcvd = 6;
3149 case 6: {
3150 if (static_cast< ::google::protobuf::uint8>(tag) ==
3151 static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
3152 set_has_minbytesrcvd();
3153 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3154 ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
3155 input, &minbytesrcvd_)));
3156 } else {
3157 goto handle_unusual;
3158 }
3159 break;
3160 }
3161
3162 // required uint64 maxBytesRcvd = 7;
3163 case 7: {
3164 if (static_cast< ::google::protobuf::uint8>(tag) ==
3165 static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
3166 set_has_maxbytesrcvd();
3167 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3168 ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
3169 input, &maxbytesrcvd_)));
3170 } else {
3171 goto handle_unusual;
3172 }
3173 break;
3174 }
3175
3176 // required uint64 latestGenerationStamp = 8;
3177 case 8: {
3178 if (static_cast< ::google::protobuf::uint8>(tag) ==
3179 static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
3180 set_has_latestgenerationstamp();
3181 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3182 ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
3183 input, &latestgenerationstamp_)));
3184 } else {
3185 goto handle_unusual;
3186 }
3187 break;
3188 }
3189
3190 // required .Hdfs.Internal.ChecksumProto requestedChecksum = 9;
3191 case 9: {
3192 if (static_cast< ::google::protobuf::uint8>(tag) ==
3193 static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) {
3194 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
3195 input, mutable_requestedchecksum()));
3196 } else {
3197 goto handle_unusual;
3198 }
3199 break;
3200 }
3201
3202 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 10;
3203 case 10: {
3204 if (static_cast< ::google::protobuf::uint8>(tag) ==
3205 static_cast< ::google::protobuf::uint8>(82u /* 82 & 0xFF */)) {
3206 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
3207 input, mutable_cachingstrategy()));
3208 } else {
3209 goto handle_unusual;
3210 }
3211 break;
3212 }
3213
3214 default: {
3215 handle_unusual:
3216 if (tag == 0) {
3217 goto success;
3218 }
3219 DO_(::google::protobuf::internal::WireFormat::SkipField(
3220 input, tag, _internal_metadata_.mutable_unknown_fields()));
3221 break;
3222 }
3223 }
3224 }
3225success:
3226 // @@protoc_insertion_point(parse_success:Hdfs.Internal.OpWriteBlockProto)
3227 return true;
3228failure:
3229 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.OpWriteBlockProto)
3230 return false;
3231#undef DO_
3232}
3233
3234void OpWriteBlockProto::SerializeWithCachedSizes(
3235 ::google::protobuf::io::CodedOutputStream* output) const {
3236 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.OpWriteBlockProto)
3237 ::google::protobuf::uint32 cached_has_bits = 0;
3238 (void) cached_has_bits;
3239
3240 cached_has_bits = _has_bits_[0];
3241 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3242 if (cached_has_bits & 0x00000001u) {
3243 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3244 1, this->_internal_header(), output);
3245 }
3246
3247 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3248 for (unsigned int i = 0,
3249 n = static_cast<unsigned int>(this->targets_size()); i < n; i++) {
3250 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3251 2,
3252 this->targets(static_cast<int>(i)),
3253 output);
3254 }
3255
3256 // optional .Hdfs.Internal.DatanodeInfoProto source = 3;
3257 if (cached_has_bits & 0x00000002u) {
3258 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3259 3, this->_internal_source(), output);
3260 }
3261
3262 // required .Hdfs.Internal.OpWriteBlockProto.BlockConstructionStage stage = 4;
3263 if (cached_has_bits & 0x00000010u) {
3264 ::google::protobuf::internal::WireFormatLite::WriteEnum(
3265 4, this->stage(), output);
3266 }
3267
3268 // required uint32 pipelineSize = 5;
3269 if (cached_has_bits & 0x00000020u) {
3270 ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->pipelinesize(), output);
3271 }
3272
3273 // required uint64 minBytesRcvd = 6;
3274 if (cached_has_bits & 0x00000040u) {
3275 ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->minbytesrcvd(), output);
3276 }
3277
3278 // required uint64 maxBytesRcvd = 7;
3279 if (cached_has_bits & 0x00000080u) {
3280 ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->maxbytesrcvd(), output);
3281 }
3282
3283 // required uint64 latestGenerationStamp = 8;
3284 if (cached_has_bits & 0x00000100u) {
3285 ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->latestgenerationstamp(), output);
3286 }
3287
3288 // required .Hdfs.Internal.ChecksumProto requestedChecksum = 9;
3289 if (cached_has_bits & 0x00000004u) {
3290 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3291 9, this->_internal_requestedchecksum(), output);
3292 }
3293
3294 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 10;
3295 if (cached_has_bits & 0x00000008u) {
3296 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3297 10, this->_internal_cachingstrategy(), output);
3298 }
3299
3300 if (_internal_metadata_.have_unknown_fields()) {
3301 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3302 _internal_metadata_.unknown_fields(), output);
3303 }
3304 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.OpWriteBlockProto)
3305}
3306
3307::google::protobuf::uint8* OpWriteBlockProto::InternalSerializeWithCachedSizesToArray(
3308 bool deterministic, ::google::protobuf::uint8* target) const {
3309 (void)deterministic; // Unused
3310 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.OpWriteBlockProto)
3311 ::google::protobuf::uint32 cached_has_bits = 0;
3312 (void) cached_has_bits;
3313
3314 cached_has_bits = _has_bits_[0];
3315 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3316 if (cached_has_bits & 0x00000001u) {
3317 target = ::google::protobuf::internal::WireFormatLite::
3318 InternalWriteMessageToArray(
3319 1, this->_internal_header(), deterministic, target);
3320 }
3321
3322 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3323 for (unsigned int i = 0,
3324 n = static_cast<unsigned int>(this->targets_size()); i < n; i++) {
3325 target = ::google::protobuf::internal::WireFormatLite::
3326 InternalWriteMessageToArray(
3327 2, this->targets(static_cast<int>(i)), deterministic, target);
3328 }
3329
3330 // optional .Hdfs.Internal.DatanodeInfoProto source = 3;
3331 if (cached_has_bits & 0x00000002u) {
3332 target = ::google::protobuf::internal::WireFormatLite::
3333 InternalWriteMessageToArray(
3334 3, this->_internal_source(), deterministic, target);
3335 }
3336
3337 // required .Hdfs.Internal.OpWriteBlockProto.BlockConstructionStage stage = 4;
3338 if (cached_has_bits & 0x00000010u) {
3339 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
3340 4, this->stage(), target);
3341 }
3342
3343 // required uint32 pipelineSize = 5;
3344 if (cached_has_bits & 0x00000020u) {
3345 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->pipelinesize(), target);
3346 }
3347
3348 // required uint64 minBytesRcvd = 6;
3349 if (cached_has_bits & 0x00000040u) {
3350 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->minbytesrcvd(), target);
3351 }
3352
3353 // required uint64 maxBytesRcvd = 7;
3354 if (cached_has_bits & 0x00000080u) {
3355 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->maxbytesrcvd(), target);
3356 }
3357
3358 // required uint64 latestGenerationStamp = 8;
3359 if (cached_has_bits & 0x00000100u) {
3360 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->latestgenerationstamp(), target);
3361 }
3362
3363 // required .Hdfs.Internal.ChecksumProto requestedChecksum = 9;
3364 if (cached_has_bits & 0x00000004u) {
3365 target = ::google::protobuf::internal::WireFormatLite::
3366 InternalWriteMessageToArray(
3367 9, this->_internal_requestedchecksum(), deterministic, target);
3368 }
3369
3370 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 10;
3371 if (cached_has_bits & 0x00000008u) {
3372 target = ::google::protobuf::internal::WireFormatLite::
3373 InternalWriteMessageToArray(
3374 10, this->_internal_cachingstrategy(), deterministic, target);
3375 }
3376
3377 if (_internal_metadata_.have_unknown_fields()) {
3378 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3379 _internal_metadata_.unknown_fields(), target);
3380 }
3381 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.OpWriteBlockProto)
3382 return target;
3383}
3384
3385size_t OpWriteBlockProto::RequiredFieldsByteSizeFallback() const {
3386// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.OpWriteBlockProto)
3387 size_t total_size = 0;
3388
3389 if (has_header()) {
3390 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3391 total_size += 1 +
3392 ::google::protobuf::internal::WireFormatLite::MessageSize(
3393 *header_);
3394 }
3395
3396 if (has_requestedchecksum()) {
3397 // required .Hdfs.Internal.ChecksumProto requestedChecksum = 9;
3398 total_size += 1 +
3399 ::google::protobuf::internal::WireFormatLite::MessageSize(
3400 *requestedchecksum_);
3401 }
3402
3403 if (has_stage()) {
3404 // required .Hdfs.Internal.OpWriteBlockProto.BlockConstructionStage stage = 4;
3405 total_size += 1 +
3406 ::google::protobuf::internal::WireFormatLite::EnumSize(this->stage());
3407 }
3408
3409 if (has_pipelinesize()) {
3410 // required uint32 pipelineSize = 5;
3411 total_size += 1 +
3412 ::google::protobuf::internal::WireFormatLite::UInt32Size(
3413 this->pipelinesize());
3414 }
3415
3416 if (has_minbytesrcvd()) {
3417 // required uint64 minBytesRcvd = 6;
3418 total_size += 1 +
3419 ::google::protobuf::internal::WireFormatLite::UInt64Size(
3420 this->minbytesrcvd());
3421 }
3422
3423 if (has_maxbytesrcvd()) {
3424 // required uint64 maxBytesRcvd = 7;
3425 total_size += 1 +
3426 ::google::protobuf::internal::WireFormatLite::UInt64Size(
3427 this->maxbytesrcvd());
3428 }
3429
3430 if (has_latestgenerationstamp()) {
3431 // required uint64 latestGenerationStamp = 8;
3432 total_size += 1 +
3433 ::google::protobuf::internal::WireFormatLite::UInt64Size(
3434 this->latestgenerationstamp());
3435 }
3436
3437 return total_size;
3438}
3439size_t OpWriteBlockProto::ByteSizeLong() const {
3440// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.OpWriteBlockProto)
3441 size_t total_size = 0;
3442
3443 if (_internal_metadata_.have_unknown_fields()) {
3444 total_size +=
3445 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3446 _internal_metadata_.unknown_fields());
3447 }
3448 if (((_has_bits_[0] & 0x000001f5) ^ 0x000001f5) == 0) { // All required fields are present.
3449 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3450 total_size += 1 +
3451 ::google::protobuf::internal::WireFormatLite::MessageSize(
3452 *header_);
3453
3454 // required .Hdfs.Internal.ChecksumProto requestedChecksum = 9;
3455 total_size += 1 +
3456 ::google::protobuf::internal::WireFormatLite::MessageSize(
3457 *requestedchecksum_);
3458
3459 // required .Hdfs.Internal.OpWriteBlockProto.BlockConstructionStage stage = 4;
3460 total_size += 1 +
3461 ::google::protobuf::internal::WireFormatLite::EnumSize(this->stage());
3462
3463 // required uint32 pipelineSize = 5;
3464 total_size += 1 +
3465 ::google::protobuf::internal::WireFormatLite::UInt32Size(
3466 this->pipelinesize());
3467
3468 // required uint64 minBytesRcvd = 6;
3469 total_size += 1 +
3470 ::google::protobuf::internal::WireFormatLite::UInt64Size(
3471 this->minbytesrcvd());
3472
3473 // required uint64 maxBytesRcvd = 7;
3474 total_size += 1 +
3475 ::google::protobuf::internal::WireFormatLite::UInt64Size(
3476 this->maxbytesrcvd());
3477
3478 // required uint64 latestGenerationStamp = 8;
3479 total_size += 1 +
3480 ::google::protobuf::internal::WireFormatLite::UInt64Size(
3481 this->latestgenerationstamp());
3482
3483 } else {
3484 total_size += RequiredFieldsByteSizeFallback();
3485 }
3486 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3487 {
3488 unsigned int count = static_cast<unsigned int>(this->targets_size());
3489 total_size += 1UL * count;
3490 for (unsigned int i = 0; i < count; i++) {
3491 total_size +=
3492 ::google::protobuf::internal::WireFormatLite::MessageSize(
3493 this->targets(static_cast<int>(i)));
3494 }
3495 }
3496
3497 // optional .Hdfs.Internal.DatanodeInfoProto source = 3;
3498 if (has_source()) {
3499 total_size += 1 +
3500 ::google::protobuf::internal::WireFormatLite::MessageSize(
3501 *source_);
3502 }
3503
3504 // optional .Hdfs.Internal.CachingStrategyProto cachingStrategy = 10;
3505 if (has_cachingstrategy()) {
3506 total_size += 1 +
3507 ::google::protobuf::internal::WireFormatLite::MessageSize(
3508 *cachingstrategy_);
3509 }
3510
3511 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
3512 SetCachedSize(cached_size);
3513 return total_size;
3514}
3515
3516void OpWriteBlockProto::MergeFrom(const ::google::protobuf::Message& from) {
3517// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.OpWriteBlockProto)
3518 GOOGLE_DCHECK_NE(&from, this);
3519 const OpWriteBlockProto* source =
3520 ::google::protobuf::internal::DynamicCastToGenerated<const OpWriteBlockProto>(
3521 &from);
3522 if (source == NULL) {
3523 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.OpWriteBlockProto)
3524 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3525 } else {
3526 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.OpWriteBlockProto)
3527 MergeFrom(*source);
3528 }
3529}
3530
3531void OpWriteBlockProto::MergeFrom(const OpWriteBlockProto& from) {
3532// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.OpWriteBlockProto)
3533 GOOGLE_DCHECK_NE(&from, this);
3534 _internal_metadata_.MergeFrom(from._internal_metadata_);
3535 ::google::protobuf::uint32 cached_has_bits = 0;
3536 (void) cached_has_bits;
3537
3538 targets_.MergeFrom(from.targets_);
3539 cached_has_bits = from._has_bits_[0];
3540 if (cached_has_bits & 255u) {
3541 if (cached_has_bits & 0x00000001u) {
3542 mutable_header()->::Hdfs::Internal::ClientOperationHeaderProto::MergeFrom(from.header());
3543 }
3544 if (cached_has_bits & 0x00000002u) {
3545 mutable_source()->::Hdfs::Internal::DatanodeInfoProto::MergeFrom(from.source());
3546 }
3547 if (cached_has_bits & 0x00000004u) {
3548 mutable_requestedchecksum()->::Hdfs::Internal::ChecksumProto::MergeFrom(from.requestedchecksum());
3549 }
3550 if (cached_has_bits & 0x00000008u) {
3551 mutable_cachingstrategy()->::Hdfs::Internal::CachingStrategyProto::MergeFrom(from.cachingstrategy());
3552 }
3553 if (cached_has_bits & 0x00000010u) {
3554 stage_ = from.stage_;
3555 }
3556 if (cached_has_bits & 0x00000020u) {
3557 pipelinesize_ = from.pipelinesize_;
3558 }
3559 if (cached_has_bits & 0x00000040u) {
3560 minbytesrcvd_ = from.minbytesrcvd_;
3561 }
3562 if (cached_has_bits & 0x00000080u) {
3563 maxbytesrcvd_ = from.maxbytesrcvd_;
3564 }
3565 _has_bits_[0] |= cached_has_bits;
3566 }
3567 if (cached_has_bits & 0x00000100u) {
3568 set_latestgenerationstamp(from.latestgenerationstamp());
3569 }
3570}
3571
3572void OpWriteBlockProto::CopyFrom(const ::google::protobuf::Message& from) {
3573// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.OpWriteBlockProto)
3574 if (&from == this) return;
3575 Clear();
3576 MergeFrom(from);
3577}
3578
3579void OpWriteBlockProto::CopyFrom(const OpWriteBlockProto& from) {
3580// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.OpWriteBlockProto)
3581 if (&from == this) return;
3582 Clear();
3583 MergeFrom(from);
3584}
3585
3586bool OpWriteBlockProto::IsInitialized() const {
3587 if ((_has_bits_[0] & 0x000001f5) != 0x000001f5) return false;
3588 if (!::google::protobuf::internal::AllAreInitialized(this->targets())) return false;
3589 if (has_header()) {
3590 if (!this->header_->IsInitialized()) return false;
3591 }
3592 if (has_source()) {
3593 if (!this->source_->IsInitialized()) return false;
3594 }
3595 if (has_requestedchecksum()) {
3596 if (!this->requestedchecksum_->IsInitialized()) return false;
3597 }
3598 return true;
3599}
3600
3601void OpWriteBlockProto::Swap(OpWriteBlockProto* other) {
3602 if (other == this) return;
3603 InternalSwap(other);
3604}
3605void OpWriteBlockProto::InternalSwap(OpWriteBlockProto* other) {
3606 using std::swap;
3607 CastToBase(&targets_)->InternalSwap(CastToBase(&other->targets_));
3608 swap(header_, other->header_);
3609 swap(source_, other->source_);
3610 swap(requestedchecksum_, other->requestedchecksum_);
3611 swap(cachingstrategy_, other->cachingstrategy_);
3612 swap(stage_, other->stage_);
3613 swap(pipelinesize_, other->pipelinesize_);
3614 swap(minbytesrcvd_, other->minbytesrcvd_);
3615 swap(maxbytesrcvd_, other->maxbytesrcvd_);
3616 swap(latestgenerationstamp_, other->latestgenerationstamp_);
3617 swap(_has_bits_[0], other->_has_bits_[0]);
3618 _internal_metadata_.Swap(&other->_internal_metadata_);
3619}
3620
3621::google::protobuf::Metadata OpWriteBlockProto::GetMetadata() const {
3622 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
3623 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
3624}
3625
3626
3627// ===================================================================
3628
3629void OpTransferBlockProto::InitAsDefaultInstance() {
3630 ::Hdfs::Internal::_OpTransferBlockProto_default_instance_._instance.get_mutable()->header_ = const_cast< ::Hdfs::Internal::ClientOperationHeaderProto*>(
3631 ::Hdfs::Internal::ClientOperationHeaderProto::internal_default_instance());
3632}
3633void OpTransferBlockProto::clear_targets() {
3634 targets_.Clear();
3635}
3636#if !defined(_MSC_VER) || _MSC_VER >= 1900
3637const int OpTransferBlockProto::kHeaderFieldNumber;
3638const int OpTransferBlockProto::kTargetsFieldNumber;
3639#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
3640
3641OpTransferBlockProto::OpTransferBlockProto()
3642 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
3643 ::google::protobuf::internal::InitSCC(
3644 &protobuf_datatransfer_2eproto::scc_info_OpTransferBlockProto.base);
3645 SharedCtor();
3646 // @@protoc_insertion_point(constructor:Hdfs.Internal.OpTransferBlockProto)
3647}
3648OpTransferBlockProto::OpTransferBlockProto(const OpTransferBlockProto& from)
3649 : ::google::protobuf::Message(),
3650 _internal_metadata_(NULL),
3651 _has_bits_(from._has_bits_),
3652 targets_(from.targets_) {
3653 _internal_metadata_.MergeFrom(from._internal_metadata_);
3654 if (from.has_header()) {
3655 header_ = new ::Hdfs::Internal::ClientOperationHeaderProto(*from.header_);
3656 } else {
3657 header_ = NULL;
3658 }
3659 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.OpTransferBlockProto)
3660}
3661
3662void OpTransferBlockProto::SharedCtor() {
3663 header_ = NULL;
3664}
3665
3666OpTransferBlockProto::~OpTransferBlockProto() {
3667 // @@protoc_insertion_point(destructor:Hdfs.Internal.OpTransferBlockProto)
3668 SharedDtor();
3669}
3670
3671void OpTransferBlockProto::SharedDtor() {
3672 if (this != internal_default_instance()) delete header_;
3673}
3674
3675void OpTransferBlockProto::SetCachedSize(int size) const {
3676 _cached_size_.Set(size);
3677}
3678const ::google::protobuf::Descriptor* OpTransferBlockProto::descriptor() {
3679 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
3680 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
3681}
3682
3683const OpTransferBlockProto& OpTransferBlockProto::default_instance() {
3684 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_OpTransferBlockProto.base);
3685 return *internal_default_instance();
3686}
3687
3688
3689void OpTransferBlockProto::Clear() {
3690// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.OpTransferBlockProto)
3691 ::google::protobuf::uint32 cached_has_bits = 0;
3692 // Prevent compiler warnings about cached_has_bits being unused
3693 (void) cached_has_bits;
3694
3695 targets_.Clear();
3696 cached_has_bits = _has_bits_[0];
3697 if (cached_has_bits & 0x00000001u) {
3698 GOOGLE_DCHECK(header_ != NULL);
3699 header_->Clear();
3700 }
3701 _has_bits_.Clear();
3702 _internal_metadata_.Clear();
3703}
3704
3705bool OpTransferBlockProto::MergePartialFromCodedStream(
3706 ::google::protobuf::io::CodedInputStream* input) {
3707#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
3708 ::google::protobuf::uint32 tag;
3709 // @@protoc_insertion_point(parse_start:Hdfs.Internal.OpTransferBlockProto)
3710 for (;;) {
3711 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
3712 tag = p.first;
3713 if (!p.second) goto handle_unusual;
3714 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3715 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3716 case 1: {
3717 if (static_cast< ::google::protobuf::uint8>(tag) ==
3718 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
3719 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
3720 input, mutable_header()));
3721 } else {
3722 goto handle_unusual;
3723 }
3724 break;
3725 }
3726
3727 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3728 case 2: {
3729 if (static_cast< ::google::protobuf::uint8>(tag) ==
3730 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
3731 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
3732 input, add_targets()));
3733 } else {
3734 goto handle_unusual;
3735 }
3736 break;
3737 }
3738
3739 default: {
3740 handle_unusual:
3741 if (tag == 0) {
3742 goto success;
3743 }
3744 DO_(::google::protobuf::internal::WireFormat::SkipField(
3745 input, tag, _internal_metadata_.mutable_unknown_fields()));
3746 break;
3747 }
3748 }
3749 }
3750success:
3751 // @@protoc_insertion_point(parse_success:Hdfs.Internal.OpTransferBlockProto)
3752 return true;
3753failure:
3754 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.OpTransferBlockProto)
3755 return false;
3756#undef DO_
3757}
3758
3759void OpTransferBlockProto::SerializeWithCachedSizes(
3760 ::google::protobuf::io::CodedOutputStream* output) const {
3761 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.OpTransferBlockProto)
3762 ::google::protobuf::uint32 cached_has_bits = 0;
3763 (void) cached_has_bits;
3764
3765 cached_has_bits = _has_bits_[0];
3766 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3767 if (cached_has_bits & 0x00000001u) {
3768 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3769 1, this->_internal_header(), output);
3770 }
3771
3772 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3773 for (unsigned int i = 0,
3774 n = static_cast<unsigned int>(this->targets_size()); i < n; i++) {
3775 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3776 2,
3777 this->targets(static_cast<int>(i)),
3778 output);
3779 }
3780
3781 if (_internal_metadata_.have_unknown_fields()) {
3782 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3783 _internal_metadata_.unknown_fields(), output);
3784 }
3785 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.OpTransferBlockProto)
3786}
3787
3788::google::protobuf::uint8* OpTransferBlockProto::InternalSerializeWithCachedSizesToArray(
3789 bool deterministic, ::google::protobuf::uint8* target) const {
3790 (void)deterministic; // Unused
3791 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.OpTransferBlockProto)
3792 ::google::protobuf::uint32 cached_has_bits = 0;
3793 (void) cached_has_bits;
3794
3795 cached_has_bits = _has_bits_[0];
3796 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3797 if (cached_has_bits & 0x00000001u) {
3798 target = ::google::protobuf::internal::WireFormatLite::
3799 InternalWriteMessageToArray(
3800 1, this->_internal_header(), deterministic, target);
3801 }
3802
3803 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3804 for (unsigned int i = 0,
3805 n = static_cast<unsigned int>(this->targets_size()); i < n; i++) {
3806 target = ::google::protobuf::internal::WireFormatLite::
3807 InternalWriteMessageToArray(
3808 2, this->targets(static_cast<int>(i)), deterministic, target);
3809 }
3810
3811 if (_internal_metadata_.have_unknown_fields()) {
3812 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3813 _internal_metadata_.unknown_fields(), target);
3814 }
3815 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.OpTransferBlockProto)
3816 return target;
3817}
3818
3819size_t OpTransferBlockProto::ByteSizeLong() const {
3820// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.OpTransferBlockProto)
3821 size_t total_size = 0;
3822
3823 if (_internal_metadata_.have_unknown_fields()) {
3824 total_size +=
3825 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3826 _internal_metadata_.unknown_fields());
3827 }
3828 // required .Hdfs.Internal.ClientOperationHeaderProto header = 1;
3829 if (has_header()) {
3830 total_size += 1 +
3831 ::google::protobuf::internal::WireFormatLite::MessageSize(
3832 *header_);
3833 }
3834 // repeated .Hdfs.Internal.DatanodeInfoProto targets = 2;
3835 {
3836 unsigned int count = static_cast<unsigned int>(this->targets_size());
3837 total_size += 1UL * count;
3838 for (unsigned int i = 0; i < count; i++) {
3839 total_size +=
3840 ::google::protobuf::internal::WireFormatLite::MessageSize(
3841 this->targets(static_cast<int>(i)));
3842 }
3843 }
3844
3845 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
3846 SetCachedSize(cached_size);
3847 return total_size;
3848}
3849
3850void OpTransferBlockProto::MergeFrom(const ::google::protobuf::Message& from) {
3851// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.OpTransferBlockProto)
3852 GOOGLE_DCHECK_NE(&from, this);
3853 const OpTransferBlockProto* source =
3854 ::google::protobuf::internal::DynamicCastToGenerated<const OpTransferBlockProto>(
3855 &from);
3856 if (source == NULL) {
3857 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.OpTransferBlockProto)
3858 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3859 } else {
3860 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.OpTransferBlockProto)
3861 MergeFrom(*source);
3862 }
3863}
3864
3865void OpTransferBlockProto::MergeFrom(const OpTransferBlockProto& from) {
3866// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.OpTransferBlockProto)
3867 GOOGLE_DCHECK_NE(&from, this);
3868 _internal_metadata_.MergeFrom(from._internal_metadata_);
3869 ::google::protobuf::uint32 cached_has_bits = 0;
3870 (void) cached_has_bits;
3871
3872 targets_.MergeFrom(from.targets_);
3873 if (from.has_header()) {
3874 mutable_header()->::Hdfs::Internal::ClientOperationHeaderProto::MergeFrom(from.header());
3875 }
3876}
3877
3878void OpTransferBlockProto::CopyFrom(const ::google::protobuf::Message& from) {
3879// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.OpTransferBlockProto)
3880 if (&from == this) return;
3881 Clear();
3882 MergeFrom(from);
3883}
3884
3885void OpTransferBlockProto::CopyFrom(const OpTransferBlockProto& from) {
3886// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.OpTransferBlockProto)
3887 if (&from == this) return;
3888 Clear();
3889 MergeFrom(from);
3890}
3891
3892bool OpTransferBlockProto::IsInitialized() const {
3893 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
3894 if (!::google::protobuf::internal::AllAreInitialized(this->targets())) return false;
3895 if (has_header()) {
3896 if (!this->header_->IsInitialized()) return false;
3897 }
3898 return true;
3899}
3900
3901void OpTransferBlockProto::Swap(OpTransferBlockProto* other) {
3902 if (other == this) return;
3903 InternalSwap(other);
3904}
3905void OpTransferBlockProto::InternalSwap(OpTransferBlockProto* other) {
3906 using std::swap;
3907 CastToBase(&targets_)->InternalSwap(CastToBase(&other->targets_));
3908 swap(header_, other->header_);
3909 swap(_has_bits_[0], other->_has_bits_[0]);
3910 _internal_metadata_.Swap(&other->_internal_metadata_);
3911}
3912
3913::google::protobuf::Metadata OpTransferBlockProto::GetMetadata() const {
3914 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
3915 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
3916}
3917
3918
3919// ===================================================================
3920
3921void OpReplaceBlockProto::InitAsDefaultInstance() {
3922 ::Hdfs::Internal::_OpReplaceBlockProto_default_instance_._instance.get_mutable()->header_ = const_cast< ::Hdfs::Internal::BaseHeaderProto*>(
3923 ::Hdfs::Internal::BaseHeaderProto::internal_default_instance());
3924 ::Hdfs::Internal::_OpReplaceBlockProto_default_instance_._instance.get_mutable()->source_ = const_cast< ::Hdfs::Internal::DatanodeInfoProto*>(
3925 ::Hdfs::Internal::DatanodeInfoProto::internal_default_instance());
3926}
3927void OpReplaceBlockProto::clear_source() {
3928 if (source_ != NULL) source_->Clear();
3929 clear_has_source();
3930}
3931#if !defined(_MSC_VER) || _MSC_VER >= 1900
3932const int OpReplaceBlockProto::kHeaderFieldNumber;
3933const int OpReplaceBlockProto::kDelHintFieldNumber;
3934const int OpReplaceBlockProto::kSourceFieldNumber;
3935#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
3936
3937OpReplaceBlockProto::OpReplaceBlockProto()
3938 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
3939 ::google::protobuf::internal::InitSCC(
3940 &protobuf_datatransfer_2eproto::scc_info_OpReplaceBlockProto.base);
3941 SharedCtor();
3942 // @@protoc_insertion_point(constructor:Hdfs.Internal.OpReplaceBlockProto)
3943}
3944OpReplaceBlockProto::OpReplaceBlockProto(const OpReplaceBlockProto& from)
3945 : ::google::protobuf::Message(),
3946 _internal_metadata_(NULL),
3947 _has_bits_(from._has_bits_) {
3948 _internal_metadata_.MergeFrom(from._internal_metadata_);
3949 delhint_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3950 if (from.has_delhint()) {
3951 delhint_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.delhint_);
3952 }
3953 if (from.has_header()) {
3954 header_ = new ::Hdfs::Internal::BaseHeaderProto(*from.header_);
3955 } else {
3956 header_ = NULL;
3957 }
3958 if (from.has_source()) {
3959 source_ = new ::Hdfs::Internal::DatanodeInfoProto(*from.source_);
3960 } else {
3961 source_ = NULL;
3962 }
3963 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.OpReplaceBlockProto)
3964}
3965
3966void OpReplaceBlockProto::SharedCtor() {
3967 delhint_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3968 ::memset(&header_, 0, static_cast<size_t>(
3969 reinterpret_cast<char*>(&source_) -
3970 reinterpret_cast<char*>(&header_)) + sizeof(source_));
3971}
3972
3973OpReplaceBlockProto::~OpReplaceBlockProto() {
3974 // @@protoc_insertion_point(destructor:Hdfs.Internal.OpReplaceBlockProto)
3975 SharedDtor();
3976}
3977
3978void OpReplaceBlockProto::SharedDtor() {
3979 delhint_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3980 if (this != internal_default_instance()) delete header_;
3981 if (this != internal_default_instance()) delete source_;
3982}
3983
3984void OpReplaceBlockProto::SetCachedSize(int size) const {
3985 _cached_size_.Set(size);
3986}
3987const ::google::protobuf::Descriptor* OpReplaceBlockProto::descriptor() {
3988 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
3989 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
3990}
3991
3992const OpReplaceBlockProto& OpReplaceBlockProto::default_instance() {
3993 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_OpReplaceBlockProto.base);
3994 return *internal_default_instance();
3995}
3996
3997
3998void OpReplaceBlockProto::Clear() {
3999// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.OpReplaceBlockProto)
4000 ::google::protobuf::uint32 cached_has_bits = 0;
4001 // Prevent compiler warnings about cached_has_bits being unused
4002 (void) cached_has_bits;
4003
4004 cached_has_bits = _has_bits_[0];
4005 if (cached_has_bits & 7u) {
4006 if (cached_has_bits & 0x00000001u) {
4007 delhint_.ClearNonDefaultToEmptyNoArena();
4008 }
4009 if (cached_has_bits & 0x00000002u) {
4010 GOOGLE_DCHECK(header_ != NULL);
4011 header_->Clear();
4012 }
4013 if (cached_has_bits & 0x00000004u) {
4014 GOOGLE_DCHECK(source_ != NULL);
4015 source_->Clear();
4016 }
4017 }
4018 _has_bits_.Clear();
4019 _internal_metadata_.Clear();
4020}
4021
4022bool OpReplaceBlockProto::MergePartialFromCodedStream(
4023 ::google::protobuf::io::CodedInputStream* input) {
4024#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
4025 ::google::protobuf::uint32 tag;
4026 // @@protoc_insertion_point(parse_start:Hdfs.Internal.OpReplaceBlockProto)
4027 for (;;) {
4028 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
4029 tag = p.first;
4030 if (!p.second) goto handle_unusual;
4031 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4032 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4033 case 1: {
4034 if (static_cast< ::google::protobuf::uint8>(tag) ==
4035 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
4036 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
4037 input, mutable_header()));
4038 } else {
4039 goto handle_unusual;
4040 }
4041 break;
4042 }
4043
4044 // required string delHint = 2;
4045 case 2: {
4046 if (static_cast< ::google::protobuf::uint8>(tag) ==
4047 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
4048 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4049 input, this->mutable_delhint()));
4050 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
4051 this->delhint().data(), static_cast<int>(this->delhint().length()),
4052 ::google::protobuf::internal::WireFormat::PARSE,
4053 "Hdfs.Internal.OpReplaceBlockProto.delHint");
4054 } else {
4055 goto handle_unusual;
4056 }
4057 break;
4058 }
4059
4060 // required .Hdfs.Internal.DatanodeInfoProto source = 3;
4061 case 3: {
4062 if (static_cast< ::google::protobuf::uint8>(tag) ==
4063 static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
4064 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
4065 input, mutable_source()));
4066 } else {
4067 goto handle_unusual;
4068 }
4069 break;
4070 }
4071
4072 default: {
4073 handle_unusual:
4074 if (tag == 0) {
4075 goto success;
4076 }
4077 DO_(::google::protobuf::internal::WireFormat::SkipField(
4078 input, tag, _internal_metadata_.mutable_unknown_fields()));
4079 break;
4080 }
4081 }
4082 }
4083success:
4084 // @@protoc_insertion_point(parse_success:Hdfs.Internal.OpReplaceBlockProto)
4085 return true;
4086failure:
4087 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.OpReplaceBlockProto)
4088 return false;
4089#undef DO_
4090}
4091
4092void OpReplaceBlockProto::SerializeWithCachedSizes(
4093 ::google::protobuf::io::CodedOutputStream* output) const {
4094 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.OpReplaceBlockProto)
4095 ::google::protobuf::uint32 cached_has_bits = 0;
4096 (void) cached_has_bits;
4097
4098 cached_has_bits = _has_bits_[0];
4099 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4100 if (cached_has_bits & 0x00000002u) {
4101 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4102 1, this->_internal_header(), output);
4103 }
4104
4105 // required string delHint = 2;
4106 if (cached_has_bits & 0x00000001u) {
4107 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
4108 this->delhint().data(), static_cast<int>(this->delhint().length()),
4109 ::google::protobuf::internal::WireFormat::SERIALIZE,
4110 "Hdfs.Internal.OpReplaceBlockProto.delHint");
4111 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
4112 2, this->delhint(), output);
4113 }
4114
4115 // required .Hdfs.Internal.DatanodeInfoProto source = 3;
4116 if (cached_has_bits & 0x00000004u) {
4117 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4118 3, this->_internal_source(), output);
4119 }
4120
4121 if (_internal_metadata_.have_unknown_fields()) {
4122 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4123 _internal_metadata_.unknown_fields(), output);
4124 }
4125 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.OpReplaceBlockProto)
4126}
4127
4128::google::protobuf::uint8* OpReplaceBlockProto::InternalSerializeWithCachedSizesToArray(
4129 bool deterministic, ::google::protobuf::uint8* target) const {
4130 (void)deterministic; // Unused
4131 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.OpReplaceBlockProto)
4132 ::google::protobuf::uint32 cached_has_bits = 0;
4133 (void) cached_has_bits;
4134
4135 cached_has_bits = _has_bits_[0];
4136 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4137 if (cached_has_bits & 0x00000002u) {
4138 target = ::google::protobuf::internal::WireFormatLite::
4139 InternalWriteMessageToArray(
4140 1, this->_internal_header(), deterministic, target);
4141 }
4142
4143 // required string delHint = 2;
4144 if (cached_has_bits & 0x00000001u) {
4145 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
4146 this->delhint().data(), static_cast<int>(this->delhint().length()),
4147 ::google::protobuf::internal::WireFormat::SERIALIZE,
4148 "Hdfs.Internal.OpReplaceBlockProto.delHint");
4149 target =
4150 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4151 2, this->delhint(), target);
4152 }
4153
4154 // required .Hdfs.Internal.DatanodeInfoProto source = 3;
4155 if (cached_has_bits & 0x00000004u) {
4156 target = ::google::protobuf::internal::WireFormatLite::
4157 InternalWriteMessageToArray(
4158 3, this->_internal_source(), deterministic, target);
4159 }
4160
4161 if (_internal_metadata_.have_unknown_fields()) {
4162 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4163 _internal_metadata_.unknown_fields(), target);
4164 }
4165 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.OpReplaceBlockProto)
4166 return target;
4167}
4168
4169size_t OpReplaceBlockProto::RequiredFieldsByteSizeFallback() const {
4170// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.OpReplaceBlockProto)
4171 size_t total_size = 0;
4172
4173 if (has_delhint()) {
4174 // required string delHint = 2;
4175 total_size += 1 +
4176 ::google::protobuf::internal::WireFormatLite::StringSize(
4177 this->delhint());
4178 }
4179
4180 if (has_header()) {
4181 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4182 total_size += 1 +
4183 ::google::protobuf::internal::WireFormatLite::MessageSize(
4184 *header_);
4185 }
4186
4187 if (has_source()) {
4188 // required .Hdfs.Internal.DatanodeInfoProto source = 3;
4189 total_size += 1 +
4190 ::google::protobuf::internal::WireFormatLite::MessageSize(
4191 *source_);
4192 }
4193
4194 return total_size;
4195}
4196size_t OpReplaceBlockProto::ByteSizeLong() const {
4197// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.OpReplaceBlockProto)
4198 size_t total_size = 0;
4199
4200 if (_internal_metadata_.have_unknown_fields()) {
4201 total_size +=
4202 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4203 _internal_metadata_.unknown_fields());
4204 }
4205 if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) { // All required fields are present.
4206 // required string delHint = 2;
4207 total_size += 1 +
4208 ::google::protobuf::internal::WireFormatLite::StringSize(
4209 this->delhint());
4210
4211 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4212 total_size += 1 +
4213 ::google::protobuf::internal::WireFormatLite::MessageSize(
4214 *header_);
4215
4216 // required .Hdfs.Internal.DatanodeInfoProto source = 3;
4217 total_size += 1 +
4218 ::google::protobuf::internal::WireFormatLite::MessageSize(
4219 *source_);
4220
4221 } else {
4222 total_size += RequiredFieldsByteSizeFallback();
4223 }
4224 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
4225 SetCachedSize(cached_size);
4226 return total_size;
4227}
4228
4229void OpReplaceBlockProto::MergeFrom(const ::google::protobuf::Message& from) {
4230// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.OpReplaceBlockProto)
4231 GOOGLE_DCHECK_NE(&from, this);
4232 const OpReplaceBlockProto* source =
4233 ::google::protobuf::internal::DynamicCastToGenerated<const OpReplaceBlockProto>(
4234 &from);
4235 if (source == NULL) {
4236 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.OpReplaceBlockProto)
4237 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4238 } else {
4239 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.OpReplaceBlockProto)
4240 MergeFrom(*source);
4241 }
4242}
4243
4244void OpReplaceBlockProto::MergeFrom(const OpReplaceBlockProto& from) {
4245// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.OpReplaceBlockProto)
4246 GOOGLE_DCHECK_NE(&from, this);
4247 _internal_metadata_.MergeFrom(from._internal_metadata_);
4248 ::google::protobuf::uint32 cached_has_bits = 0;
4249 (void) cached_has_bits;
4250
4251 cached_has_bits = from._has_bits_[0];
4252 if (cached_has_bits & 7u) {
4253 if (cached_has_bits & 0x00000001u) {
4254 set_has_delhint();
4255 delhint_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.delhint_);
4256 }
4257 if (cached_has_bits & 0x00000002u) {
4258 mutable_header()->::Hdfs::Internal::BaseHeaderProto::MergeFrom(from.header());
4259 }
4260 if (cached_has_bits & 0x00000004u) {
4261 mutable_source()->::Hdfs::Internal::DatanodeInfoProto::MergeFrom(from.source());
4262 }
4263 }
4264}
4265
4266void OpReplaceBlockProto::CopyFrom(const ::google::protobuf::Message& from) {
4267// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.OpReplaceBlockProto)
4268 if (&from == this) return;
4269 Clear();
4270 MergeFrom(from);
4271}
4272
4273void OpReplaceBlockProto::CopyFrom(const OpReplaceBlockProto& from) {
4274// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.OpReplaceBlockProto)
4275 if (&from == this) return;
4276 Clear();
4277 MergeFrom(from);
4278}
4279
4280bool OpReplaceBlockProto::IsInitialized() const {
4281 if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
4282 if (has_header()) {
4283 if (!this->header_->IsInitialized()) return false;
4284 }
4285 if (has_source()) {
4286 if (!this->source_->IsInitialized()) return false;
4287 }
4288 return true;
4289}
4290
4291void OpReplaceBlockProto::Swap(OpReplaceBlockProto* other) {
4292 if (other == this) return;
4293 InternalSwap(other);
4294}
4295void OpReplaceBlockProto::InternalSwap(OpReplaceBlockProto* other) {
4296 using std::swap;
4297 delhint_.Swap(&other->delhint_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4298 GetArenaNoVirtual());
4299 swap(header_, other->header_);
4300 swap(source_, other->source_);
4301 swap(_has_bits_[0], other->_has_bits_[0]);
4302 _internal_metadata_.Swap(&other->_internal_metadata_);
4303}
4304
4305::google::protobuf::Metadata OpReplaceBlockProto::GetMetadata() const {
4306 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
4307 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
4308}
4309
4310
4311// ===================================================================
4312
4313void OpCopyBlockProto::InitAsDefaultInstance() {
4314 ::Hdfs::Internal::_OpCopyBlockProto_default_instance_._instance.get_mutable()->header_ = const_cast< ::Hdfs::Internal::BaseHeaderProto*>(
4315 ::Hdfs::Internal::BaseHeaderProto::internal_default_instance());
4316}
4317#if !defined(_MSC_VER) || _MSC_VER >= 1900
4318const int OpCopyBlockProto::kHeaderFieldNumber;
4319#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
4320
4321OpCopyBlockProto::OpCopyBlockProto()
4322 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
4323 ::google::protobuf::internal::InitSCC(
4324 &protobuf_datatransfer_2eproto::scc_info_OpCopyBlockProto.base);
4325 SharedCtor();
4326 // @@protoc_insertion_point(constructor:Hdfs.Internal.OpCopyBlockProto)
4327}
4328OpCopyBlockProto::OpCopyBlockProto(const OpCopyBlockProto& from)
4329 : ::google::protobuf::Message(),
4330 _internal_metadata_(NULL),
4331 _has_bits_(from._has_bits_) {
4332 _internal_metadata_.MergeFrom(from._internal_metadata_);
4333 if (from.has_header()) {
4334 header_ = new ::Hdfs::Internal::BaseHeaderProto(*from.header_);
4335 } else {
4336 header_ = NULL;
4337 }
4338 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.OpCopyBlockProto)
4339}
4340
4341void OpCopyBlockProto::SharedCtor() {
4342 header_ = NULL;
4343}
4344
4345OpCopyBlockProto::~OpCopyBlockProto() {
4346 // @@protoc_insertion_point(destructor:Hdfs.Internal.OpCopyBlockProto)
4347 SharedDtor();
4348}
4349
4350void OpCopyBlockProto::SharedDtor() {
4351 if (this != internal_default_instance()) delete header_;
4352}
4353
4354void OpCopyBlockProto::SetCachedSize(int size) const {
4355 _cached_size_.Set(size);
4356}
4357const ::google::protobuf::Descriptor* OpCopyBlockProto::descriptor() {
4358 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
4359 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
4360}
4361
4362const OpCopyBlockProto& OpCopyBlockProto::default_instance() {
4363 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_OpCopyBlockProto.base);
4364 return *internal_default_instance();
4365}
4366
4367
4368void OpCopyBlockProto::Clear() {
4369// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.OpCopyBlockProto)
4370 ::google::protobuf::uint32 cached_has_bits = 0;
4371 // Prevent compiler warnings about cached_has_bits being unused
4372 (void) cached_has_bits;
4373
4374 cached_has_bits = _has_bits_[0];
4375 if (cached_has_bits & 0x00000001u) {
4376 GOOGLE_DCHECK(header_ != NULL);
4377 header_->Clear();
4378 }
4379 _has_bits_.Clear();
4380 _internal_metadata_.Clear();
4381}
4382
4383bool OpCopyBlockProto::MergePartialFromCodedStream(
4384 ::google::protobuf::io::CodedInputStream* input) {
4385#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
4386 ::google::protobuf::uint32 tag;
4387 // @@protoc_insertion_point(parse_start:Hdfs.Internal.OpCopyBlockProto)
4388 for (;;) {
4389 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
4390 tag = p.first;
4391 if (!p.second) goto handle_unusual;
4392 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4393 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4394 case 1: {
4395 if (static_cast< ::google::protobuf::uint8>(tag) ==
4396 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
4397 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
4398 input, mutable_header()));
4399 } else {
4400 goto handle_unusual;
4401 }
4402 break;
4403 }
4404
4405 default: {
4406 handle_unusual:
4407 if (tag == 0) {
4408 goto success;
4409 }
4410 DO_(::google::protobuf::internal::WireFormat::SkipField(
4411 input, tag, _internal_metadata_.mutable_unknown_fields()));
4412 break;
4413 }
4414 }
4415 }
4416success:
4417 // @@protoc_insertion_point(parse_success:Hdfs.Internal.OpCopyBlockProto)
4418 return true;
4419failure:
4420 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.OpCopyBlockProto)
4421 return false;
4422#undef DO_
4423}
4424
4425void OpCopyBlockProto::SerializeWithCachedSizes(
4426 ::google::protobuf::io::CodedOutputStream* output) const {
4427 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.OpCopyBlockProto)
4428 ::google::protobuf::uint32 cached_has_bits = 0;
4429 (void) cached_has_bits;
4430
4431 cached_has_bits = _has_bits_[0];
4432 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4433 if (cached_has_bits & 0x00000001u) {
4434 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4435 1, this->_internal_header(), output);
4436 }
4437
4438 if (_internal_metadata_.have_unknown_fields()) {
4439 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4440 _internal_metadata_.unknown_fields(), output);
4441 }
4442 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.OpCopyBlockProto)
4443}
4444
4445::google::protobuf::uint8* OpCopyBlockProto::InternalSerializeWithCachedSizesToArray(
4446 bool deterministic, ::google::protobuf::uint8* target) const {
4447 (void)deterministic; // Unused
4448 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.OpCopyBlockProto)
4449 ::google::protobuf::uint32 cached_has_bits = 0;
4450 (void) cached_has_bits;
4451
4452 cached_has_bits = _has_bits_[0];
4453 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4454 if (cached_has_bits & 0x00000001u) {
4455 target = ::google::protobuf::internal::WireFormatLite::
4456 InternalWriteMessageToArray(
4457 1, this->_internal_header(), deterministic, target);
4458 }
4459
4460 if (_internal_metadata_.have_unknown_fields()) {
4461 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4462 _internal_metadata_.unknown_fields(), target);
4463 }
4464 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.OpCopyBlockProto)
4465 return target;
4466}
4467
4468size_t OpCopyBlockProto::ByteSizeLong() const {
4469// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.OpCopyBlockProto)
4470 size_t total_size = 0;
4471
4472 if (_internal_metadata_.have_unknown_fields()) {
4473 total_size +=
4474 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4475 _internal_metadata_.unknown_fields());
4476 }
4477 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4478 if (has_header()) {
4479 total_size += 1 +
4480 ::google::protobuf::internal::WireFormatLite::MessageSize(
4481 *header_);
4482 }
4483 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
4484 SetCachedSize(cached_size);
4485 return total_size;
4486}
4487
4488void OpCopyBlockProto::MergeFrom(const ::google::protobuf::Message& from) {
4489// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.OpCopyBlockProto)
4490 GOOGLE_DCHECK_NE(&from, this);
4491 const OpCopyBlockProto* source =
4492 ::google::protobuf::internal::DynamicCastToGenerated<const OpCopyBlockProto>(
4493 &from);
4494 if (source == NULL) {
4495 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.OpCopyBlockProto)
4496 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4497 } else {
4498 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.OpCopyBlockProto)
4499 MergeFrom(*source);
4500 }
4501}
4502
4503void OpCopyBlockProto::MergeFrom(const OpCopyBlockProto& from) {
4504// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.OpCopyBlockProto)
4505 GOOGLE_DCHECK_NE(&from, this);
4506 _internal_metadata_.MergeFrom(from._internal_metadata_);
4507 ::google::protobuf::uint32 cached_has_bits = 0;
4508 (void) cached_has_bits;
4509
4510 if (from.has_header()) {
4511 mutable_header()->::Hdfs::Internal::BaseHeaderProto::MergeFrom(from.header());
4512 }
4513}
4514
4515void OpCopyBlockProto::CopyFrom(const ::google::protobuf::Message& from) {
4516// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.OpCopyBlockProto)
4517 if (&from == this) return;
4518 Clear();
4519 MergeFrom(from);
4520}
4521
4522void OpCopyBlockProto::CopyFrom(const OpCopyBlockProto& from) {
4523// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.OpCopyBlockProto)
4524 if (&from == this) return;
4525 Clear();
4526 MergeFrom(from);
4527}
4528
4529bool OpCopyBlockProto::IsInitialized() const {
4530 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4531 if (has_header()) {
4532 if (!this->header_->IsInitialized()) return false;
4533 }
4534 return true;
4535}
4536
4537void OpCopyBlockProto::Swap(OpCopyBlockProto* other) {
4538 if (other == this) return;
4539 InternalSwap(other);
4540}
4541void OpCopyBlockProto::InternalSwap(OpCopyBlockProto* other) {
4542 using std::swap;
4543 swap(header_, other->header_);
4544 swap(_has_bits_[0], other->_has_bits_[0]);
4545 _internal_metadata_.Swap(&other->_internal_metadata_);
4546}
4547
4548::google::protobuf::Metadata OpCopyBlockProto::GetMetadata() const {
4549 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
4550 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
4551}
4552
4553
4554// ===================================================================
4555
4556void OpBlockChecksumProto::InitAsDefaultInstance() {
4557 ::Hdfs::Internal::_OpBlockChecksumProto_default_instance_._instance.get_mutable()->header_ = const_cast< ::Hdfs::Internal::BaseHeaderProto*>(
4558 ::Hdfs::Internal::BaseHeaderProto::internal_default_instance());
4559}
4560#if !defined(_MSC_VER) || _MSC_VER >= 1900
4561const int OpBlockChecksumProto::kHeaderFieldNumber;
4562#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
4563
4564OpBlockChecksumProto::OpBlockChecksumProto()
4565 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
4566 ::google::protobuf::internal::InitSCC(
4567 &protobuf_datatransfer_2eproto::scc_info_OpBlockChecksumProto.base);
4568 SharedCtor();
4569 // @@protoc_insertion_point(constructor:Hdfs.Internal.OpBlockChecksumProto)
4570}
4571OpBlockChecksumProto::OpBlockChecksumProto(const OpBlockChecksumProto& from)
4572 : ::google::protobuf::Message(),
4573 _internal_metadata_(NULL),
4574 _has_bits_(from._has_bits_) {
4575 _internal_metadata_.MergeFrom(from._internal_metadata_);
4576 if (from.has_header()) {
4577 header_ = new ::Hdfs::Internal::BaseHeaderProto(*from.header_);
4578 } else {
4579 header_ = NULL;
4580 }
4581 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.OpBlockChecksumProto)
4582}
4583
4584void OpBlockChecksumProto::SharedCtor() {
4585 header_ = NULL;
4586}
4587
4588OpBlockChecksumProto::~OpBlockChecksumProto() {
4589 // @@protoc_insertion_point(destructor:Hdfs.Internal.OpBlockChecksumProto)
4590 SharedDtor();
4591}
4592
4593void OpBlockChecksumProto::SharedDtor() {
4594 if (this != internal_default_instance()) delete header_;
4595}
4596
4597void OpBlockChecksumProto::SetCachedSize(int size) const {
4598 _cached_size_.Set(size);
4599}
4600const ::google::protobuf::Descriptor* OpBlockChecksumProto::descriptor() {
4601 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
4602 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
4603}
4604
4605const OpBlockChecksumProto& OpBlockChecksumProto::default_instance() {
4606 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_OpBlockChecksumProto.base);
4607 return *internal_default_instance();
4608}
4609
4610
4611void OpBlockChecksumProto::Clear() {
4612// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.OpBlockChecksumProto)
4613 ::google::protobuf::uint32 cached_has_bits = 0;
4614 // Prevent compiler warnings about cached_has_bits being unused
4615 (void) cached_has_bits;
4616
4617 cached_has_bits = _has_bits_[0];
4618 if (cached_has_bits & 0x00000001u) {
4619 GOOGLE_DCHECK(header_ != NULL);
4620 header_->Clear();
4621 }
4622 _has_bits_.Clear();
4623 _internal_metadata_.Clear();
4624}
4625
4626bool OpBlockChecksumProto::MergePartialFromCodedStream(
4627 ::google::protobuf::io::CodedInputStream* input) {
4628#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
4629 ::google::protobuf::uint32 tag;
4630 // @@protoc_insertion_point(parse_start:Hdfs.Internal.OpBlockChecksumProto)
4631 for (;;) {
4632 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
4633 tag = p.first;
4634 if (!p.second) goto handle_unusual;
4635 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4636 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4637 case 1: {
4638 if (static_cast< ::google::protobuf::uint8>(tag) ==
4639 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
4640 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
4641 input, mutable_header()));
4642 } else {
4643 goto handle_unusual;
4644 }
4645 break;
4646 }
4647
4648 default: {
4649 handle_unusual:
4650 if (tag == 0) {
4651 goto success;
4652 }
4653 DO_(::google::protobuf::internal::WireFormat::SkipField(
4654 input, tag, _internal_metadata_.mutable_unknown_fields()));
4655 break;
4656 }
4657 }
4658 }
4659success:
4660 // @@protoc_insertion_point(parse_success:Hdfs.Internal.OpBlockChecksumProto)
4661 return true;
4662failure:
4663 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.OpBlockChecksumProto)
4664 return false;
4665#undef DO_
4666}
4667
4668void OpBlockChecksumProto::SerializeWithCachedSizes(
4669 ::google::protobuf::io::CodedOutputStream* output) const {
4670 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.OpBlockChecksumProto)
4671 ::google::protobuf::uint32 cached_has_bits = 0;
4672 (void) cached_has_bits;
4673
4674 cached_has_bits = _has_bits_[0];
4675 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4676 if (cached_has_bits & 0x00000001u) {
4677 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4678 1, this->_internal_header(), output);
4679 }
4680
4681 if (_internal_metadata_.have_unknown_fields()) {
4682 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4683 _internal_metadata_.unknown_fields(), output);
4684 }
4685 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.OpBlockChecksumProto)
4686}
4687
4688::google::protobuf::uint8* OpBlockChecksumProto::InternalSerializeWithCachedSizesToArray(
4689 bool deterministic, ::google::protobuf::uint8* target) const {
4690 (void)deterministic; // Unused
4691 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.OpBlockChecksumProto)
4692 ::google::protobuf::uint32 cached_has_bits = 0;
4693 (void) cached_has_bits;
4694
4695 cached_has_bits = _has_bits_[0];
4696 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4697 if (cached_has_bits & 0x00000001u) {
4698 target = ::google::protobuf::internal::WireFormatLite::
4699 InternalWriteMessageToArray(
4700 1, this->_internal_header(), deterministic, target);
4701 }
4702
4703 if (_internal_metadata_.have_unknown_fields()) {
4704 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4705 _internal_metadata_.unknown_fields(), target);
4706 }
4707 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.OpBlockChecksumProto)
4708 return target;
4709}
4710
4711size_t OpBlockChecksumProto::ByteSizeLong() const {
4712// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.OpBlockChecksumProto)
4713 size_t total_size = 0;
4714
4715 if (_internal_metadata_.have_unknown_fields()) {
4716 total_size +=
4717 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4718 _internal_metadata_.unknown_fields());
4719 }
4720 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4721 if (has_header()) {
4722 total_size += 1 +
4723 ::google::protobuf::internal::WireFormatLite::MessageSize(
4724 *header_);
4725 }
4726 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
4727 SetCachedSize(cached_size);
4728 return total_size;
4729}
4730
4731void OpBlockChecksumProto::MergeFrom(const ::google::protobuf::Message& from) {
4732// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.OpBlockChecksumProto)
4733 GOOGLE_DCHECK_NE(&from, this);
4734 const OpBlockChecksumProto* source =
4735 ::google::protobuf::internal::DynamicCastToGenerated<const OpBlockChecksumProto>(
4736 &from);
4737 if (source == NULL) {
4738 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.OpBlockChecksumProto)
4739 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4740 } else {
4741 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.OpBlockChecksumProto)
4742 MergeFrom(*source);
4743 }
4744}
4745
4746void OpBlockChecksumProto::MergeFrom(const OpBlockChecksumProto& from) {
4747// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.OpBlockChecksumProto)
4748 GOOGLE_DCHECK_NE(&from, this);
4749 _internal_metadata_.MergeFrom(from._internal_metadata_);
4750 ::google::protobuf::uint32 cached_has_bits = 0;
4751 (void) cached_has_bits;
4752
4753 if (from.has_header()) {
4754 mutable_header()->::Hdfs::Internal::BaseHeaderProto::MergeFrom(from.header());
4755 }
4756}
4757
4758void OpBlockChecksumProto::CopyFrom(const ::google::protobuf::Message& from) {
4759// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.OpBlockChecksumProto)
4760 if (&from == this) return;
4761 Clear();
4762 MergeFrom(from);
4763}
4764
4765void OpBlockChecksumProto::CopyFrom(const OpBlockChecksumProto& from) {
4766// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.OpBlockChecksumProto)
4767 if (&from == this) return;
4768 Clear();
4769 MergeFrom(from);
4770}
4771
4772bool OpBlockChecksumProto::IsInitialized() const {
4773 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4774 if (has_header()) {
4775 if (!this->header_->IsInitialized()) return false;
4776 }
4777 return true;
4778}
4779
4780void OpBlockChecksumProto::Swap(OpBlockChecksumProto* other) {
4781 if (other == this) return;
4782 InternalSwap(other);
4783}
4784void OpBlockChecksumProto::InternalSwap(OpBlockChecksumProto* other) {
4785 using std::swap;
4786 swap(header_, other->header_);
4787 swap(_has_bits_[0], other->_has_bits_[0]);
4788 _internal_metadata_.Swap(&other->_internal_metadata_);
4789}
4790
4791::google::protobuf::Metadata OpBlockChecksumProto::GetMetadata() const {
4792 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
4793 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
4794}
4795
4796
4797// ===================================================================
4798
4799void OpRequestShortCircuitAccessProto::InitAsDefaultInstance() {
4800 ::Hdfs::Internal::_OpRequestShortCircuitAccessProto_default_instance_._instance.get_mutable()->header_ = const_cast< ::Hdfs::Internal::BaseHeaderProto*>(
4801 ::Hdfs::Internal::BaseHeaderProto::internal_default_instance());
4802}
4803#if !defined(_MSC_VER) || _MSC_VER >= 1900
4804const int OpRequestShortCircuitAccessProto::kHeaderFieldNumber;
4805const int OpRequestShortCircuitAccessProto::kMaxVersionFieldNumber;
4806#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
4807
4808OpRequestShortCircuitAccessProto::OpRequestShortCircuitAccessProto()
4809 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
4810 ::google::protobuf::internal::InitSCC(
4811 &protobuf_datatransfer_2eproto::scc_info_OpRequestShortCircuitAccessProto.base);
4812 SharedCtor();
4813 // @@protoc_insertion_point(constructor:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4814}
4815OpRequestShortCircuitAccessProto::OpRequestShortCircuitAccessProto(const OpRequestShortCircuitAccessProto& from)
4816 : ::google::protobuf::Message(),
4817 _internal_metadata_(NULL),
4818 _has_bits_(from._has_bits_) {
4819 _internal_metadata_.MergeFrom(from._internal_metadata_);
4820 if (from.has_header()) {
4821 header_ = new ::Hdfs::Internal::BaseHeaderProto(*from.header_);
4822 } else {
4823 header_ = NULL;
4824 }
4825 maxversion_ = from.maxversion_;
4826 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4827}
4828
4829void OpRequestShortCircuitAccessProto::SharedCtor() {
4830 ::memset(&header_, 0, static_cast<size_t>(
4831 reinterpret_cast<char*>(&maxversion_) -
4832 reinterpret_cast<char*>(&header_)) + sizeof(maxversion_));
4833}
4834
4835OpRequestShortCircuitAccessProto::~OpRequestShortCircuitAccessProto() {
4836 // @@protoc_insertion_point(destructor:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4837 SharedDtor();
4838}
4839
4840void OpRequestShortCircuitAccessProto::SharedDtor() {
4841 if (this != internal_default_instance()) delete header_;
4842}
4843
4844void OpRequestShortCircuitAccessProto::SetCachedSize(int size) const {
4845 _cached_size_.Set(size);
4846}
4847const ::google::protobuf::Descriptor* OpRequestShortCircuitAccessProto::descriptor() {
4848 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
4849 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
4850}
4851
4852const OpRequestShortCircuitAccessProto& OpRequestShortCircuitAccessProto::default_instance() {
4853 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_OpRequestShortCircuitAccessProto.base);
4854 return *internal_default_instance();
4855}
4856
4857
4858void OpRequestShortCircuitAccessProto::Clear() {
4859// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4860 ::google::protobuf::uint32 cached_has_bits = 0;
4861 // Prevent compiler warnings about cached_has_bits being unused
4862 (void) cached_has_bits;
4863
4864 cached_has_bits = _has_bits_[0];
4865 if (cached_has_bits & 0x00000001u) {
4866 GOOGLE_DCHECK(header_ != NULL);
4867 header_->Clear();
4868 }
4869 maxversion_ = 0u;
4870 _has_bits_.Clear();
4871 _internal_metadata_.Clear();
4872}
4873
4874bool OpRequestShortCircuitAccessProto::MergePartialFromCodedStream(
4875 ::google::protobuf::io::CodedInputStream* input) {
4876#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
4877 ::google::protobuf::uint32 tag;
4878 // @@protoc_insertion_point(parse_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4879 for (;;) {
4880 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
4881 tag = p.first;
4882 if (!p.second) goto handle_unusual;
4883 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4884 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4885 case 1: {
4886 if (static_cast< ::google::protobuf::uint8>(tag) ==
4887 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
4888 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
4889 input, mutable_header()));
4890 } else {
4891 goto handle_unusual;
4892 }
4893 break;
4894 }
4895
4896 // required uint32 maxVersion = 2;
4897 case 2: {
4898 if (static_cast< ::google::protobuf::uint8>(tag) ==
4899 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
4900 set_has_maxversion();
4901 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4902 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
4903 input, &maxversion_)));
4904 } else {
4905 goto handle_unusual;
4906 }
4907 break;
4908 }
4909
4910 default: {
4911 handle_unusual:
4912 if (tag == 0) {
4913 goto success;
4914 }
4915 DO_(::google::protobuf::internal::WireFormat::SkipField(
4916 input, tag, _internal_metadata_.mutable_unknown_fields()));
4917 break;
4918 }
4919 }
4920 }
4921success:
4922 // @@protoc_insertion_point(parse_success:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4923 return true;
4924failure:
4925 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4926 return false;
4927#undef DO_
4928}
4929
4930void OpRequestShortCircuitAccessProto::SerializeWithCachedSizes(
4931 ::google::protobuf::io::CodedOutputStream* output) const {
4932 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4933 ::google::protobuf::uint32 cached_has_bits = 0;
4934 (void) cached_has_bits;
4935
4936 cached_has_bits = _has_bits_[0];
4937 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4938 if (cached_has_bits & 0x00000001u) {
4939 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4940 1, this->_internal_header(), output);
4941 }
4942
4943 // required uint32 maxVersion = 2;
4944 if (cached_has_bits & 0x00000002u) {
4945 ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->maxversion(), output);
4946 }
4947
4948 if (_internal_metadata_.have_unknown_fields()) {
4949 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4950 _internal_metadata_.unknown_fields(), output);
4951 }
4952 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4953}
4954
4955::google::protobuf::uint8* OpRequestShortCircuitAccessProto::InternalSerializeWithCachedSizesToArray(
4956 bool deterministic, ::google::protobuf::uint8* target) const {
4957 (void)deterministic; // Unused
4958 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4959 ::google::protobuf::uint32 cached_has_bits = 0;
4960 (void) cached_has_bits;
4961
4962 cached_has_bits = _has_bits_[0];
4963 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4964 if (cached_has_bits & 0x00000001u) {
4965 target = ::google::protobuf::internal::WireFormatLite::
4966 InternalWriteMessageToArray(
4967 1, this->_internal_header(), deterministic, target);
4968 }
4969
4970 // required uint32 maxVersion = 2;
4971 if (cached_has_bits & 0x00000002u) {
4972 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->maxversion(), target);
4973 }
4974
4975 if (_internal_metadata_.have_unknown_fields()) {
4976 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4977 _internal_metadata_.unknown_fields(), target);
4978 }
4979 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4980 return target;
4981}
4982
4983size_t OpRequestShortCircuitAccessProto::RequiredFieldsByteSizeFallback() const {
4984// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
4985 size_t total_size = 0;
4986
4987 if (has_header()) {
4988 // required .Hdfs.Internal.BaseHeaderProto header = 1;
4989 total_size += 1 +
4990 ::google::protobuf::internal::WireFormatLite::MessageSize(
4991 *header_);
4992 }
4993
4994 if (has_maxversion()) {
4995 // required uint32 maxVersion = 2;
4996 total_size += 1 +
4997 ::google::protobuf::internal::WireFormatLite::UInt32Size(
4998 this->maxversion());
4999 }
5000
5001 return total_size;
5002}
5003size_t OpRequestShortCircuitAccessProto::ByteSizeLong() const {
5004// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
5005 size_t total_size = 0;
5006
5007 if (_internal_metadata_.have_unknown_fields()) {
5008 total_size +=
5009 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5010 _internal_metadata_.unknown_fields());
5011 }
5012 if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present.
5013 // required .Hdfs.Internal.BaseHeaderProto header = 1;
5014 total_size += 1 +
5015 ::google::protobuf::internal::WireFormatLite::MessageSize(
5016 *header_);
5017
5018 // required uint32 maxVersion = 2;
5019 total_size += 1 +
5020 ::google::protobuf::internal::WireFormatLite::UInt32Size(
5021 this->maxversion());
5022
5023 } else {
5024 total_size += RequiredFieldsByteSizeFallback();
5025 }
5026 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
5027 SetCachedSize(cached_size);
5028 return total_size;
5029}
5030
5031void OpRequestShortCircuitAccessProto::MergeFrom(const ::google::protobuf::Message& from) {
5032// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
5033 GOOGLE_DCHECK_NE(&from, this);
5034 const OpRequestShortCircuitAccessProto* source =
5035 ::google::protobuf::internal::DynamicCastToGenerated<const OpRequestShortCircuitAccessProto>(
5036 &from);
5037 if (source == NULL) {
5038 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.OpRequestShortCircuitAccessProto)
5039 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5040 } else {
5041 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.OpRequestShortCircuitAccessProto)
5042 MergeFrom(*source);
5043 }
5044}
5045
5046void OpRequestShortCircuitAccessProto::MergeFrom(const OpRequestShortCircuitAccessProto& from) {
5047// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
5048 GOOGLE_DCHECK_NE(&from, this);
5049 _internal_metadata_.MergeFrom(from._internal_metadata_);
5050 ::google::protobuf::uint32 cached_has_bits = 0;
5051 (void) cached_has_bits;
5052
5053 cached_has_bits = from._has_bits_[0];
5054 if (cached_has_bits & 3u) {
5055 if (cached_has_bits & 0x00000001u) {
5056 mutable_header()->::Hdfs::Internal::BaseHeaderProto::MergeFrom(from.header());
5057 }
5058 if (cached_has_bits & 0x00000002u) {
5059 maxversion_ = from.maxversion_;
5060 }
5061 _has_bits_[0] |= cached_has_bits;
5062 }
5063}
5064
5065void OpRequestShortCircuitAccessProto::CopyFrom(const ::google::protobuf::Message& from) {
5066// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
5067 if (&from == this) return;
5068 Clear();
5069 MergeFrom(from);
5070}
5071
5072void OpRequestShortCircuitAccessProto::CopyFrom(const OpRequestShortCircuitAccessProto& from) {
5073// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.OpRequestShortCircuitAccessProto)
5074 if (&from == this) return;
5075 Clear();
5076 MergeFrom(from);
5077}
5078
5079bool OpRequestShortCircuitAccessProto::IsInitialized() const {
5080 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
5081 if (has_header()) {
5082 if (!this->header_->IsInitialized()) return false;
5083 }
5084 return true;
5085}
5086
5087void OpRequestShortCircuitAccessProto::Swap(OpRequestShortCircuitAccessProto* other) {
5088 if (other == this) return;
5089 InternalSwap(other);
5090}
5091void OpRequestShortCircuitAccessProto::InternalSwap(OpRequestShortCircuitAccessProto* other) {
5092 using std::swap;
5093 swap(header_, other->header_);
5094 swap(maxversion_, other->maxversion_);
5095 swap(_has_bits_[0], other->_has_bits_[0]);
5096 _internal_metadata_.Swap(&other->_internal_metadata_);
5097}
5098
5099::google::protobuf::Metadata OpRequestShortCircuitAccessProto::GetMetadata() const {
5100 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
5101 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
5102}
5103
5104
5105// ===================================================================
5106
5107void PacketHeaderProto::InitAsDefaultInstance() {
5108}
5109#if !defined(_MSC_VER) || _MSC_VER >= 1900
5110const int PacketHeaderProto::kOffsetInBlockFieldNumber;
5111const int PacketHeaderProto::kSeqnoFieldNumber;
5112const int PacketHeaderProto::kLastPacketInBlockFieldNumber;
5113const int PacketHeaderProto::kDataLenFieldNumber;
5114const int PacketHeaderProto::kSyncBlockFieldNumber;
5115#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
5116
5117PacketHeaderProto::PacketHeaderProto()
5118 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
5119 ::google::protobuf::internal::InitSCC(
5120 &protobuf_datatransfer_2eproto::scc_info_PacketHeaderProto.base);
5121 SharedCtor();
5122 // @@protoc_insertion_point(constructor:Hdfs.Internal.PacketHeaderProto)
5123}
5124PacketHeaderProto::PacketHeaderProto(const PacketHeaderProto& from)
5125 : ::google::protobuf::Message(),
5126 _internal_metadata_(NULL),
5127 _has_bits_(from._has_bits_) {
5128 _internal_metadata_.MergeFrom(from._internal_metadata_);
5129 ::memcpy(&offsetinblock_, &from.offsetinblock_,
5130 static_cast<size_t>(reinterpret_cast<char*>(&syncblock_) -
5131 reinterpret_cast<char*>(&offsetinblock_)) + sizeof(syncblock_));
5132 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.PacketHeaderProto)
5133}
5134
5135void PacketHeaderProto::SharedCtor() {
5136 ::memset(&offsetinblock_, 0, static_cast<size_t>(
5137 reinterpret_cast<char*>(&syncblock_) -
5138 reinterpret_cast<char*>(&offsetinblock_)) + sizeof(syncblock_));
5139}
5140
5141PacketHeaderProto::~PacketHeaderProto() {
5142 // @@protoc_insertion_point(destructor:Hdfs.Internal.PacketHeaderProto)
5143 SharedDtor();
5144}
5145
5146void PacketHeaderProto::SharedDtor() {
5147}
5148
5149void PacketHeaderProto::SetCachedSize(int size) const {
5150 _cached_size_.Set(size);
5151}
5152const ::google::protobuf::Descriptor* PacketHeaderProto::descriptor() {
5153 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
5154 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
5155}
5156
5157const PacketHeaderProto& PacketHeaderProto::default_instance() {
5158 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_PacketHeaderProto.base);
5159 return *internal_default_instance();
5160}
5161
5162
5163void PacketHeaderProto::Clear() {
5164// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.PacketHeaderProto)
5165 ::google::protobuf::uint32 cached_has_bits = 0;
5166 // Prevent compiler warnings about cached_has_bits being unused
5167 (void) cached_has_bits;
5168
5169 cached_has_bits = _has_bits_[0];
5170 if (cached_has_bits & 31u) {
5171 ::memset(&offsetinblock_, 0, static_cast<size_t>(
5172 reinterpret_cast<char*>(&syncblock_) -
5173 reinterpret_cast<char*>(&offsetinblock_)) + sizeof(syncblock_));
5174 }
5175 _has_bits_.Clear();
5176 _internal_metadata_.Clear();
5177}
5178
5179bool PacketHeaderProto::MergePartialFromCodedStream(
5180 ::google::protobuf::io::CodedInputStream* input) {
5181#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
5182 ::google::protobuf::uint32 tag;
5183 // @@protoc_insertion_point(parse_start:Hdfs.Internal.PacketHeaderProto)
5184 for (;;) {
5185 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
5186 tag = p.first;
5187 if (!p.second) goto handle_unusual;
5188 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5189 // required sfixed64 offsetInBlock = 1;
5190 case 1: {
5191 if (static_cast< ::google::protobuf::uint8>(tag) ==
5192 static_cast< ::google::protobuf::uint8>(9u /* 9 & 0xFF */)) {
5193 set_has_offsetinblock();
5194 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5195 ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64>(
5196 input, &offsetinblock_)));
5197 } else {
5198 goto handle_unusual;
5199 }
5200 break;
5201 }
5202
5203 // required sfixed64 seqno = 2;
5204 case 2: {
5205 if (static_cast< ::google::protobuf::uint8>(tag) ==
5206 static_cast< ::google::protobuf::uint8>(17u /* 17 & 0xFF */)) {
5207 set_has_seqno();
5208 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5209 ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64>(
5210 input, &seqno_)));
5211 } else {
5212 goto handle_unusual;
5213 }
5214 break;
5215 }
5216
5217 // required bool lastPacketInBlock = 3;
5218 case 3: {
5219 if (static_cast< ::google::protobuf::uint8>(tag) ==
5220 static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
5221 set_has_lastpacketinblock();
5222 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5223 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5224 input, &lastpacketinblock_)));
5225 } else {
5226 goto handle_unusual;
5227 }
5228 break;
5229 }
5230
5231 // required sfixed32 dataLen = 4;
5232 case 4: {
5233 if (static_cast< ::google::protobuf::uint8>(tag) ==
5234 static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
5235 set_has_datalen();
5236 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5237 ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SFIXED32>(
5238 input, &datalen_)));
5239 } else {
5240 goto handle_unusual;
5241 }
5242 break;
5243 }
5244
5245 // optional bool syncBlock = 5 [default = false];
5246 case 5: {
5247 if (static_cast< ::google::protobuf::uint8>(tag) ==
5248 static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
5249 set_has_syncblock();
5250 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5251 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5252 input, &syncblock_)));
5253 } else {
5254 goto handle_unusual;
5255 }
5256 break;
5257 }
5258
5259 default: {
5260 handle_unusual:
5261 if (tag == 0) {
5262 goto success;
5263 }
5264 DO_(::google::protobuf::internal::WireFormat::SkipField(
5265 input, tag, _internal_metadata_.mutable_unknown_fields()));
5266 break;
5267 }
5268 }
5269 }
5270success:
5271 // @@protoc_insertion_point(parse_success:Hdfs.Internal.PacketHeaderProto)
5272 return true;
5273failure:
5274 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.PacketHeaderProto)
5275 return false;
5276#undef DO_
5277}
5278
5279void PacketHeaderProto::SerializeWithCachedSizes(
5280 ::google::protobuf::io::CodedOutputStream* output) const {
5281 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.PacketHeaderProto)
5282 ::google::protobuf::uint32 cached_has_bits = 0;
5283 (void) cached_has_bits;
5284
5285 cached_has_bits = _has_bits_[0];
5286 // required sfixed64 offsetInBlock = 1;
5287 if (cached_has_bits & 0x00000001u) {
5288 ::google::protobuf::internal::WireFormatLite::WriteSFixed64(1, this->offsetinblock(), output);
5289 }
5290
5291 // required sfixed64 seqno = 2;
5292 if (cached_has_bits & 0x00000002u) {
5293 ::google::protobuf::internal::WireFormatLite::WriteSFixed64(2, this->seqno(), output);
5294 }
5295
5296 // required bool lastPacketInBlock = 3;
5297 if (cached_has_bits & 0x00000008u) {
5298 ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->lastpacketinblock(), output);
5299 }
5300
5301 // required sfixed32 dataLen = 4;
5302 if (cached_has_bits & 0x00000004u) {
5303 ::google::protobuf::internal::WireFormatLite::WriteSFixed32(4, this->datalen(), output);
5304 }
5305
5306 // optional bool syncBlock = 5 [default = false];
5307 if (cached_has_bits & 0x00000010u) {
5308 ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->syncblock(), output);
5309 }
5310
5311 if (_internal_metadata_.have_unknown_fields()) {
5312 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5313 _internal_metadata_.unknown_fields(), output);
5314 }
5315 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.PacketHeaderProto)
5316}
5317
5318::google::protobuf::uint8* PacketHeaderProto::InternalSerializeWithCachedSizesToArray(
5319 bool deterministic, ::google::protobuf::uint8* target) const {
5320 (void)deterministic; // Unused
5321 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.PacketHeaderProto)
5322 ::google::protobuf::uint32 cached_has_bits = 0;
5323 (void) cached_has_bits;
5324
5325 cached_has_bits = _has_bits_[0];
5326 // required sfixed64 offsetInBlock = 1;
5327 if (cached_has_bits & 0x00000001u) {
5328 target = ::google::protobuf::internal::WireFormatLite::WriteSFixed64ToArray(1, this->offsetinblock(), target);
5329 }
5330
5331 // required sfixed64 seqno = 2;
5332 if (cached_has_bits & 0x00000002u) {
5333 target = ::google::protobuf::internal::WireFormatLite::WriteSFixed64ToArray(2, this->seqno(), target);
5334 }
5335
5336 // required bool lastPacketInBlock = 3;
5337 if (cached_has_bits & 0x00000008u) {
5338 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->lastpacketinblock(), target);
5339 }
5340
5341 // required sfixed32 dataLen = 4;
5342 if (cached_has_bits & 0x00000004u) {
5343 target = ::google::protobuf::internal::WireFormatLite::WriteSFixed32ToArray(4, this->datalen(), target);
5344 }
5345
5346 // optional bool syncBlock = 5 [default = false];
5347 if (cached_has_bits & 0x00000010u) {
5348 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->syncblock(), target);
5349 }
5350
5351 if (_internal_metadata_.have_unknown_fields()) {
5352 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5353 _internal_metadata_.unknown_fields(), target);
5354 }
5355 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.PacketHeaderProto)
5356 return target;
5357}
5358
5359size_t PacketHeaderProto::RequiredFieldsByteSizeFallback() const {
5360// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.PacketHeaderProto)
5361 size_t total_size = 0;
5362
5363 if (has_offsetinblock()) {
5364 // required sfixed64 offsetInBlock = 1;
5365 total_size += 1 + 8;
5366 }
5367
5368 if (has_seqno()) {
5369 // required sfixed64 seqno = 2;
5370 total_size += 1 + 8;
5371 }
5372
5373 if (has_datalen()) {
5374 // required sfixed32 dataLen = 4;
5375 total_size += 1 + 4;
5376 }
5377
5378 if (has_lastpacketinblock()) {
5379 // required bool lastPacketInBlock = 3;
5380 total_size += 1 + 1;
5381 }
5382
5383 return total_size;
5384}
5385size_t PacketHeaderProto::ByteSizeLong() const {
5386// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.PacketHeaderProto)
5387 size_t total_size = 0;
5388
5389 if (_internal_metadata_.have_unknown_fields()) {
5390 total_size +=
5391 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5392 _internal_metadata_.unknown_fields());
5393 }
5394 if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) { // All required fields are present.
5395 // required sfixed64 offsetInBlock = 1;
5396 total_size += 1 + 8;
5397
5398 // required sfixed64 seqno = 2;
5399 total_size += 1 + 8;
5400
5401 // required sfixed32 dataLen = 4;
5402 total_size += 1 + 4;
5403
5404 // required bool lastPacketInBlock = 3;
5405 total_size += 1 + 1;
5406
5407 } else {
5408 total_size += RequiredFieldsByteSizeFallback();
5409 }
5410 // optional bool syncBlock = 5 [default = false];
5411 if (has_syncblock()) {
5412 total_size += 1 + 1;
5413 }
5414
5415 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
5416 SetCachedSize(cached_size);
5417 return total_size;
5418}
5419
5420void PacketHeaderProto::MergeFrom(const ::google::protobuf::Message& from) {
5421// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.PacketHeaderProto)
5422 GOOGLE_DCHECK_NE(&from, this);
5423 const PacketHeaderProto* source =
5424 ::google::protobuf::internal::DynamicCastToGenerated<const PacketHeaderProto>(
5425 &from);
5426 if (source == NULL) {
5427 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.PacketHeaderProto)
5428 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5429 } else {
5430 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.PacketHeaderProto)
5431 MergeFrom(*source);
5432 }
5433}
5434
5435void PacketHeaderProto::MergeFrom(const PacketHeaderProto& from) {
5436// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.PacketHeaderProto)
5437 GOOGLE_DCHECK_NE(&from, this);
5438 _internal_metadata_.MergeFrom(from._internal_metadata_);
5439 ::google::protobuf::uint32 cached_has_bits = 0;
5440 (void) cached_has_bits;
5441
5442 cached_has_bits = from._has_bits_[0];
5443 if (cached_has_bits & 31u) {
5444 if (cached_has_bits & 0x00000001u) {
5445 offsetinblock_ = from.offsetinblock_;
5446 }
5447 if (cached_has_bits & 0x00000002u) {
5448 seqno_ = from.seqno_;
5449 }
5450 if (cached_has_bits & 0x00000004u) {
5451 datalen_ = from.datalen_;
5452 }
5453 if (cached_has_bits & 0x00000008u) {
5454 lastpacketinblock_ = from.lastpacketinblock_;
5455 }
5456 if (cached_has_bits & 0x00000010u) {
5457 syncblock_ = from.syncblock_;
5458 }
5459 _has_bits_[0] |= cached_has_bits;
5460 }
5461}
5462
5463void PacketHeaderProto::CopyFrom(const ::google::protobuf::Message& from) {
5464// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.PacketHeaderProto)
5465 if (&from == this) return;
5466 Clear();
5467 MergeFrom(from);
5468}
5469
5470void PacketHeaderProto::CopyFrom(const PacketHeaderProto& from) {
5471// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.PacketHeaderProto)
5472 if (&from == this) return;
5473 Clear();
5474 MergeFrom(from);
5475}
5476
5477bool PacketHeaderProto::IsInitialized() const {
5478 if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
5479 return true;
5480}
5481
5482void PacketHeaderProto::Swap(PacketHeaderProto* other) {
5483 if (other == this) return;
5484 InternalSwap(other);
5485}
5486void PacketHeaderProto::InternalSwap(PacketHeaderProto* other) {
5487 using std::swap;
5488 swap(offsetinblock_, other->offsetinblock_);
5489 swap(seqno_, other->seqno_);
5490 swap(datalen_, other->datalen_);
5491 swap(lastpacketinblock_, other->lastpacketinblock_);
5492 swap(syncblock_, other->syncblock_);
5493 swap(_has_bits_[0], other->_has_bits_[0]);
5494 _internal_metadata_.Swap(&other->_internal_metadata_);
5495}
5496
5497::google::protobuf::Metadata PacketHeaderProto::GetMetadata() const {
5498 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
5499 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
5500}
5501
5502
5503// ===================================================================
5504
5505void PipelineAckProto::InitAsDefaultInstance() {
5506}
5507#if !defined(_MSC_VER) || _MSC_VER >= 1900
5508const int PipelineAckProto::kSeqnoFieldNumber;
5509const int PipelineAckProto::kStatusFieldNumber;
5510const int PipelineAckProto::kDownstreamAckTimeNanosFieldNumber;
5511#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
5512
5513PipelineAckProto::PipelineAckProto()
5514 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
5515 ::google::protobuf::internal::InitSCC(
5516 &protobuf_datatransfer_2eproto::scc_info_PipelineAckProto.base);
5517 SharedCtor();
5518 // @@protoc_insertion_point(constructor:Hdfs.Internal.PipelineAckProto)
5519}
5520PipelineAckProto::PipelineAckProto(const PipelineAckProto& from)
5521 : ::google::protobuf::Message(),
5522 _internal_metadata_(NULL),
5523 _has_bits_(from._has_bits_),
5524 status_(from.status_) {
5525 _internal_metadata_.MergeFrom(from._internal_metadata_);
5526 ::memcpy(&seqno_, &from.seqno_,
5527 static_cast<size_t>(reinterpret_cast<char*>(&downstreamacktimenanos_) -
5528 reinterpret_cast<char*>(&seqno_)) + sizeof(downstreamacktimenanos_));
5529 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.PipelineAckProto)
5530}
5531
5532void PipelineAckProto::SharedCtor() {
5533 ::memset(&seqno_, 0, static_cast<size_t>(
5534 reinterpret_cast<char*>(&downstreamacktimenanos_) -
5535 reinterpret_cast<char*>(&seqno_)) + sizeof(downstreamacktimenanos_));
5536}
5537
5538PipelineAckProto::~PipelineAckProto() {
5539 // @@protoc_insertion_point(destructor:Hdfs.Internal.PipelineAckProto)
5540 SharedDtor();
5541}
5542
5543void PipelineAckProto::SharedDtor() {
5544}
5545
5546void PipelineAckProto::SetCachedSize(int size) const {
5547 _cached_size_.Set(size);
5548}
5549const ::google::protobuf::Descriptor* PipelineAckProto::descriptor() {
5550 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
5551 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
5552}
5553
5554const PipelineAckProto& PipelineAckProto::default_instance() {
5555 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_PipelineAckProto.base);
5556 return *internal_default_instance();
5557}
5558
5559
5560void PipelineAckProto::Clear() {
5561// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.PipelineAckProto)
5562 ::google::protobuf::uint32 cached_has_bits = 0;
5563 // Prevent compiler warnings about cached_has_bits being unused
5564 (void) cached_has_bits;
5565
5566 status_.Clear();
5567 cached_has_bits = _has_bits_[0];
5568 if (cached_has_bits & 3u) {
5569 ::memset(&seqno_, 0, static_cast<size_t>(
5570 reinterpret_cast<char*>(&downstreamacktimenanos_) -
5571 reinterpret_cast<char*>(&seqno_)) + sizeof(downstreamacktimenanos_));
5572 }
5573 _has_bits_.Clear();
5574 _internal_metadata_.Clear();
5575}
5576
5577bool PipelineAckProto::MergePartialFromCodedStream(
5578 ::google::protobuf::io::CodedInputStream* input) {
5579#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
5580 ::google::protobuf::uint32 tag;
5581 // @@protoc_insertion_point(parse_start:Hdfs.Internal.PipelineAckProto)
5582 for (;;) {
5583 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
5584 tag = p.first;
5585 if (!p.second) goto handle_unusual;
5586 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5587 // required sint64 seqno = 1;
5588 case 1: {
5589 if (static_cast< ::google::protobuf::uint8>(tag) ==
5590 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
5591 set_has_seqno();
5592 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5593 ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
5594 input, &seqno_)));
5595 } else {
5596 goto handle_unusual;
5597 }
5598 break;
5599 }
5600
5601 // repeated .Hdfs.Internal.Status status = 2;
5602 case 2: {
5603 if (static_cast< ::google::protobuf::uint8>(tag) ==
5604 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
5605 int value;
5606 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5607 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
5608 input, &value)));
5609 if (::Hdfs::Internal::Status_IsValid(value)) {
5610 add_status(static_cast< ::Hdfs::Internal::Status >(value));
5611 } else {
5612 mutable_unknown_fields()->AddVarint(
5613 2, static_cast< ::google::protobuf::uint64>(value));
5614 }
5615 } else if (
5616 static_cast< ::google::protobuf::uint8>(tag) ==
5617 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
5618 DO_((::google::protobuf::internal::WireFormat::ReadPackedEnumPreserveUnknowns(
5619 input,
5620 2,
5621 ::Hdfs::Internal::Status_IsValid,
5622 mutable_unknown_fields(),
5623 this->mutable_status())));
5624 } else {
5625 goto handle_unusual;
5626 }
5627 break;
5628 }
5629
5630 // optional uint64 downstreamAckTimeNanos = 3 [default = 0];
5631 case 3: {
5632 if (static_cast< ::google::protobuf::uint8>(tag) ==
5633 static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
5634 set_has_downstreamacktimenanos();
5635 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5636 ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
5637 input, &downstreamacktimenanos_)));
5638 } else {
5639 goto handle_unusual;
5640 }
5641 break;
5642 }
5643
5644 default: {
5645 handle_unusual:
5646 if (tag == 0) {
5647 goto success;
5648 }
5649 DO_(::google::protobuf::internal::WireFormat::SkipField(
5650 input, tag, _internal_metadata_.mutable_unknown_fields()));
5651 break;
5652 }
5653 }
5654 }
5655success:
5656 // @@protoc_insertion_point(parse_success:Hdfs.Internal.PipelineAckProto)
5657 return true;
5658failure:
5659 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.PipelineAckProto)
5660 return false;
5661#undef DO_
5662}
5663
5664void PipelineAckProto::SerializeWithCachedSizes(
5665 ::google::protobuf::io::CodedOutputStream* output) const {
5666 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.PipelineAckProto)
5667 ::google::protobuf::uint32 cached_has_bits = 0;
5668 (void) cached_has_bits;
5669
5670 cached_has_bits = _has_bits_[0];
5671 // required sint64 seqno = 1;
5672 if (cached_has_bits & 0x00000001u) {
5673 ::google::protobuf::internal::WireFormatLite::WriteSInt64(1, this->seqno(), output);
5674 }
5675
5676 // repeated .Hdfs.Internal.Status status = 2;
5677 for (int i = 0, n = this->status_size(); i < n; i++) {
5678 ::google::protobuf::internal::WireFormatLite::WriteEnum(
5679 2, this->status(i), output);
5680 }
5681
5682 // optional uint64 downstreamAckTimeNanos = 3 [default = 0];
5683 if (cached_has_bits & 0x00000002u) {
5684 ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->downstreamacktimenanos(), output);
5685 }
5686
5687 if (_internal_metadata_.have_unknown_fields()) {
5688 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5689 _internal_metadata_.unknown_fields(), output);
5690 }
5691 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.PipelineAckProto)
5692}
5693
5694::google::protobuf::uint8* PipelineAckProto::InternalSerializeWithCachedSizesToArray(
5695 bool deterministic, ::google::protobuf::uint8* target) const {
5696 (void)deterministic; // Unused
5697 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.PipelineAckProto)
5698 ::google::protobuf::uint32 cached_has_bits = 0;
5699 (void) cached_has_bits;
5700
5701 cached_has_bits = _has_bits_[0];
5702 // required sint64 seqno = 1;
5703 if (cached_has_bits & 0x00000001u) {
5704 target = ::google::protobuf::internal::WireFormatLite::WriteSInt64ToArray(1, this->seqno(), target);
5705 }
5706
5707 // repeated .Hdfs.Internal.Status status = 2;
5708 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
5709 2, this->status_, target);
5710
5711 // optional uint64 downstreamAckTimeNanos = 3 [default = 0];
5712 if (cached_has_bits & 0x00000002u) {
5713 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->downstreamacktimenanos(), target);
5714 }
5715
5716 if (_internal_metadata_.have_unknown_fields()) {
5717 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5718 _internal_metadata_.unknown_fields(), target);
5719 }
5720 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.PipelineAckProto)
5721 return target;
5722}
5723
5724size_t PipelineAckProto::ByteSizeLong() const {
5725// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.PipelineAckProto)
5726 size_t total_size = 0;
5727
5728 if (_internal_metadata_.have_unknown_fields()) {
5729 total_size +=
5730 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5731 _internal_metadata_.unknown_fields());
5732 }
5733 // required sint64 seqno = 1;
5734 if (has_seqno()) {
5735 total_size += 1 +
5736 ::google::protobuf::internal::WireFormatLite::SInt64Size(
5737 this->seqno());
5738 }
5739 // repeated .Hdfs.Internal.Status status = 2;
5740 {
5741 size_t data_size = 0;
5742 unsigned int count = static_cast<unsigned int>(this->status_size());for (unsigned int i = 0; i < count; i++) {
5743 data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
5744 this->status(static_cast<int>(i)));
5745 }
5746 total_size += (1UL * count) + data_size;
5747 }
5748
5749 // optional uint64 downstreamAckTimeNanos = 3 [default = 0];
5750 if (has_downstreamacktimenanos()) {
5751 total_size += 1 +
5752 ::google::protobuf::internal::WireFormatLite::UInt64Size(
5753 this->downstreamacktimenanos());
5754 }
5755
5756 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
5757 SetCachedSize(cached_size);
5758 return total_size;
5759}
5760
5761void PipelineAckProto::MergeFrom(const ::google::protobuf::Message& from) {
5762// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.PipelineAckProto)
5763 GOOGLE_DCHECK_NE(&from, this);
5764 const PipelineAckProto* source =
5765 ::google::protobuf::internal::DynamicCastToGenerated<const PipelineAckProto>(
5766 &from);
5767 if (source == NULL) {
5768 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.PipelineAckProto)
5769 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5770 } else {
5771 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.PipelineAckProto)
5772 MergeFrom(*source);
5773 }
5774}
5775
5776void PipelineAckProto::MergeFrom(const PipelineAckProto& from) {
5777// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.PipelineAckProto)
5778 GOOGLE_DCHECK_NE(&from, this);
5779 _internal_metadata_.MergeFrom(from._internal_metadata_);
5780 ::google::protobuf::uint32 cached_has_bits = 0;
5781 (void) cached_has_bits;
5782
5783 status_.MergeFrom(from.status_);
5784 cached_has_bits = from._has_bits_[0];
5785 if (cached_has_bits & 3u) {
5786 if (cached_has_bits & 0x00000001u) {
5787 seqno_ = from.seqno_;
5788 }
5789 if (cached_has_bits & 0x00000002u) {
5790 downstreamacktimenanos_ = from.downstreamacktimenanos_;
5791 }
5792 _has_bits_[0] |= cached_has_bits;
5793 }
5794}
5795
5796void PipelineAckProto::CopyFrom(const ::google::protobuf::Message& from) {
5797// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.PipelineAckProto)
5798 if (&from == this) return;
5799 Clear();
5800 MergeFrom(from);
5801}
5802
5803void PipelineAckProto::CopyFrom(const PipelineAckProto& from) {
5804// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.PipelineAckProto)
5805 if (&from == this) return;
5806 Clear();
5807 MergeFrom(from);
5808}
5809
5810bool PipelineAckProto::IsInitialized() const {
5811 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
5812 return true;
5813}
5814
5815void PipelineAckProto::Swap(PipelineAckProto* other) {
5816 if (other == this) return;
5817 InternalSwap(other);
5818}
5819void PipelineAckProto::InternalSwap(PipelineAckProto* other) {
5820 using std::swap;
5821 status_.InternalSwap(&other->status_);
5822 swap(seqno_, other->seqno_);
5823 swap(downstreamacktimenanos_, other->downstreamacktimenanos_);
5824 swap(_has_bits_[0], other->_has_bits_[0]);
5825 _internal_metadata_.Swap(&other->_internal_metadata_);
5826}
5827
5828::google::protobuf::Metadata PipelineAckProto::GetMetadata() const {
5829 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
5830 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
5831}
5832
5833
5834// ===================================================================
5835
5836void ReadOpChecksumInfoProto::InitAsDefaultInstance() {
5837 ::Hdfs::Internal::_ReadOpChecksumInfoProto_default_instance_._instance.get_mutable()->checksum_ = const_cast< ::Hdfs::Internal::ChecksumProto*>(
5838 ::Hdfs::Internal::ChecksumProto::internal_default_instance());
5839}
5840#if !defined(_MSC_VER) || _MSC_VER >= 1900
5841const int ReadOpChecksumInfoProto::kChecksumFieldNumber;
5842const int ReadOpChecksumInfoProto::kChunkOffsetFieldNumber;
5843#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
5844
5845ReadOpChecksumInfoProto::ReadOpChecksumInfoProto()
5846 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
5847 ::google::protobuf::internal::InitSCC(
5848 &protobuf_datatransfer_2eproto::scc_info_ReadOpChecksumInfoProto.base);
5849 SharedCtor();
5850 // @@protoc_insertion_point(constructor:Hdfs.Internal.ReadOpChecksumInfoProto)
5851}
5852ReadOpChecksumInfoProto::ReadOpChecksumInfoProto(const ReadOpChecksumInfoProto& from)
5853 : ::google::protobuf::Message(),
5854 _internal_metadata_(NULL),
5855 _has_bits_(from._has_bits_) {
5856 _internal_metadata_.MergeFrom(from._internal_metadata_);
5857 if (from.has_checksum()) {
5858 checksum_ = new ::Hdfs::Internal::ChecksumProto(*from.checksum_);
5859 } else {
5860 checksum_ = NULL;
5861 }
5862 chunkoffset_ = from.chunkoffset_;
5863 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.ReadOpChecksumInfoProto)
5864}
5865
5866void ReadOpChecksumInfoProto::SharedCtor() {
5867 ::memset(&checksum_, 0, static_cast<size_t>(
5868 reinterpret_cast<char*>(&chunkoffset_) -
5869 reinterpret_cast<char*>(&checksum_)) + sizeof(chunkoffset_));
5870}
5871
5872ReadOpChecksumInfoProto::~ReadOpChecksumInfoProto() {
5873 // @@protoc_insertion_point(destructor:Hdfs.Internal.ReadOpChecksumInfoProto)
5874 SharedDtor();
5875}
5876
5877void ReadOpChecksumInfoProto::SharedDtor() {
5878 if (this != internal_default_instance()) delete checksum_;
5879}
5880
5881void ReadOpChecksumInfoProto::SetCachedSize(int size) const {
5882 _cached_size_.Set(size);
5883}
5884const ::google::protobuf::Descriptor* ReadOpChecksumInfoProto::descriptor() {
5885 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
5886 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
5887}
5888
5889const ReadOpChecksumInfoProto& ReadOpChecksumInfoProto::default_instance() {
5890 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_ReadOpChecksumInfoProto.base);
5891 return *internal_default_instance();
5892}
5893
5894
5895void ReadOpChecksumInfoProto::Clear() {
5896// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.ReadOpChecksumInfoProto)
5897 ::google::protobuf::uint32 cached_has_bits = 0;
5898 // Prevent compiler warnings about cached_has_bits being unused
5899 (void) cached_has_bits;
5900
5901 cached_has_bits = _has_bits_[0];
5902 if (cached_has_bits & 0x00000001u) {
5903 GOOGLE_DCHECK(checksum_ != NULL);
5904 checksum_->Clear();
5905 }
5906 chunkoffset_ = GOOGLE_ULONGLONG(0);
5907 _has_bits_.Clear();
5908 _internal_metadata_.Clear();
5909}
5910
5911bool ReadOpChecksumInfoProto::MergePartialFromCodedStream(
5912 ::google::protobuf::io::CodedInputStream* input) {
5913#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
5914 ::google::protobuf::uint32 tag;
5915 // @@protoc_insertion_point(parse_start:Hdfs.Internal.ReadOpChecksumInfoProto)
5916 for (;;) {
5917 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
5918 tag = p.first;
5919 if (!p.second) goto handle_unusual;
5920 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5921 // required .Hdfs.Internal.ChecksumProto checksum = 1;
5922 case 1: {
5923 if (static_cast< ::google::protobuf::uint8>(tag) ==
5924 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
5925 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
5926 input, mutable_checksum()));
5927 } else {
5928 goto handle_unusual;
5929 }
5930 break;
5931 }
5932
5933 // required uint64 chunkOffset = 2;
5934 case 2: {
5935 if (static_cast< ::google::protobuf::uint8>(tag) ==
5936 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
5937 set_has_chunkoffset();
5938 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5939 ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
5940 input, &chunkoffset_)));
5941 } else {
5942 goto handle_unusual;
5943 }
5944 break;
5945 }
5946
5947 default: {
5948 handle_unusual:
5949 if (tag == 0) {
5950 goto success;
5951 }
5952 DO_(::google::protobuf::internal::WireFormat::SkipField(
5953 input, tag, _internal_metadata_.mutable_unknown_fields()));
5954 break;
5955 }
5956 }
5957 }
5958success:
5959 // @@protoc_insertion_point(parse_success:Hdfs.Internal.ReadOpChecksumInfoProto)
5960 return true;
5961failure:
5962 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.ReadOpChecksumInfoProto)
5963 return false;
5964#undef DO_
5965}
5966
5967void ReadOpChecksumInfoProto::SerializeWithCachedSizes(
5968 ::google::protobuf::io::CodedOutputStream* output) const {
5969 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.ReadOpChecksumInfoProto)
5970 ::google::protobuf::uint32 cached_has_bits = 0;
5971 (void) cached_has_bits;
5972
5973 cached_has_bits = _has_bits_[0];
5974 // required .Hdfs.Internal.ChecksumProto checksum = 1;
5975 if (cached_has_bits & 0x00000001u) {
5976 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
5977 1, this->_internal_checksum(), output);
5978 }
5979
5980 // required uint64 chunkOffset = 2;
5981 if (cached_has_bits & 0x00000002u) {
5982 ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->chunkoffset(), output);
5983 }
5984
5985 if (_internal_metadata_.have_unknown_fields()) {
5986 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5987 _internal_metadata_.unknown_fields(), output);
5988 }
5989 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.ReadOpChecksumInfoProto)
5990}
5991
5992::google::protobuf::uint8* ReadOpChecksumInfoProto::InternalSerializeWithCachedSizesToArray(
5993 bool deterministic, ::google::protobuf::uint8* target) const {
5994 (void)deterministic; // Unused
5995 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.ReadOpChecksumInfoProto)
5996 ::google::protobuf::uint32 cached_has_bits = 0;
5997 (void) cached_has_bits;
5998
5999 cached_has_bits = _has_bits_[0];
6000 // required .Hdfs.Internal.ChecksumProto checksum = 1;
6001 if (cached_has_bits & 0x00000001u) {
6002 target = ::google::protobuf::internal::WireFormatLite::
6003 InternalWriteMessageToArray(
6004 1, this->_internal_checksum(), deterministic, target);
6005 }
6006
6007 // required uint64 chunkOffset = 2;
6008 if (cached_has_bits & 0x00000002u) {
6009 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->chunkoffset(), target);
6010 }
6011
6012 if (_internal_metadata_.have_unknown_fields()) {
6013 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6014 _internal_metadata_.unknown_fields(), target);
6015 }
6016 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.ReadOpChecksumInfoProto)
6017 return target;
6018}
6019
6020size_t ReadOpChecksumInfoProto::RequiredFieldsByteSizeFallback() const {
6021// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.ReadOpChecksumInfoProto)
6022 size_t total_size = 0;
6023
6024 if (has_checksum()) {
6025 // required .Hdfs.Internal.ChecksumProto checksum = 1;
6026 total_size += 1 +
6027 ::google::protobuf::internal::WireFormatLite::MessageSize(
6028 *checksum_);
6029 }
6030
6031 if (has_chunkoffset()) {
6032 // required uint64 chunkOffset = 2;
6033 total_size += 1 +
6034 ::google::protobuf::internal::WireFormatLite::UInt64Size(
6035 this->chunkoffset());
6036 }
6037
6038 return total_size;
6039}
6040size_t ReadOpChecksumInfoProto::ByteSizeLong() const {
6041// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.ReadOpChecksumInfoProto)
6042 size_t total_size = 0;
6043
6044 if (_internal_metadata_.have_unknown_fields()) {
6045 total_size +=
6046 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
6047 _internal_metadata_.unknown_fields());
6048 }
6049 if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present.
6050 // required .Hdfs.Internal.ChecksumProto checksum = 1;
6051 total_size += 1 +
6052 ::google::protobuf::internal::WireFormatLite::MessageSize(
6053 *checksum_);
6054
6055 // required uint64 chunkOffset = 2;
6056 total_size += 1 +
6057 ::google::protobuf::internal::WireFormatLite::UInt64Size(
6058 this->chunkoffset());
6059
6060 } else {
6061 total_size += RequiredFieldsByteSizeFallback();
6062 }
6063 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
6064 SetCachedSize(cached_size);
6065 return total_size;
6066}
6067
6068void ReadOpChecksumInfoProto::MergeFrom(const ::google::protobuf::Message& from) {
6069// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.ReadOpChecksumInfoProto)
6070 GOOGLE_DCHECK_NE(&from, this);
6071 const ReadOpChecksumInfoProto* source =
6072 ::google::protobuf::internal::DynamicCastToGenerated<const ReadOpChecksumInfoProto>(
6073 &from);
6074 if (source == NULL) {
6075 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.ReadOpChecksumInfoProto)
6076 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6077 } else {
6078 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.ReadOpChecksumInfoProto)
6079 MergeFrom(*source);
6080 }
6081}
6082
6083void ReadOpChecksumInfoProto::MergeFrom(const ReadOpChecksumInfoProto& from) {
6084// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.ReadOpChecksumInfoProto)
6085 GOOGLE_DCHECK_NE(&from, this);
6086 _internal_metadata_.MergeFrom(from._internal_metadata_);
6087 ::google::protobuf::uint32 cached_has_bits = 0;
6088 (void) cached_has_bits;
6089
6090 cached_has_bits = from._has_bits_[0];
6091 if (cached_has_bits & 3u) {
6092 if (cached_has_bits & 0x00000001u) {
6093 mutable_checksum()->::Hdfs::Internal::ChecksumProto::MergeFrom(from.checksum());
6094 }
6095 if (cached_has_bits & 0x00000002u) {
6096 chunkoffset_ = from.chunkoffset_;
6097 }
6098 _has_bits_[0] |= cached_has_bits;
6099 }
6100}
6101
6102void ReadOpChecksumInfoProto::CopyFrom(const ::google::protobuf::Message& from) {
6103// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.ReadOpChecksumInfoProto)
6104 if (&from == this) return;
6105 Clear();
6106 MergeFrom(from);
6107}
6108
6109void ReadOpChecksumInfoProto::CopyFrom(const ReadOpChecksumInfoProto& from) {
6110// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.ReadOpChecksumInfoProto)
6111 if (&from == this) return;
6112 Clear();
6113 MergeFrom(from);
6114}
6115
6116bool ReadOpChecksumInfoProto::IsInitialized() const {
6117 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
6118 if (has_checksum()) {
6119 if (!this->checksum_->IsInitialized()) return false;
6120 }
6121 return true;
6122}
6123
6124void ReadOpChecksumInfoProto::Swap(ReadOpChecksumInfoProto* other) {
6125 if (other == this) return;
6126 InternalSwap(other);
6127}
6128void ReadOpChecksumInfoProto::InternalSwap(ReadOpChecksumInfoProto* other) {
6129 using std::swap;
6130 swap(checksum_, other->checksum_);
6131 swap(chunkoffset_, other->chunkoffset_);
6132 swap(_has_bits_[0], other->_has_bits_[0]);
6133 _internal_metadata_.Swap(&other->_internal_metadata_);
6134}
6135
6136::google::protobuf::Metadata ReadOpChecksumInfoProto::GetMetadata() const {
6137 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
6138 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
6139}
6140
6141
6142// ===================================================================
6143
6144void BlockOpResponseProto::InitAsDefaultInstance() {
6145 ::Hdfs::Internal::_BlockOpResponseProto_default_instance_._instance.get_mutable()->checksumresponse_ = const_cast< ::Hdfs::Internal::OpBlockChecksumResponseProto*>(
6146 ::Hdfs::Internal::OpBlockChecksumResponseProto::internal_default_instance());
6147 ::Hdfs::Internal::_BlockOpResponseProto_default_instance_._instance.get_mutable()->readopchecksuminfo_ = const_cast< ::Hdfs::Internal::ReadOpChecksumInfoProto*>(
6148 ::Hdfs::Internal::ReadOpChecksumInfoProto::internal_default_instance());
6149}
6150#if !defined(_MSC_VER) || _MSC_VER >= 1900
6151const int BlockOpResponseProto::kStatusFieldNumber;
6152const int BlockOpResponseProto::kFirstBadLinkFieldNumber;
6153const int BlockOpResponseProto::kChecksumResponseFieldNumber;
6154const int BlockOpResponseProto::kReadOpChecksumInfoFieldNumber;
6155const int BlockOpResponseProto::kMessageFieldNumber;
6156const int BlockOpResponseProto::kShortCircuitAccessVersionFieldNumber;
6157#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
6158
6159BlockOpResponseProto::BlockOpResponseProto()
6160 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
6161 ::google::protobuf::internal::InitSCC(
6162 &protobuf_datatransfer_2eproto::scc_info_BlockOpResponseProto.base);
6163 SharedCtor();
6164 // @@protoc_insertion_point(constructor:Hdfs.Internal.BlockOpResponseProto)
6165}
6166BlockOpResponseProto::BlockOpResponseProto(const BlockOpResponseProto& from)
6167 : ::google::protobuf::Message(),
6168 _internal_metadata_(NULL),
6169 _has_bits_(from._has_bits_) {
6170 _internal_metadata_.MergeFrom(from._internal_metadata_);
6171 firstbadlink_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6172 if (from.has_firstbadlink()) {
6173 firstbadlink_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.firstbadlink_);
6174 }
6175 message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6176 if (from.has_message()) {
6177 message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
6178 }
6179 if (from.has_checksumresponse()) {
6180 checksumresponse_ = new ::Hdfs::Internal::OpBlockChecksumResponseProto(*from.checksumresponse_);
6181 } else {
6182 checksumresponse_ = NULL;
6183 }
6184 if (from.has_readopchecksuminfo()) {
6185 readopchecksuminfo_ = new ::Hdfs::Internal::ReadOpChecksumInfoProto(*from.readopchecksuminfo_);
6186 } else {
6187 readopchecksuminfo_ = NULL;
6188 }
6189 ::memcpy(&status_, &from.status_,
6190 static_cast<size_t>(reinterpret_cast<char*>(&shortcircuitaccessversion_) -
6191 reinterpret_cast<char*>(&status_)) + sizeof(shortcircuitaccessversion_));
6192 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.BlockOpResponseProto)
6193}
6194
6195void BlockOpResponseProto::SharedCtor() {
6196 firstbadlink_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6197 message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6198 ::memset(&checksumresponse_, 0, static_cast<size_t>(
6199 reinterpret_cast<char*>(&shortcircuitaccessversion_) -
6200 reinterpret_cast<char*>(&checksumresponse_)) + sizeof(shortcircuitaccessversion_));
6201}
6202
6203BlockOpResponseProto::~BlockOpResponseProto() {
6204 // @@protoc_insertion_point(destructor:Hdfs.Internal.BlockOpResponseProto)
6205 SharedDtor();
6206}
6207
6208void BlockOpResponseProto::SharedDtor() {
6209 firstbadlink_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6210 message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6211 if (this != internal_default_instance()) delete checksumresponse_;
6212 if (this != internal_default_instance()) delete readopchecksuminfo_;
6213}
6214
6215void BlockOpResponseProto::SetCachedSize(int size) const {
6216 _cached_size_.Set(size);
6217}
6218const ::google::protobuf::Descriptor* BlockOpResponseProto::descriptor() {
6219 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
6220 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
6221}
6222
6223const BlockOpResponseProto& BlockOpResponseProto::default_instance() {
6224 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_BlockOpResponseProto.base);
6225 return *internal_default_instance();
6226}
6227
6228
6229void BlockOpResponseProto::Clear() {
6230// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.BlockOpResponseProto)
6231 ::google::protobuf::uint32 cached_has_bits = 0;
6232 // Prevent compiler warnings about cached_has_bits being unused
6233 (void) cached_has_bits;
6234
6235 cached_has_bits = _has_bits_[0];
6236 if (cached_has_bits & 15u) {
6237 if (cached_has_bits & 0x00000001u) {
6238 firstbadlink_.ClearNonDefaultToEmptyNoArena();
6239 }
6240 if (cached_has_bits & 0x00000002u) {
6241 message_.ClearNonDefaultToEmptyNoArena();
6242 }
6243 if (cached_has_bits & 0x00000004u) {
6244 GOOGLE_DCHECK(checksumresponse_ != NULL);
6245 checksumresponse_->Clear();
6246 }
6247 if (cached_has_bits & 0x00000008u) {
6248 GOOGLE_DCHECK(readopchecksuminfo_ != NULL);
6249 readopchecksuminfo_->Clear();
6250 }
6251 }
6252 if (cached_has_bits & 48u) {
6253 ::memset(&status_, 0, static_cast<size_t>(
6254 reinterpret_cast<char*>(&shortcircuitaccessversion_) -
6255 reinterpret_cast<char*>(&status_)) + sizeof(shortcircuitaccessversion_));
6256 }
6257 _has_bits_.Clear();
6258 _internal_metadata_.Clear();
6259}
6260
6261bool BlockOpResponseProto::MergePartialFromCodedStream(
6262 ::google::protobuf::io::CodedInputStream* input) {
6263#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
6264 ::google::protobuf::uint32 tag;
6265 // @@protoc_insertion_point(parse_start:Hdfs.Internal.BlockOpResponseProto)
6266 for (;;) {
6267 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
6268 tag = p.first;
6269 if (!p.second) goto handle_unusual;
6270 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6271 // required .Hdfs.Internal.Status status = 1;
6272 case 1: {
6273 if (static_cast< ::google::protobuf::uint8>(tag) ==
6274 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
6275 int value;
6276 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
6277 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
6278 input, &value)));
6279 if (::Hdfs::Internal::Status_IsValid(value)) {
6280 set_status(static_cast< ::Hdfs::Internal::Status >(value));
6281 } else {
6282 mutable_unknown_fields()->AddVarint(
6283 1, static_cast< ::google::protobuf::uint64>(value));
6284 }
6285 } else {
6286 goto handle_unusual;
6287 }
6288 break;
6289 }
6290
6291 // optional string firstBadLink = 2;
6292 case 2: {
6293 if (static_cast< ::google::protobuf::uint8>(tag) ==
6294 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
6295 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
6296 input, this->mutable_firstbadlink()));
6297 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
6298 this->firstbadlink().data(), static_cast<int>(this->firstbadlink().length()),
6299 ::google::protobuf::internal::WireFormat::PARSE,
6300 "Hdfs.Internal.BlockOpResponseProto.firstBadLink");
6301 } else {
6302 goto handle_unusual;
6303 }
6304 break;
6305 }
6306
6307 // optional .Hdfs.Internal.OpBlockChecksumResponseProto checksumResponse = 3;
6308 case 3: {
6309 if (static_cast< ::google::protobuf::uint8>(tag) ==
6310 static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
6311 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
6312 input, mutable_checksumresponse()));
6313 } else {
6314 goto handle_unusual;
6315 }
6316 break;
6317 }
6318
6319 // optional .Hdfs.Internal.ReadOpChecksumInfoProto readOpChecksumInfo = 4;
6320 case 4: {
6321 if (static_cast< ::google::protobuf::uint8>(tag) ==
6322 static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
6323 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
6324 input, mutable_readopchecksuminfo()));
6325 } else {
6326 goto handle_unusual;
6327 }
6328 break;
6329 }
6330
6331 // optional string message = 5;
6332 case 5: {
6333 if (static_cast< ::google::protobuf::uint8>(tag) ==
6334 static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
6335 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
6336 input, this->mutable_message()));
6337 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
6338 this->message().data(), static_cast<int>(this->message().length()),
6339 ::google::protobuf::internal::WireFormat::PARSE,
6340 "Hdfs.Internal.BlockOpResponseProto.message");
6341 } else {
6342 goto handle_unusual;
6343 }
6344 break;
6345 }
6346
6347 // optional uint32 shortCircuitAccessVersion = 6;
6348 case 6: {
6349 if (static_cast< ::google::protobuf::uint8>(tag) ==
6350 static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
6351 set_has_shortcircuitaccessversion();
6352 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
6353 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
6354 input, &shortcircuitaccessversion_)));
6355 } else {
6356 goto handle_unusual;
6357 }
6358 break;
6359 }
6360
6361 default: {
6362 handle_unusual:
6363 if (tag == 0) {
6364 goto success;
6365 }
6366 DO_(::google::protobuf::internal::WireFormat::SkipField(
6367 input, tag, _internal_metadata_.mutable_unknown_fields()));
6368 break;
6369 }
6370 }
6371 }
6372success:
6373 // @@protoc_insertion_point(parse_success:Hdfs.Internal.BlockOpResponseProto)
6374 return true;
6375failure:
6376 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.BlockOpResponseProto)
6377 return false;
6378#undef DO_
6379}
6380
6381void BlockOpResponseProto::SerializeWithCachedSizes(
6382 ::google::protobuf::io::CodedOutputStream* output) const {
6383 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.BlockOpResponseProto)
6384 ::google::protobuf::uint32 cached_has_bits = 0;
6385 (void) cached_has_bits;
6386
6387 cached_has_bits = _has_bits_[0];
6388 // required .Hdfs.Internal.Status status = 1;
6389 if (cached_has_bits & 0x00000010u) {
6390 ::google::protobuf::internal::WireFormatLite::WriteEnum(
6391 1, this->status(), output);
6392 }
6393
6394 // optional string firstBadLink = 2;
6395 if (cached_has_bits & 0x00000001u) {
6396 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
6397 this->firstbadlink().data(), static_cast<int>(this->firstbadlink().length()),
6398 ::google::protobuf::internal::WireFormat::SERIALIZE,
6399 "Hdfs.Internal.BlockOpResponseProto.firstBadLink");
6400 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
6401 2, this->firstbadlink(), output);
6402 }
6403
6404 // optional .Hdfs.Internal.OpBlockChecksumResponseProto checksumResponse = 3;
6405 if (cached_has_bits & 0x00000004u) {
6406 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
6407 3, this->_internal_checksumresponse(), output);
6408 }
6409
6410 // optional .Hdfs.Internal.ReadOpChecksumInfoProto readOpChecksumInfo = 4;
6411 if (cached_has_bits & 0x00000008u) {
6412 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
6413 4, this->_internal_readopchecksuminfo(), output);
6414 }
6415
6416 // optional string message = 5;
6417 if (cached_has_bits & 0x00000002u) {
6418 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
6419 this->message().data(), static_cast<int>(this->message().length()),
6420 ::google::protobuf::internal::WireFormat::SERIALIZE,
6421 "Hdfs.Internal.BlockOpResponseProto.message");
6422 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
6423 5, this->message(), output);
6424 }
6425
6426 // optional uint32 shortCircuitAccessVersion = 6;
6427 if (cached_has_bits & 0x00000020u) {
6428 ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->shortcircuitaccessversion(), output);
6429 }
6430
6431 if (_internal_metadata_.have_unknown_fields()) {
6432 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
6433 _internal_metadata_.unknown_fields(), output);
6434 }
6435 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.BlockOpResponseProto)
6436}
6437
6438::google::protobuf::uint8* BlockOpResponseProto::InternalSerializeWithCachedSizesToArray(
6439 bool deterministic, ::google::protobuf::uint8* target) const {
6440 (void)deterministic; // Unused
6441 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.BlockOpResponseProto)
6442 ::google::protobuf::uint32 cached_has_bits = 0;
6443 (void) cached_has_bits;
6444
6445 cached_has_bits = _has_bits_[0];
6446 // required .Hdfs.Internal.Status status = 1;
6447 if (cached_has_bits & 0x00000010u) {
6448 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
6449 1, this->status(), target);
6450 }
6451
6452 // optional string firstBadLink = 2;
6453 if (cached_has_bits & 0x00000001u) {
6454 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
6455 this->firstbadlink().data(), static_cast<int>(this->firstbadlink().length()),
6456 ::google::protobuf::internal::WireFormat::SERIALIZE,
6457 "Hdfs.Internal.BlockOpResponseProto.firstBadLink");
6458 target =
6459 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6460 2, this->firstbadlink(), target);
6461 }
6462
6463 // optional .Hdfs.Internal.OpBlockChecksumResponseProto checksumResponse = 3;
6464 if (cached_has_bits & 0x00000004u) {
6465 target = ::google::protobuf::internal::WireFormatLite::
6466 InternalWriteMessageToArray(
6467 3, this->_internal_checksumresponse(), deterministic, target);
6468 }
6469
6470 // optional .Hdfs.Internal.ReadOpChecksumInfoProto readOpChecksumInfo = 4;
6471 if (cached_has_bits & 0x00000008u) {
6472 target = ::google::protobuf::internal::WireFormatLite::
6473 InternalWriteMessageToArray(
6474 4, this->_internal_readopchecksuminfo(), deterministic, target);
6475 }
6476
6477 // optional string message = 5;
6478 if (cached_has_bits & 0x00000002u) {
6479 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
6480 this->message().data(), static_cast<int>(this->message().length()),
6481 ::google::protobuf::internal::WireFormat::SERIALIZE,
6482 "Hdfs.Internal.BlockOpResponseProto.message");
6483 target =
6484 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6485 5, this->message(), target);
6486 }
6487
6488 // optional uint32 shortCircuitAccessVersion = 6;
6489 if (cached_has_bits & 0x00000020u) {
6490 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->shortcircuitaccessversion(), target);
6491 }
6492
6493 if (_internal_metadata_.have_unknown_fields()) {
6494 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6495 _internal_metadata_.unknown_fields(), target);
6496 }
6497 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.BlockOpResponseProto)
6498 return target;
6499}
6500
6501size_t BlockOpResponseProto::ByteSizeLong() const {
6502// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.BlockOpResponseProto)
6503 size_t total_size = 0;
6504
6505 if (_internal_metadata_.have_unknown_fields()) {
6506 total_size +=
6507 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
6508 _internal_metadata_.unknown_fields());
6509 }
6510 // required .Hdfs.Internal.Status status = 1;
6511 if (has_status()) {
6512 total_size += 1 +
6513 ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
6514 }
6515 if (_has_bits_[0 / 32] & 15u) {
6516 // optional string firstBadLink = 2;
6517 if (has_firstbadlink()) {
6518 total_size += 1 +
6519 ::google::protobuf::internal::WireFormatLite::StringSize(
6520 this->firstbadlink());
6521 }
6522
6523 // optional string message = 5;
6524 if (has_message()) {
6525 total_size += 1 +
6526 ::google::protobuf::internal::WireFormatLite::StringSize(
6527 this->message());
6528 }
6529
6530 // optional .Hdfs.Internal.OpBlockChecksumResponseProto checksumResponse = 3;
6531 if (has_checksumresponse()) {
6532 total_size += 1 +
6533 ::google::protobuf::internal::WireFormatLite::MessageSize(
6534 *checksumresponse_);
6535 }
6536
6537 // optional .Hdfs.Internal.ReadOpChecksumInfoProto readOpChecksumInfo = 4;
6538 if (has_readopchecksuminfo()) {
6539 total_size += 1 +
6540 ::google::protobuf::internal::WireFormatLite::MessageSize(
6541 *readopchecksuminfo_);
6542 }
6543
6544 }
6545 // optional uint32 shortCircuitAccessVersion = 6;
6546 if (has_shortcircuitaccessversion()) {
6547 total_size += 1 +
6548 ::google::protobuf::internal::WireFormatLite::UInt32Size(
6549 this->shortcircuitaccessversion());
6550 }
6551
6552 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
6553 SetCachedSize(cached_size);
6554 return total_size;
6555}
6556
6557void BlockOpResponseProto::MergeFrom(const ::google::protobuf::Message& from) {
6558// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.BlockOpResponseProto)
6559 GOOGLE_DCHECK_NE(&from, this);
6560 const BlockOpResponseProto* source =
6561 ::google::protobuf::internal::DynamicCastToGenerated<const BlockOpResponseProto>(
6562 &from);
6563 if (source == NULL) {
6564 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.BlockOpResponseProto)
6565 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6566 } else {
6567 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.BlockOpResponseProto)
6568 MergeFrom(*source);
6569 }
6570}
6571
6572void BlockOpResponseProto::MergeFrom(const BlockOpResponseProto& from) {
6573// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.BlockOpResponseProto)
6574 GOOGLE_DCHECK_NE(&from, this);
6575 _internal_metadata_.MergeFrom(from._internal_metadata_);
6576 ::google::protobuf::uint32 cached_has_bits = 0;
6577 (void) cached_has_bits;
6578
6579 cached_has_bits = from._has_bits_[0];
6580 if (cached_has_bits & 63u) {
6581 if (cached_has_bits & 0x00000001u) {
6582 set_has_firstbadlink();
6583 firstbadlink_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.firstbadlink_);
6584 }
6585 if (cached_has_bits & 0x00000002u) {
6586 set_has_message();
6587 message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
6588 }
6589 if (cached_has_bits & 0x00000004u) {
6590 mutable_checksumresponse()->::Hdfs::Internal::OpBlockChecksumResponseProto::MergeFrom(from.checksumresponse());
6591 }
6592 if (cached_has_bits & 0x00000008u) {
6593 mutable_readopchecksuminfo()->::Hdfs::Internal::ReadOpChecksumInfoProto::MergeFrom(from.readopchecksuminfo());
6594 }
6595 if (cached_has_bits & 0x00000010u) {
6596 status_ = from.status_;
6597 }
6598 if (cached_has_bits & 0x00000020u) {
6599 shortcircuitaccessversion_ = from.shortcircuitaccessversion_;
6600 }
6601 _has_bits_[0] |= cached_has_bits;
6602 }
6603}
6604
6605void BlockOpResponseProto::CopyFrom(const ::google::protobuf::Message& from) {
6606// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.BlockOpResponseProto)
6607 if (&from == this) return;
6608 Clear();
6609 MergeFrom(from);
6610}
6611
6612void BlockOpResponseProto::CopyFrom(const BlockOpResponseProto& from) {
6613// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.BlockOpResponseProto)
6614 if (&from == this) return;
6615 Clear();
6616 MergeFrom(from);
6617}
6618
6619bool BlockOpResponseProto::IsInitialized() const {
6620 if ((_has_bits_[0] & 0x00000010) != 0x00000010) return false;
6621 if (has_checksumresponse()) {
6622 if (!this->checksumresponse_->IsInitialized()) return false;
6623 }
6624 if (has_readopchecksuminfo()) {
6625 if (!this->readopchecksuminfo_->IsInitialized()) return false;
6626 }
6627 return true;
6628}
6629
6630void BlockOpResponseProto::Swap(BlockOpResponseProto* other) {
6631 if (other == this) return;
6632 InternalSwap(other);
6633}
6634void BlockOpResponseProto::InternalSwap(BlockOpResponseProto* other) {
6635 using std::swap;
6636 firstbadlink_.Swap(&other->firstbadlink_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
6637 GetArenaNoVirtual());
6638 message_.Swap(&other->message_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
6639 GetArenaNoVirtual());
6640 swap(checksumresponse_, other->checksumresponse_);
6641 swap(readopchecksuminfo_, other->readopchecksuminfo_);
6642 swap(status_, other->status_);
6643 swap(shortcircuitaccessversion_, other->shortcircuitaccessversion_);
6644 swap(_has_bits_[0], other->_has_bits_[0]);
6645 _internal_metadata_.Swap(&other->_internal_metadata_);
6646}
6647
6648::google::protobuf::Metadata BlockOpResponseProto::GetMetadata() const {
6649 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
6650 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
6651}
6652
6653
6654// ===================================================================
6655
6656void ClientReadStatusProto::InitAsDefaultInstance() {
6657}
6658#if !defined(_MSC_VER) || _MSC_VER >= 1900
6659const int ClientReadStatusProto::kStatusFieldNumber;
6660#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
6661
6662ClientReadStatusProto::ClientReadStatusProto()
6663 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
6664 ::google::protobuf::internal::InitSCC(
6665 &protobuf_datatransfer_2eproto::scc_info_ClientReadStatusProto.base);
6666 SharedCtor();
6667 // @@protoc_insertion_point(constructor:Hdfs.Internal.ClientReadStatusProto)
6668}
6669ClientReadStatusProto::ClientReadStatusProto(const ClientReadStatusProto& from)
6670 : ::google::protobuf::Message(),
6671 _internal_metadata_(NULL),
6672 _has_bits_(from._has_bits_) {
6673 _internal_metadata_.MergeFrom(from._internal_metadata_);
6674 status_ = from.status_;
6675 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.ClientReadStatusProto)
6676}
6677
6678void ClientReadStatusProto::SharedCtor() {
6679 status_ = 0;
6680}
6681
6682ClientReadStatusProto::~ClientReadStatusProto() {
6683 // @@protoc_insertion_point(destructor:Hdfs.Internal.ClientReadStatusProto)
6684 SharedDtor();
6685}
6686
6687void ClientReadStatusProto::SharedDtor() {
6688}
6689
6690void ClientReadStatusProto::SetCachedSize(int size) const {
6691 _cached_size_.Set(size);
6692}
6693const ::google::protobuf::Descriptor* ClientReadStatusProto::descriptor() {
6694 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
6695 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
6696}
6697
6698const ClientReadStatusProto& ClientReadStatusProto::default_instance() {
6699 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_ClientReadStatusProto.base);
6700 return *internal_default_instance();
6701}
6702
6703
6704void ClientReadStatusProto::Clear() {
6705// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.ClientReadStatusProto)
6706 ::google::protobuf::uint32 cached_has_bits = 0;
6707 // Prevent compiler warnings about cached_has_bits being unused
6708 (void) cached_has_bits;
6709
6710 status_ = 0;
6711 _has_bits_.Clear();
6712 _internal_metadata_.Clear();
6713}
6714
6715bool ClientReadStatusProto::MergePartialFromCodedStream(
6716 ::google::protobuf::io::CodedInputStream* input) {
6717#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
6718 ::google::protobuf::uint32 tag;
6719 // @@protoc_insertion_point(parse_start:Hdfs.Internal.ClientReadStatusProto)
6720 for (;;) {
6721 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
6722 tag = p.first;
6723 if (!p.second) goto handle_unusual;
6724 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6725 // required .Hdfs.Internal.Status status = 1;
6726 case 1: {
6727 if (static_cast< ::google::protobuf::uint8>(tag) ==
6728 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
6729 int value;
6730 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
6731 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
6732 input, &value)));
6733 if (::Hdfs::Internal::Status_IsValid(value)) {
6734 set_status(static_cast< ::Hdfs::Internal::Status >(value));
6735 } else {
6736 mutable_unknown_fields()->AddVarint(
6737 1, static_cast< ::google::protobuf::uint64>(value));
6738 }
6739 } else {
6740 goto handle_unusual;
6741 }
6742 break;
6743 }
6744
6745 default: {
6746 handle_unusual:
6747 if (tag == 0) {
6748 goto success;
6749 }
6750 DO_(::google::protobuf::internal::WireFormat::SkipField(
6751 input, tag, _internal_metadata_.mutable_unknown_fields()));
6752 break;
6753 }
6754 }
6755 }
6756success:
6757 // @@protoc_insertion_point(parse_success:Hdfs.Internal.ClientReadStatusProto)
6758 return true;
6759failure:
6760 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.ClientReadStatusProto)
6761 return false;
6762#undef DO_
6763}
6764
6765void ClientReadStatusProto::SerializeWithCachedSizes(
6766 ::google::protobuf::io::CodedOutputStream* output) const {
6767 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.ClientReadStatusProto)
6768 ::google::protobuf::uint32 cached_has_bits = 0;
6769 (void) cached_has_bits;
6770
6771 cached_has_bits = _has_bits_[0];
6772 // required .Hdfs.Internal.Status status = 1;
6773 if (cached_has_bits & 0x00000001u) {
6774 ::google::protobuf::internal::WireFormatLite::WriteEnum(
6775 1, this->status(), output);
6776 }
6777
6778 if (_internal_metadata_.have_unknown_fields()) {
6779 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
6780 _internal_metadata_.unknown_fields(), output);
6781 }
6782 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.ClientReadStatusProto)
6783}
6784
6785::google::protobuf::uint8* ClientReadStatusProto::InternalSerializeWithCachedSizesToArray(
6786 bool deterministic, ::google::protobuf::uint8* target) const {
6787 (void)deterministic; // Unused
6788 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.ClientReadStatusProto)
6789 ::google::protobuf::uint32 cached_has_bits = 0;
6790 (void) cached_has_bits;
6791
6792 cached_has_bits = _has_bits_[0];
6793 // required .Hdfs.Internal.Status status = 1;
6794 if (cached_has_bits & 0x00000001u) {
6795 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
6796 1, this->status(), target);
6797 }
6798
6799 if (_internal_metadata_.have_unknown_fields()) {
6800 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6801 _internal_metadata_.unknown_fields(), target);
6802 }
6803 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.ClientReadStatusProto)
6804 return target;
6805}
6806
6807size_t ClientReadStatusProto::ByteSizeLong() const {
6808// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.ClientReadStatusProto)
6809 size_t total_size = 0;
6810
6811 if (_internal_metadata_.have_unknown_fields()) {
6812 total_size +=
6813 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
6814 _internal_metadata_.unknown_fields());
6815 }
6816 // required .Hdfs.Internal.Status status = 1;
6817 if (has_status()) {
6818 total_size += 1 +
6819 ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
6820 }
6821 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
6822 SetCachedSize(cached_size);
6823 return total_size;
6824}
6825
6826void ClientReadStatusProto::MergeFrom(const ::google::protobuf::Message& from) {
6827// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.ClientReadStatusProto)
6828 GOOGLE_DCHECK_NE(&from, this);
6829 const ClientReadStatusProto* source =
6830 ::google::protobuf::internal::DynamicCastToGenerated<const ClientReadStatusProto>(
6831 &from);
6832 if (source == NULL) {
6833 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.ClientReadStatusProto)
6834 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6835 } else {
6836 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.ClientReadStatusProto)
6837 MergeFrom(*source);
6838 }
6839}
6840
6841void ClientReadStatusProto::MergeFrom(const ClientReadStatusProto& from) {
6842// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.ClientReadStatusProto)
6843 GOOGLE_DCHECK_NE(&from, this);
6844 _internal_metadata_.MergeFrom(from._internal_metadata_);
6845 ::google::protobuf::uint32 cached_has_bits = 0;
6846 (void) cached_has_bits;
6847
6848 if (from.has_status()) {
6849 set_status(from.status());
6850 }
6851}
6852
6853void ClientReadStatusProto::CopyFrom(const ::google::protobuf::Message& from) {
6854// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.ClientReadStatusProto)
6855 if (&from == this) return;
6856 Clear();
6857 MergeFrom(from);
6858}
6859
6860void ClientReadStatusProto::CopyFrom(const ClientReadStatusProto& from) {
6861// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.ClientReadStatusProto)
6862 if (&from == this) return;
6863 Clear();
6864 MergeFrom(from);
6865}
6866
6867bool ClientReadStatusProto::IsInitialized() const {
6868 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
6869 return true;
6870}
6871
6872void ClientReadStatusProto::Swap(ClientReadStatusProto* other) {
6873 if (other == this) return;
6874 InternalSwap(other);
6875}
6876void ClientReadStatusProto::InternalSwap(ClientReadStatusProto* other) {
6877 using std::swap;
6878 swap(status_, other->status_);
6879 swap(_has_bits_[0], other->_has_bits_[0]);
6880 _internal_metadata_.Swap(&other->_internal_metadata_);
6881}
6882
6883::google::protobuf::Metadata ClientReadStatusProto::GetMetadata() const {
6884 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
6885 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
6886}
6887
6888
6889// ===================================================================
6890
6891void DNTransferAckProto::InitAsDefaultInstance() {
6892}
6893#if !defined(_MSC_VER) || _MSC_VER >= 1900
6894const int DNTransferAckProto::kStatusFieldNumber;
6895#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
6896
6897DNTransferAckProto::DNTransferAckProto()
6898 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
6899 ::google::protobuf::internal::InitSCC(
6900 &protobuf_datatransfer_2eproto::scc_info_DNTransferAckProto.base);
6901 SharedCtor();
6902 // @@protoc_insertion_point(constructor:Hdfs.Internal.DNTransferAckProto)
6903}
6904DNTransferAckProto::DNTransferAckProto(const DNTransferAckProto& from)
6905 : ::google::protobuf::Message(),
6906 _internal_metadata_(NULL),
6907 _has_bits_(from._has_bits_) {
6908 _internal_metadata_.MergeFrom(from._internal_metadata_);
6909 status_ = from.status_;
6910 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.DNTransferAckProto)
6911}
6912
6913void DNTransferAckProto::SharedCtor() {
6914 status_ = 0;
6915}
6916
6917DNTransferAckProto::~DNTransferAckProto() {
6918 // @@protoc_insertion_point(destructor:Hdfs.Internal.DNTransferAckProto)
6919 SharedDtor();
6920}
6921
6922void DNTransferAckProto::SharedDtor() {
6923}
6924
6925void DNTransferAckProto::SetCachedSize(int size) const {
6926 _cached_size_.Set(size);
6927}
6928const ::google::protobuf::Descriptor* DNTransferAckProto::descriptor() {
6929 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
6930 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
6931}
6932
6933const DNTransferAckProto& DNTransferAckProto::default_instance() {
6934 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_DNTransferAckProto.base);
6935 return *internal_default_instance();
6936}
6937
6938
6939void DNTransferAckProto::Clear() {
6940// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.DNTransferAckProto)
6941 ::google::protobuf::uint32 cached_has_bits = 0;
6942 // Prevent compiler warnings about cached_has_bits being unused
6943 (void) cached_has_bits;
6944
6945 status_ = 0;
6946 _has_bits_.Clear();
6947 _internal_metadata_.Clear();
6948}
6949
6950bool DNTransferAckProto::MergePartialFromCodedStream(
6951 ::google::protobuf::io::CodedInputStream* input) {
6952#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
6953 ::google::protobuf::uint32 tag;
6954 // @@protoc_insertion_point(parse_start:Hdfs.Internal.DNTransferAckProto)
6955 for (;;) {
6956 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
6957 tag = p.first;
6958 if (!p.second) goto handle_unusual;
6959 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6960 // required .Hdfs.Internal.Status status = 1;
6961 case 1: {
6962 if (static_cast< ::google::protobuf::uint8>(tag) ==
6963 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
6964 int value;
6965 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
6966 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
6967 input, &value)));
6968 if (::Hdfs::Internal::Status_IsValid(value)) {
6969 set_status(static_cast< ::Hdfs::Internal::Status >(value));
6970 } else {
6971 mutable_unknown_fields()->AddVarint(
6972 1, static_cast< ::google::protobuf::uint64>(value));
6973 }
6974 } else {
6975 goto handle_unusual;
6976 }
6977 break;
6978 }
6979
6980 default: {
6981 handle_unusual:
6982 if (tag == 0) {
6983 goto success;
6984 }
6985 DO_(::google::protobuf::internal::WireFormat::SkipField(
6986 input, tag, _internal_metadata_.mutable_unknown_fields()));
6987 break;
6988 }
6989 }
6990 }
6991success:
6992 // @@protoc_insertion_point(parse_success:Hdfs.Internal.DNTransferAckProto)
6993 return true;
6994failure:
6995 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.DNTransferAckProto)
6996 return false;
6997#undef DO_
6998}
6999
7000void DNTransferAckProto::SerializeWithCachedSizes(
7001 ::google::protobuf::io::CodedOutputStream* output) const {
7002 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.DNTransferAckProto)
7003 ::google::protobuf::uint32 cached_has_bits = 0;
7004 (void) cached_has_bits;
7005
7006 cached_has_bits = _has_bits_[0];
7007 // required .Hdfs.Internal.Status status = 1;
7008 if (cached_has_bits & 0x00000001u) {
7009 ::google::protobuf::internal::WireFormatLite::WriteEnum(
7010 1, this->status(), output);
7011 }
7012
7013 if (_internal_metadata_.have_unknown_fields()) {
7014 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
7015 _internal_metadata_.unknown_fields(), output);
7016 }
7017 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.DNTransferAckProto)
7018}
7019
7020::google::protobuf::uint8* DNTransferAckProto::InternalSerializeWithCachedSizesToArray(
7021 bool deterministic, ::google::protobuf::uint8* target) const {
7022 (void)deterministic; // Unused
7023 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.DNTransferAckProto)
7024 ::google::protobuf::uint32 cached_has_bits = 0;
7025 (void) cached_has_bits;
7026
7027 cached_has_bits = _has_bits_[0];
7028 // required .Hdfs.Internal.Status status = 1;
7029 if (cached_has_bits & 0x00000001u) {
7030 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
7031 1, this->status(), target);
7032 }
7033
7034 if (_internal_metadata_.have_unknown_fields()) {
7035 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
7036 _internal_metadata_.unknown_fields(), target);
7037 }
7038 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.DNTransferAckProto)
7039 return target;
7040}
7041
7042size_t DNTransferAckProto::ByteSizeLong() const {
7043// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.DNTransferAckProto)
7044 size_t total_size = 0;
7045
7046 if (_internal_metadata_.have_unknown_fields()) {
7047 total_size +=
7048 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
7049 _internal_metadata_.unknown_fields());
7050 }
7051 // required .Hdfs.Internal.Status status = 1;
7052 if (has_status()) {
7053 total_size += 1 +
7054 ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
7055 }
7056 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
7057 SetCachedSize(cached_size);
7058 return total_size;
7059}
7060
7061void DNTransferAckProto::MergeFrom(const ::google::protobuf::Message& from) {
7062// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.DNTransferAckProto)
7063 GOOGLE_DCHECK_NE(&from, this);
7064 const DNTransferAckProto* source =
7065 ::google::protobuf::internal::DynamicCastToGenerated<const DNTransferAckProto>(
7066 &from);
7067 if (source == NULL) {
7068 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.DNTransferAckProto)
7069 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
7070 } else {
7071 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.DNTransferAckProto)
7072 MergeFrom(*source);
7073 }
7074}
7075
7076void DNTransferAckProto::MergeFrom(const DNTransferAckProto& from) {
7077// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.DNTransferAckProto)
7078 GOOGLE_DCHECK_NE(&from, this);
7079 _internal_metadata_.MergeFrom(from._internal_metadata_);
7080 ::google::protobuf::uint32 cached_has_bits = 0;
7081 (void) cached_has_bits;
7082
7083 if (from.has_status()) {
7084 set_status(from.status());
7085 }
7086}
7087
7088void DNTransferAckProto::CopyFrom(const ::google::protobuf::Message& from) {
7089// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.DNTransferAckProto)
7090 if (&from == this) return;
7091 Clear();
7092 MergeFrom(from);
7093}
7094
7095void DNTransferAckProto::CopyFrom(const DNTransferAckProto& from) {
7096// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.DNTransferAckProto)
7097 if (&from == this) return;
7098 Clear();
7099 MergeFrom(from);
7100}
7101
7102bool DNTransferAckProto::IsInitialized() const {
7103 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
7104 return true;
7105}
7106
7107void DNTransferAckProto::Swap(DNTransferAckProto* other) {
7108 if (other == this) return;
7109 InternalSwap(other);
7110}
7111void DNTransferAckProto::InternalSwap(DNTransferAckProto* other) {
7112 using std::swap;
7113 swap(status_, other->status_);
7114 swap(_has_bits_[0], other->_has_bits_[0]);
7115 _internal_metadata_.Swap(&other->_internal_metadata_);
7116}
7117
7118::google::protobuf::Metadata DNTransferAckProto::GetMetadata() const {
7119 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
7120 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
7121}
7122
7123
7124// ===================================================================
7125
7126void OpBlockChecksumResponseProto::InitAsDefaultInstance() {
7127}
7128#if !defined(_MSC_VER) || _MSC_VER >= 1900
7129const int OpBlockChecksumResponseProto::kBytesPerCrcFieldNumber;
7130const int OpBlockChecksumResponseProto::kCrcPerBlockFieldNumber;
7131const int OpBlockChecksumResponseProto::kMd5FieldNumber;
7132const int OpBlockChecksumResponseProto::kCrcTypeFieldNumber;
7133#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
7134
7135OpBlockChecksumResponseProto::OpBlockChecksumResponseProto()
7136 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
7137 ::google::protobuf::internal::InitSCC(
7138 &protobuf_datatransfer_2eproto::scc_info_OpBlockChecksumResponseProto.base);
7139 SharedCtor();
7140 // @@protoc_insertion_point(constructor:Hdfs.Internal.OpBlockChecksumResponseProto)
7141}
7142OpBlockChecksumResponseProto::OpBlockChecksumResponseProto(const OpBlockChecksumResponseProto& from)
7143 : ::google::protobuf::Message(),
7144 _internal_metadata_(NULL),
7145 _has_bits_(from._has_bits_) {
7146 _internal_metadata_.MergeFrom(from._internal_metadata_);
7147 md5_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7148 if (from.has_md5()) {
7149 md5_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.md5_);
7150 }
7151 ::memcpy(&crcperblock_, &from.crcperblock_,
7152 static_cast<size_t>(reinterpret_cast<char*>(&crctype_) -
7153 reinterpret_cast<char*>(&crcperblock_)) + sizeof(crctype_));
7154 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.OpBlockChecksumResponseProto)
7155}
7156
7157void OpBlockChecksumResponseProto::SharedCtor() {
7158 md5_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7159 ::memset(&crcperblock_, 0, static_cast<size_t>(
7160 reinterpret_cast<char*>(&crctype_) -
7161 reinterpret_cast<char*>(&crcperblock_)) + sizeof(crctype_));
7162}
7163
7164OpBlockChecksumResponseProto::~OpBlockChecksumResponseProto() {
7165 // @@protoc_insertion_point(destructor:Hdfs.Internal.OpBlockChecksumResponseProto)
7166 SharedDtor();
7167}
7168
7169void OpBlockChecksumResponseProto::SharedDtor() {
7170 md5_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7171}
7172
7173void OpBlockChecksumResponseProto::SetCachedSize(int size) const {
7174 _cached_size_.Set(size);
7175}
7176const ::google::protobuf::Descriptor* OpBlockChecksumResponseProto::descriptor() {
7177 ::protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
7178 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
7179}
7180
7181const OpBlockChecksumResponseProto& OpBlockChecksumResponseProto::default_instance() {
7182 ::google::protobuf::internal::InitSCC(&protobuf_datatransfer_2eproto::scc_info_OpBlockChecksumResponseProto.base);
7183 return *internal_default_instance();
7184}
7185
7186
7187void OpBlockChecksumResponseProto::Clear() {
7188// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7189 ::google::protobuf::uint32 cached_has_bits = 0;
7190 // Prevent compiler warnings about cached_has_bits being unused
7191 (void) cached_has_bits;
7192
7193 cached_has_bits = _has_bits_[0];
7194 if (cached_has_bits & 0x00000001u) {
7195 md5_.ClearNonDefaultToEmptyNoArena();
7196 }
7197 if (cached_has_bits & 14u) {
7198 ::memset(&crcperblock_, 0, static_cast<size_t>(
7199 reinterpret_cast<char*>(&crctype_) -
7200 reinterpret_cast<char*>(&crcperblock_)) + sizeof(crctype_));
7201 }
7202 _has_bits_.Clear();
7203 _internal_metadata_.Clear();
7204}
7205
7206bool OpBlockChecksumResponseProto::MergePartialFromCodedStream(
7207 ::google::protobuf::io::CodedInputStream* input) {
7208#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
7209 ::google::protobuf::uint32 tag;
7210 // @@protoc_insertion_point(parse_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7211 for (;;) {
7212 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
7213 tag = p.first;
7214 if (!p.second) goto handle_unusual;
7215 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
7216 // required uint32 bytesPerCrc = 1;
7217 case 1: {
7218 if (static_cast< ::google::protobuf::uint8>(tag) ==
7219 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
7220 set_has_bytespercrc();
7221 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
7222 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
7223 input, &bytespercrc_)));
7224 } else {
7225 goto handle_unusual;
7226 }
7227 break;
7228 }
7229
7230 // required uint64 crcPerBlock = 2;
7231 case 2: {
7232 if (static_cast< ::google::protobuf::uint8>(tag) ==
7233 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
7234 set_has_crcperblock();
7235 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
7236 ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
7237 input, &crcperblock_)));
7238 } else {
7239 goto handle_unusual;
7240 }
7241 break;
7242 }
7243
7244 // required bytes md5 = 3;
7245 case 3: {
7246 if (static_cast< ::google::protobuf::uint8>(tag) ==
7247 static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
7248 DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
7249 input, this->mutable_md5()));
7250 } else {
7251 goto handle_unusual;
7252 }
7253 break;
7254 }
7255
7256 // optional .Hdfs.Internal.ChecksumTypeProto crcType = 4;
7257 case 4: {
7258 if (static_cast< ::google::protobuf::uint8>(tag) ==
7259 static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
7260 int value;
7261 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
7262 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
7263 input, &value)));
7264 if (::Hdfs::Internal::ChecksumTypeProto_IsValid(value)) {
7265 set_crctype(static_cast< ::Hdfs::Internal::ChecksumTypeProto >(value));
7266 } else {
7267 mutable_unknown_fields()->AddVarint(
7268 4, static_cast< ::google::protobuf::uint64>(value));
7269 }
7270 } else {
7271 goto handle_unusual;
7272 }
7273 break;
7274 }
7275
7276 default: {
7277 handle_unusual:
7278 if (tag == 0) {
7279 goto success;
7280 }
7281 DO_(::google::protobuf::internal::WireFormat::SkipField(
7282 input, tag, _internal_metadata_.mutable_unknown_fields()));
7283 break;
7284 }
7285 }
7286 }
7287success:
7288 // @@protoc_insertion_point(parse_success:Hdfs.Internal.OpBlockChecksumResponseProto)
7289 return true;
7290failure:
7291 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.OpBlockChecksumResponseProto)
7292 return false;
7293#undef DO_
7294}
7295
7296void OpBlockChecksumResponseProto::SerializeWithCachedSizes(
7297 ::google::protobuf::io::CodedOutputStream* output) const {
7298 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7299 ::google::protobuf::uint32 cached_has_bits = 0;
7300 (void) cached_has_bits;
7301
7302 cached_has_bits = _has_bits_[0];
7303 // required uint32 bytesPerCrc = 1;
7304 if (cached_has_bits & 0x00000004u) {
7305 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->bytespercrc(), output);
7306 }
7307
7308 // required uint64 crcPerBlock = 2;
7309 if (cached_has_bits & 0x00000002u) {
7310 ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->crcperblock(), output);
7311 }
7312
7313 // required bytes md5 = 3;
7314 if (cached_has_bits & 0x00000001u) {
7315 ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
7316 3, this->md5(), output);
7317 }
7318
7319 // optional .Hdfs.Internal.ChecksumTypeProto crcType = 4;
7320 if (cached_has_bits & 0x00000008u) {
7321 ::google::protobuf::internal::WireFormatLite::WriteEnum(
7322 4, this->crctype(), output);
7323 }
7324
7325 if (_internal_metadata_.have_unknown_fields()) {
7326 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
7327 _internal_metadata_.unknown_fields(), output);
7328 }
7329 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.OpBlockChecksumResponseProto)
7330}
7331
7332::google::protobuf::uint8* OpBlockChecksumResponseProto::InternalSerializeWithCachedSizesToArray(
7333 bool deterministic, ::google::protobuf::uint8* target) const {
7334 (void)deterministic; // Unused
7335 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7336 ::google::protobuf::uint32 cached_has_bits = 0;
7337 (void) cached_has_bits;
7338
7339 cached_has_bits = _has_bits_[0];
7340 // required uint32 bytesPerCrc = 1;
7341 if (cached_has_bits & 0x00000004u) {
7342 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->bytespercrc(), target);
7343 }
7344
7345 // required uint64 crcPerBlock = 2;
7346 if (cached_has_bits & 0x00000002u) {
7347 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->crcperblock(), target);
7348 }
7349
7350 // required bytes md5 = 3;
7351 if (cached_has_bits & 0x00000001u) {
7352 target =
7353 ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
7354 3, this->md5(), target);
7355 }
7356
7357 // optional .Hdfs.Internal.ChecksumTypeProto crcType = 4;
7358 if (cached_has_bits & 0x00000008u) {
7359 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
7360 4, this->crctype(), target);
7361 }
7362
7363 if (_internal_metadata_.have_unknown_fields()) {
7364 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
7365 _internal_metadata_.unknown_fields(), target);
7366 }
7367 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.OpBlockChecksumResponseProto)
7368 return target;
7369}
7370
7371size_t OpBlockChecksumResponseProto::RequiredFieldsByteSizeFallback() const {
7372// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7373 size_t total_size = 0;
7374
7375 if (has_md5()) {
7376 // required bytes md5 = 3;
7377 total_size += 1 +
7378 ::google::protobuf::internal::WireFormatLite::BytesSize(
7379 this->md5());
7380 }
7381
7382 if (has_crcperblock()) {
7383 // required uint64 crcPerBlock = 2;
7384 total_size += 1 +
7385 ::google::protobuf::internal::WireFormatLite::UInt64Size(
7386 this->crcperblock());
7387 }
7388
7389 if (has_bytespercrc()) {
7390 // required uint32 bytesPerCrc = 1;
7391 total_size += 1 +
7392 ::google::protobuf::internal::WireFormatLite::UInt32Size(
7393 this->bytespercrc());
7394 }
7395
7396 return total_size;
7397}
7398size_t OpBlockChecksumResponseProto::ByteSizeLong() const {
7399// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7400 size_t total_size = 0;
7401
7402 if (_internal_metadata_.have_unknown_fields()) {
7403 total_size +=
7404 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
7405 _internal_metadata_.unknown_fields());
7406 }
7407 if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) { // All required fields are present.
7408 // required bytes md5 = 3;
7409 total_size += 1 +
7410 ::google::protobuf::internal::WireFormatLite::BytesSize(
7411 this->md5());
7412
7413 // required uint64 crcPerBlock = 2;
7414 total_size += 1 +
7415 ::google::protobuf::internal::WireFormatLite::UInt64Size(
7416 this->crcperblock());
7417
7418 // required uint32 bytesPerCrc = 1;
7419 total_size += 1 +
7420 ::google::protobuf::internal::WireFormatLite::UInt32Size(
7421 this->bytespercrc());
7422
7423 } else {
7424 total_size += RequiredFieldsByteSizeFallback();
7425 }
7426 // optional .Hdfs.Internal.ChecksumTypeProto crcType = 4;
7427 if (has_crctype()) {
7428 total_size += 1 +
7429 ::google::protobuf::internal::WireFormatLite::EnumSize(this->crctype());
7430 }
7431
7432 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
7433 SetCachedSize(cached_size);
7434 return total_size;
7435}
7436
7437void OpBlockChecksumResponseProto::MergeFrom(const ::google::protobuf::Message& from) {
7438// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7439 GOOGLE_DCHECK_NE(&from, this);
7440 const OpBlockChecksumResponseProto* source =
7441 ::google::protobuf::internal::DynamicCastToGenerated<const OpBlockChecksumResponseProto>(
7442 &from);
7443 if (source == NULL) {
7444 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.OpBlockChecksumResponseProto)
7445 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
7446 } else {
7447 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.OpBlockChecksumResponseProto)
7448 MergeFrom(*source);
7449 }
7450}
7451
7452void OpBlockChecksumResponseProto::MergeFrom(const OpBlockChecksumResponseProto& from) {
7453// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7454 GOOGLE_DCHECK_NE(&from, this);
7455 _internal_metadata_.MergeFrom(from._internal_metadata_);
7456 ::google::protobuf::uint32 cached_has_bits = 0;
7457 (void) cached_has_bits;
7458
7459 cached_has_bits = from._has_bits_[0];
7460 if (cached_has_bits & 15u) {
7461 if (cached_has_bits & 0x00000001u) {
7462 set_has_md5();
7463 md5_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.md5_);
7464 }
7465 if (cached_has_bits & 0x00000002u) {
7466 crcperblock_ = from.crcperblock_;
7467 }
7468 if (cached_has_bits & 0x00000004u) {
7469 bytespercrc_ = from.bytespercrc_;
7470 }
7471 if (cached_has_bits & 0x00000008u) {
7472 crctype_ = from.crctype_;
7473 }
7474 _has_bits_[0] |= cached_has_bits;
7475 }
7476}
7477
7478void OpBlockChecksumResponseProto::CopyFrom(const ::google::protobuf::Message& from) {
7479// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7480 if (&from == this) return;
7481 Clear();
7482 MergeFrom(from);
7483}
7484
7485void OpBlockChecksumResponseProto::CopyFrom(const OpBlockChecksumResponseProto& from) {
7486// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.OpBlockChecksumResponseProto)
7487 if (&from == this) return;
7488 Clear();
7489 MergeFrom(from);
7490}
7491
7492bool OpBlockChecksumResponseProto::IsInitialized() const {
7493 if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
7494 return true;
7495}
7496
7497void OpBlockChecksumResponseProto::Swap(OpBlockChecksumResponseProto* other) {
7498 if (other == this) return;
7499 InternalSwap(other);
7500}
7501void OpBlockChecksumResponseProto::InternalSwap(OpBlockChecksumResponseProto* other) {
7502 using std::swap;
7503 md5_.Swap(&other->md5_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
7504 GetArenaNoVirtual());
7505 swap(crcperblock_, other->crcperblock_);
7506 swap(bytespercrc_, other->bytespercrc_);
7507 swap(crctype_, other->crctype_);
7508 swap(_has_bits_[0], other->_has_bits_[0]);
7509 _internal_metadata_.Swap(&other->_internal_metadata_);
7510}
7511
7512::google::protobuf::Metadata OpBlockChecksumResponseProto::GetMetadata() const {
7513 protobuf_datatransfer_2eproto::protobuf_AssignDescriptorsOnce();
7514 return ::protobuf_datatransfer_2eproto::file_level_metadata[kIndexInFileMessages];
7515}
7516
7517
7518// @@protoc_insertion_point(namespace_scope)
7519} // namespace Internal
7520} // namespace Hdfs
7521namespace google {
7522namespace protobuf {
7523template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::DataTransferEncryptorMessageProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::DataTransferEncryptorMessageProto >(Arena* arena) {
7524 return Arena::CreateInternal< ::Hdfs::Internal::DataTransferEncryptorMessageProto >(arena);
7525}
7526template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::BaseHeaderProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::BaseHeaderProto >(Arena* arena) {
7527 return Arena::CreateInternal< ::Hdfs::Internal::BaseHeaderProto >(arena);
7528}
7529template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::ClientOperationHeaderProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::ClientOperationHeaderProto >(Arena* arena) {
7530 return Arena::CreateInternal< ::Hdfs::Internal::ClientOperationHeaderProto >(arena);
7531}
7532template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::CachingStrategyProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::CachingStrategyProto >(Arena* arena) {
7533 return Arena::CreateInternal< ::Hdfs::Internal::CachingStrategyProto >(arena);
7534}
7535template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::OpReadBlockProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::OpReadBlockProto >(Arena* arena) {
7536 return Arena::CreateInternal< ::Hdfs::Internal::OpReadBlockProto >(arena);
7537}
7538template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::ChecksumProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::ChecksumProto >(Arena* arena) {
7539 return Arena::CreateInternal< ::Hdfs::Internal::ChecksumProto >(arena);
7540}
7541template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::OpWriteBlockProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::OpWriteBlockProto >(Arena* arena) {
7542 return Arena::CreateInternal< ::Hdfs::Internal::OpWriteBlockProto >(arena);
7543}
7544template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::OpTransferBlockProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::OpTransferBlockProto >(Arena* arena) {
7545 return Arena::CreateInternal< ::Hdfs::Internal::OpTransferBlockProto >(arena);
7546}
7547template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::OpReplaceBlockProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::OpReplaceBlockProto >(Arena* arena) {
7548 return Arena::CreateInternal< ::Hdfs::Internal::OpReplaceBlockProto >(arena);
7549}
7550template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::OpCopyBlockProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::OpCopyBlockProto >(Arena* arena) {
7551 return Arena::CreateInternal< ::Hdfs::Internal::OpCopyBlockProto >(arena);
7552}
7553template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::OpBlockChecksumProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::OpBlockChecksumProto >(Arena* arena) {
7554 return Arena::CreateInternal< ::Hdfs::Internal::OpBlockChecksumProto >(arena);
7555}
7556template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::OpRequestShortCircuitAccessProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::OpRequestShortCircuitAccessProto >(Arena* arena) {
7557 return Arena::CreateInternal< ::Hdfs::Internal::OpRequestShortCircuitAccessProto >(arena);
7558}
7559template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::PacketHeaderProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::PacketHeaderProto >(Arena* arena) {
7560 return Arena::CreateInternal< ::Hdfs::Internal::PacketHeaderProto >(arena);
7561}
7562template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::PipelineAckProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::PipelineAckProto >(Arena* arena) {
7563 return Arena::CreateInternal< ::Hdfs::Internal::PipelineAckProto >(arena);
7564}
7565template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::ReadOpChecksumInfoProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::ReadOpChecksumInfoProto >(Arena* arena) {
7566 return Arena::CreateInternal< ::Hdfs::Internal::ReadOpChecksumInfoProto >(arena);
7567}
7568template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::BlockOpResponseProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::BlockOpResponseProto >(Arena* arena) {
7569 return Arena::CreateInternal< ::Hdfs::Internal::BlockOpResponseProto >(arena);
7570}
7571template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::ClientReadStatusProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::ClientReadStatusProto >(Arena* arena) {
7572 return Arena::CreateInternal< ::Hdfs::Internal::ClientReadStatusProto >(arena);
7573}
7574template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::DNTransferAckProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::DNTransferAckProto >(Arena* arena) {
7575 return Arena::CreateInternal< ::Hdfs::Internal::DNTransferAckProto >(arena);
7576}
7577template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::OpBlockChecksumResponseProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::OpBlockChecksumResponseProto >(Arena* arena) {
7578 return Arena::CreateInternal< ::Hdfs::Internal::OpBlockChecksumResponseProto >(arena);
7579}
7580} // namespace protobuf
7581} // namespace google
7582
7583// @@protoc_insertion_point(global_scope)
7584