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