RDFS
The Rice Comp413 2017 class' continuation on the work of the 2016 RDFS.
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Pages
xattr.pb.h
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: xattr.proto
3 
4 #ifndef PROTOBUF_xattr_2eproto__INCLUDED
5 #define PROTOBUF_xattr_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 // @@protoc_insertion_point(includes)
32 
33 namespace hadoop {
34 namespace hdfs {
35 
36 // Internal implementation detail -- do not call these.
37 void protobuf_AddDesc_xattr_2eproto();
38 void protobuf_AssignDesc_xattr_2eproto();
39 void protobuf_ShutdownFile_xattr_2eproto();
40 
41 class GetXAttrsRequestProto;
42 class GetXAttrsResponseProto;
43 class ListXAttrsRequestProto;
44 class ListXAttrsResponseProto;
45 class RemoveXAttrRequestProto;
46 class RemoveXAttrResponseProto;
47 class SetXAttrRequestProto;
48 class SetXAttrResponseProto;
49 class XAttrEditLogProto;
50 class XAttrProto;
51 
52 enum XAttrProto_XAttrNamespaceProto {
53  XAttrProto_XAttrNamespaceProto_USER = 0,
54  XAttrProto_XAttrNamespaceProto_TRUSTED = 1,
55  XAttrProto_XAttrNamespaceProto_SECURITY = 2,
56  XAttrProto_XAttrNamespaceProto_SYSTEM = 3,
57  XAttrProto_XAttrNamespaceProto_RAW = 4
58 };
59 bool XAttrProto_XAttrNamespaceProto_IsValid(int value);
60 const XAttrProto_XAttrNamespaceProto XAttrProto_XAttrNamespaceProto_XAttrNamespaceProto_MIN = XAttrProto_XAttrNamespaceProto_USER;
61 const XAttrProto_XAttrNamespaceProto XAttrProto_XAttrNamespaceProto_XAttrNamespaceProto_MAX = XAttrProto_XAttrNamespaceProto_RAW;
62 const int XAttrProto_XAttrNamespaceProto_XAttrNamespaceProto_ARRAYSIZE = XAttrProto_XAttrNamespaceProto_XAttrNamespaceProto_MAX + 1;
63 
64 const ::google::protobuf::EnumDescriptor* XAttrProto_XAttrNamespaceProto_descriptor();
65 inline const ::std::string& XAttrProto_XAttrNamespaceProto_Name(XAttrProto_XAttrNamespaceProto value) {
66  return ::google::protobuf::internal::NameOfEnum(
67  XAttrProto_XAttrNamespaceProto_descriptor(), value);
68 }
69 inline bool XAttrProto_XAttrNamespaceProto_Parse(
70  const ::std::string& name, XAttrProto_XAttrNamespaceProto* value) {
71  return ::google::protobuf::internal::ParseNamedEnum<XAttrProto_XAttrNamespaceProto>(
72  XAttrProto_XAttrNamespaceProto_descriptor(), name, value);
73 }
74 enum XAttrSetFlagProto {
75  XATTR_CREATE = 1,
76  XATTR_REPLACE = 2
77 };
78 bool XAttrSetFlagProto_IsValid(int value);
79 const XAttrSetFlagProto XAttrSetFlagProto_MIN = XATTR_CREATE;
80 const XAttrSetFlagProto XAttrSetFlagProto_MAX = XATTR_REPLACE;
81 const int XAttrSetFlagProto_ARRAYSIZE = XAttrSetFlagProto_MAX + 1;
82 
83 const ::google::protobuf::EnumDescriptor* XAttrSetFlagProto_descriptor();
84 inline const ::std::string& XAttrSetFlagProto_Name(XAttrSetFlagProto value) {
85  return ::google::protobuf::internal::NameOfEnum(
86  XAttrSetFlagProto_descriptor(), value);
87 }
88 inline bool XAttrSetFlagProto_Parse(
89  const ::std::string& name, XAttrSetFlagProto* value) {
90  return ::google::protobuf::internal::ParseNamedEnum<XAttrSetFlagProto>(
91  XAttrSetFlagProto_descriptor(), name, value);
92 }
93 // ===================================================================
94 
95 class XAttrProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.XAttrProto) */ {
96  public:
97  XAttrProto();
98  virtual ~XAttrProto();
99 
100  XAttrProto(const XAttrProto& from);
101 
102  inline XAttrProto& operator=(const XAttrProto& from) {
103  CopyFrom(from);
104  return *this;
105  }
106 
107  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
108  return _internal_metadata_.unknown_fields();
109  }
110 
111  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
112  return _internal_metadata_.mutable_unknown_fields();
113  }
114 
115  static const ::google::protobuf::Descriptor* descriptor();
116  static const XAttrProto& default_instance();
117 
118  void Swap(XAttrProto* other);
119 
120  // implements Message ----------------------------------------------
121 
122  inline XAttrProto* New() const { return New(NULL); }
123 
124  XAttrProto* New(::google::protobuf::Arena* arena) const;
125  void CopyFrom(const ::google::protobuf::Message& from);
126  void MergeFrom(const ::google::protobuf::Message& from);
127  void CopyFrom(const XAttrProto& from);
128  void MergeFrom(const XAttrProto& from);
129  void Clear();
130  bool IsInitialized() const;
131 
132  int ByteSize() const;
133  bool MergePartialFromCodedStream(
134  ::google::protobuf::io::CodedInputStream* input);
135  void SerializeWithCachedSizes(
136  ::google::protobuf::io::CodedOutputStream* output) const;
137  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
138  bool deterministic, ::google::protobuf::uint8* output) const;
139  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
140  return InternalSerializeWithCachedSizesToArray(false, output);
141  }
142  int GetCachedSize() const { return _cached_size_; }
143  private:
144  void SharedCtor();
145  void SharedDtor();
146  void SetCachedSize(int size) const;
147  void InternalSwap(XAttrProto* other);
148  private:
149  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
150  return _internal_metadata_.arena();
151  }
152  inline void* MaybeArenaPtr() const {
153  return _internal_metadata_.raw_arena_ptr();
154  }
155  public:
156 
157  ::google::protobuf::Metadata GetMetadata() const;
158 
159  // nested types ----------------------------------------------------
160 
161  typedef XAttrProto_XAttrNamespaceProto XAttrNamespaceProto;
162  static const XAttrNamespaceProto USER =
163  XAttrProto_XAttrNamespaceProto_USER;
164  static const XAttrNamespaceProto TRUSTED =
165  XAttrProto_XAttrNamespaceProto_TRUSTED;
166  static const XAttrNamespaceProto SECURITY =
167  XAttrProto_XAttrNamespaceProto_SECURITY;
168  static const XAttrNamespaceProto SYSTEM =
169  XAttrProto_XAttrNamespaceProto_SYSTEM;
170  static const XAttrNamespaceProto RAW =
171  XAttrProto_XAttrNamespaceProto_RAW;
172  static inline bool XAttrNamespaceProto_IsValid(int value) {
173  return XAttrProto_XAttrNamespaceProto_IsValid(value);
174  }
175  static const XAttrNamespaceProto XAttrNamespaceProto_MIN =
176  XAttrProto_XAttrNamespaceProto_XAttrNamespaceProto_MIN;
177  static const XAttrNamespaceProto XAttrNamespaceProto_MAX =
178  XAttrProto_XAttrNamespaceProto_XAttrNamespaceProto_MAX;
179  static const int XAttrNamespaceProto_ARRAYSIZE =
180  XAttrProto_XAttrNamespaceProto_XAttrNamespaceProto_ARRAYSIZE;
181  static inline const ::google::protobuf::EnumDescriptor*
182  XAttrNamespaceProto_descriptor() {
183  return XAttrProto_XAttrNamespaceProto_descriptor();
184  }
185  static inline const ::std::string& XAttrNamespaceProto_Name(XAttrNamespaceProto value) {
186  return XAttrProto_XAttrNamespaceProto_Name(value);
187  }
188  static inline bool XAttrNamespaceProto_Parse(const ::std::string& name,
189  XAttrNamespaceProto* value) {
190  return XAttrProto_XAttrNamespaceProto_Parse(name, value);
191  }
192 
193  // accessors -------------------------------------------------------
194 
195  // required .hadoop.hdfs.XAttrProto.XAttrNamespaceProto namespace = 1;
196  bool has_namespace_() const;
197  void clear_namespace_();
198  static const int kNamespaceFieldNumber = 1;
199  ::hadoop::hdfs::XAttrProto_XAttrNamespaceProto namespace_() const;
200  void set_namespace_(::hadoop::hdfs::XAttrProto_XAttrNamespaceProto value);
201 
202  // required string name = 2;
203  bool has_name() const;
204  void clear_name();
205  static const int kNameFieldNumber = 2;
206  const ::std::string& name() const;
207  void set_name(const ::std::string& value);
208  void set_name(const char* value);
209  void set_name(const char* value, size_t size);
210  ::std::string* mutable_name();
211  ::std::string* release_name();
212  void set_allocated_name(::std::string* name);
213 
214  // optional bytes value = 3;
215  bool has_value() const;
216  void clear_value();
217  static const int kValueFieldNumber = 3;
218  const ::std::string& value() const;
219  void set_value(const ::std::string& value);
220  void set_value(const char* value);
221  void set_value(const void* value, size_t size);
222  ::std::string* mutable_value();
223  ::std::string* release_value();
224  void set_allocated_value(::std::string* value);
225 
226  // @@protoc_insertion_point(class_scope:hadoop.hdfs.XAttrProto)
227  private:
228  inline void set_has_namespace_();
229  inline void clear_has_namespace_();
230  inline void set_has_name();
231  inline void clear_has_name();
232  inline void set_has_value();
233  inline void clear_has_value();
234 
235  // helper for ByteSize()
236  int RequiredFieldsByteSizeFallback() const;
237 
238  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
239  ::google::protobuf::uint32 _has_bits_[1];
240  mutable int _cached_size_;
241  ::google::protobuf::internal::ArenaStringPtr name_;
242  ::google::protobuf::internal::ArenaStringPtr value_;
243  int namespace__;
244  friend void protobuf_AddDesc_xattr_2eproto();
245  friend void protobuf_AssignDesc_xattr_2eproto();
246  friend void protobuf_ShutdownFile_xattr_2eproto();
247 
248  void InitAsDefaultInstance();
249  static XAttrProto* default_instance_;
250 };
251 // -------------------------------------------------------------------
252 
253 class XAttrEditLogProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.XAttrEditLogProto) */ {
254  public:
255  XAttrEditLogProto();
256  virtual ~XAttrEditLogProto();
257 
258  XAttrEditLogProto(const XAttrEditLogProto& from);
259 
260  inline XAttrEditLogProto& operator=(const XAttrEditLogProto& from) {
261  CopyFrom(from);
262  return *this;
263  }
264 
265  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
266  return _internal_metadata_.unknown_fields();
267  }
268 
269  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
270  return _internal_metadata_.mutable_unknown_fields();
271  }
272 
273  static const ::google::protobuf::Descriptor* descriptor();
274  static const XAttrEditLogProto& default_instance();
275 
276  void Swap(XAttrEditLogProto* other);
277 
278  // implements Message ----------------------------------------------
279 
280  inline XAttrEditLogProto* New() const { return New(NULL); }
281 
282  XAttrEditLogProto* New(::google::protobuf::Arena* arena) const;
283  void CopyFrom(const ::google::protobuf::Message& from);
284  void MergeFrom(const ::google::protobuf::Message& from);
285  void CopyFrom(const XAttrEditLogProto& from);
286  void MergeFrom(const XAttrEditLogProto& from);
287  void Clear();
288  bool IsInitialized() const;
289 
290  int ByteSize() const;
291  bool MergePartialFromCodedStream(
292  ::google::protobuf::io::CodedInputStream* input);
293  void SerializeWithCachedSizes(
294  ::google::protobuf::io::CodedOutputStream* output) const;
295  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
296  bool deterministic, ::google::protobuf::uint8* output) const;
297  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
298  return InternalSerializeWithCachedSizesToArray(false, output);
299  }
300  int GetCachedSize() const { return _cached_size_; }
301  private:
302  void SharedCtor();
303  void SharedDtor();
304  void SetCachedSize(int size) const;
305  void InternalSwap(XAttrEditLogProto* other);
306  private:
307  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
308  return _internal_metadata_.arena();
309  }
310  inline void* MaybeArenaPtr() const {
311  return _internal_metadata_.raw_arena_ptr();
312  }
313  public:
314 
315  ::google::protobuf::Metadata GetMetadata() const;
316 
317  // nested types ----------------------------------------------------
318 
319  // accessors -------------------------------------------------------
320 
321  // optional string src = 1;
322  bool has_src() const;
323  void clear_src();
324  static const int kSrcFieldNumber = 1;
325  const ::std::string& src() const;
326  void set_src(const ::std::string& value);
327  void set_src(const char* value);
328  void set_src(const char* value, size_t size);
329  ::std::string* mutable_src();
330  ::std::string* release_src();
331  void set_allocated_src(::std::string* src);
332 
333  // repeated .hadoop.hdfs.XAttrProto xAttrs = 2;
334  int xattrs_size() const;
335  void clear_xattrs();
336  static const int kXAttrsFieldNumber = 2;
337  const ::hadoop::hdfs::XAttrProto& xattrs(int index) const;
338  ::hadoop::hdfs::XAttrProto* mutable_xattrs(int index);
339  ::hadoop::hdfs::XAttrProto* add_xattrs();
340  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >*
341  mutable_xattrs();
342  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >&
343  xattrs() const;
344 
345  // @@protoc_insertion_point(class_scope:hadoop.hdfs.XAttrEditLogProto)
346  private:
347  inline void set_has_src();
348  inline void clear_has_src();
349 
350  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
351  ::google::protobuf::uint32 _has_bits_[1];
352  mutable int _cached_size_;
353  ::google::protobuf::internal::ArenaStringPtr src_;
354  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto > xattrs_;
355  friend void protobuf_AddDesc_xattr_2eproto();
356  friend void protobuf_AssignDesc_xattr_2eproto();
357  friend void protobuf_ShutdownFile_xattr_2eproto();
358 
359  void InitAsDefaultInstance();
360  static XAttrEditLogProto* default_instance_;
361 };
362 // -------------------------------------------------------------------
363 
364 class SetXAttrRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SetXAttrRequestProto) */ {
365  public:
366  SetXAttrRequestProto();
367  virtual ~SetXAttrRequestProto();
368 
369  SetXAttrRequestProto(const SetXAttrRequestProto& from);
370 
371  inline SetXAttrRequestProto& operator=(const SetXAttrRequestProto& from) {
372  CopyFrom(from);
373  return *this;
374  }
375 
376  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
377  return _internal_metadata_.unknown_fields();
378  }
379 
380  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
381  return _internal_metadata_.mutable_unknown_fields();
382  }
383 
384  static const ::google::protobuf::Descriptor* descriptor();
385  static const SetXAttrRequestProto& default_instance();
386 
387  void Swap(SetXAttrRequestProto* other);
388 
389  // implements Message ----------------------------------------------
390 
391  inline SetXAttrRequestProto* New() const { return New(NULL); }
392 
393  SetXAttrRequestProto* New(::google::protobuf::Arena* arena) const;
394  void CopyFrom(const ::google::protobuf::Message& from);
395  void MergeFrom(const ::google::protobuf::Message& from);
396  void CopyFrom(const SetXAttrRequestProto& from);
397  void MergeFrom(const SetXAttrRequestProto& from);
398  void Clear();
399  bool IsInitialized() const;
400 
401  int ByteSize() const;
402  bool MergePartialFromCodedStream(
403  ::google::protobuf::io::CodedInputStream* input);
404  void SerializeWithCachedSizes(
405  ::google::protobuf::io::CodedOutputStream* output) const;
406  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
407  bool deterministic, ::google::protobuf::uint8* output) const;
408  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
409  return InternalSerializeWithCachedSizesToArray(false, output);
410  }
411  int GetCachedSize() const { return _cached_size_; }
412  private:
413  void SharedCtor();
414  void SharedDtor();
415  void SetCachedSize(int size) const;
416  void InternalSwap(SetXAttrRequestProto* other);
417  private:
418  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
419  return _internal_metadata_.arena();
420  }
421  inline void* MaybeArenaPtr() const {
422  return _internal_metadata_.raw_arena_ptr();
423  }
424  public:
425 
426  ::google::protobuf::Metadata GetMetadata() const;
427 
428  // nested types ----------------------------------------------------
429 
430  // accessors -------------------------------------------------------
431 
432  // required string src = 1;
433  bool has_src() const;
434  void clear_src();
435  static const int kSrcFieldNumber = 1;
436  const ::std::string& src() const;
437  void set_src(const ::std::string& value);
438  void set_src(const char* value);
439  void set_src(const char* value, size_t size);
440  ::std::string* mutable_src();
441  ::std::string* release_src();
442  void set_allocated_src(::std::string* src);
443 
444  // optional .hadoop.hdfs.XAttrProto xAttr = 2;
445  bool has_xattr() const;
446  void clear_xattr();
447  static const int kXAttrFieldNumber = 2;
448  const ::hadoop::hdfs::XAttrProto& xattr() const;
449  ::hadoop::hdfs::XAttrProto* mutable_xattr();
450  ::hadoop::hdfs::XAttrProto* release_xattr();
451  void set_allocated_xattr(::hadoop::hdfs::XAttrProto* xattr);
452 
453  // optional uint32 flag = 3;
454  bool has_flag() const;
455  void clear_flag();
456  static const int kFlagFieldNumber = 3;
457  ::google::protobuf::uint32 flag() const;
458  void set_flag(::google::protobuf::uint32 value);
459 
460  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SetXAttrRequestProto)
461  private:
462  inline void set_has_src();
463  inline void clear_has_src();
464  inline void set_has_xattr();
465  inline void clear_has_xattr();
466  inline void set_has_flag();
467  inline void clear_has_flag();
468 
469  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
470  ::google::protobuf::uint32 _has_bits_[1];
471  mutable int _cached_size_;
472  ::google::protobuf::internal::ArenaStringPtr src_;
473  ::hadoop::hdfs::XAttrProto* xattr_;
474  ::google::protobuf::uint32 flag_;
475  friend void protobuf_AddDesc_xattr_2eproto();
476  friend void protobuf_AssignDesc_xattr_2eproto();
477  friend void protobuf_ShutdownFile_xattr_2eproto();
478 
479  void InitAsDefaultInstance();
480  static SetXAttrRequestProto* default_instance_;
481 };
482 // -------------------------------------------------------------------
483 
484 class SetXAttrResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SetXAttrResponseProto) */ {
485  public:
486  SetXAttrResponseProto();
487  virtual ~SetXAttrResponseProto();
488 
489  SetXAttrResponseProto(const SetXAttrResponseProto& from);
490 
491  inline SetXAttrResponseProto& operator=(const SetXAttrResponseProto& from) {
492  CopyFrom(from);
493  return *this;
494  }
495 
496  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
497  return _internal_metadata_.unknown_fields();
498  }
499 
500  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
501  return _internal_metadata_.mutable_unknown_fields();
502  }
503 
504  static const ::google::protobuf::Descriptor* descriptor();
505  static const SetXAttrResponseProto& default_instance();
506 
507  void Swap(SetXAttrResponseProto* other);
508 
509  // implements Message ----------------------------------------------
510 
511  inline SetXAttrResponseProto* New() const { return New(NULL); }
512 
513  SetXAttrResponseProto* New(::google::protobuf::Arena* arena) const;
514  void CopyFrom(const ::google::protobuf::Message& from);
515  void MergeFrom(const ::google::protobuf::Message& from);
516  void CopyFrom(const SetXAttrResponseProto& from);
517  void MergeFrom(const SetXAttrResponseProto& from);
518  void Clear();
519  bool IsInitialized() const;
520 
521  int ByteSize() const;
522  bool MergePartialFromCodedStream(
523  ::google::protobuf::io::CodedInputStream* input);
524  void SerializeWithCachedSizes(
525  ::google::protobuf::io::CodedOutputStream* output) const;
526  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
527  bool deterministic, ::google::protobuf::uint8* output) const;
528  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
529  return InternalSerializeWithCachedSizesToArray(false, output);
530  }
531  int GetCachedSize() const { return _cached_size_; }
532  private:
533  void SharedCtor();
534  void SharedDtor();
535  void SetCachedSize(int size) const;
536  void InternalSwap(SetXAttrResponseProto* other);
537  private:
538  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
539  return _internal_metadata_.arena();
540  }
541  inline void* MaybeArenaPtr() const {
542  return _internal_metadata_.raw_arena_ptr();
543  }
544  public:
545 
546  ::google::protobuf::Metadata GetMetadata() const;
547 
548  // nested types ----------------------------------------------------
549 
550  // accessors -------------------------------------------------------
551 
552  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SetXAttrResponseProto)
553  private:
554 
555  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
556  ::google::protobuf::uint32 _has_bits_[1];
557  mutable int _cached_size_;
558  friend void protobuf_AddDesc_xattr_2eproto();
559  friend void protobuf_AssignDesc_xattr_2eproto();
560  friend void protobuf_ShutdownFile_xattr_2eproto();
561 
562  void InitAsDefaultInstance();
563  static SetXAttrResponseProto* default_instance_;
564 };
565 // -------------------------------------------------------------------
566 
567 class GetXAttrsRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.GetXAttrsRequestProto) */ {
568  public:
569  GetXAttrsRequestProto();
570  virtual ~GetXAttrsRequestProto();
571 
572  GetXAttrsRequestProto(const GetXAttrsRequestProto& from);
573 
574  inline GetXAttrsRequestProto& operator=(const GetXAttrsRequestProto& from) {
575  CopyFrom(from);
576  return *this;
577  }
578 
579  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
580  return _internal_metadata_.unknown_fields();
581  }
582 
583  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
584  return _internal_metadata_.mutable_unknown_fields();
585  }
586 
587  static const ::google::protobuf::Descriptor* descriptor();
588  static const GetXAttrsRequestProto& default_instance();
589 
590  void Swap(GetXAttrsRequestProto* other);
591 
592  // implements Message ----------------------------------------------
593 
594  inline GetXAttrsRequestProto* New() const { return New(NULL); }
595 
596  GetXAttrsRequestProto* New(::google::protobuf::Arena* arena) const;
597  void CopyFrom(const ::google::protobuf::Message& from);
598  void MergeFrom(const ::google::protobuf::Message& from);
599  void CopyFrom(const GetXAttrsRequestProto& from);
600  void MergeFrom(const GetXAttrsRequestProto& from);
601  void Clear();
602  bool IsInitialized() const;
603 
604  int ByteSize() const;
605  bool MergePartialFromCodedStream(
606  ::google::protobuf::io::CodedInputStream* input);
607  void SerializeWithCachedSizes(
608  ::google::protobuf::io::CodedOutputStream* output) const;
609  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
610  bool deterministic, ::google::protobuf::uint8* output) const;
611  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
612  return InternalSerializeWithCachedSizesToArray(false, output);
613  }
614  int GetCachedSize() const { return _cached_size_; }
615  private:
616  void SharedCtor();
617  void SharedDtor();
618  void SetCachedSize(int size) const;
619  void InternalSwap(GetXAttrsRequestProto* other);
620  private:
621  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
622  return _internal_metadata_.arena();
623  }
624  inline void* MaybeArenaPtr() const {
625  return _internal_metadata_.raw_arena_ptr();
626  }
627  public:
628 
629  ::google::protobuf::Metadata GetMetadata() const;
630 
631  // nested types ----------------------------------------------------
632 
633  // accessors -------------------------------------------------------
634 
635  // required string src = 1;
636  bool has_src() const;
637  void clear_src();
638  static const int kSrcFieldNumber = 1;
639  const ::std::string& src() const;
640  void set_src(const ::std::string& value);
641  void set_src(const char* value);
642  void set_src(const char* value, size_t size);
643  ::std::string* mutable_src();
644  ::std::string* release_src();
645  void set_allocated_src(::std::string* src);
646 
647  // repeated .hadoop.hdfs.XAttrProto xAttrs = 2;
648  int xattrs_size() const;
649  void clear_xattrs();
650  static const int kXAttrsFieldNumber = 2;
651  const ::hadoop::hdfs::XAttrProto& xattrs(int index) const;
652  ::hadoop::hdfs::XAttrProto* mutable_xattrs(int index);
653  ::hadoop::hdfs::XAttrProto* add_xattrs();
654  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >*
655  mutable_xattrs();
656  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >&
657  xattrs() const;
658 
659  // @@protoc_insertion_point(class_scope:hadoop.hdfs.GetXAttrsRequestProto)
660  private:
661  inline void set_has_src();
662  inline void clear_has_src();
663 
664  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
665  ::google::protobuf::uint32 _has_bits_[1];
666  mutable int _cached_size_;
667  ::google::protobuf::internal::ArenaStringPtr src_;
668  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto > xattrs_;
669  friend void protobuf_AddDesc_xattr_2eproto();
670  friend void protobuf_AssignDesc_xattr_2eproto();
671  friend void protobuf_ShutdownFile_xattr_2eproto();
672 
673  void InitAsDefaultInstance();
674  static GetXAttrsRequestProto* default_instance_;
675 };
676 // -------------------------------------------------------------------
677 
678 class GetXAttrsResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.GetXAttrsResponseProto) */ {
679  public:
680  GetXAttrsResponseProto();
681  virtual ~GetXAttrsResponseProto();
682 
683  GetXAttrsResponseProto(const GetXAttrsResponseProto& from);
684 
685  inline GetXAttrsResponseProto& operator=(const GetXAttrsResponseProto& from) {
686  CopyFrom(from);
687  return *this;
688  }
689 
690  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
691  return _internal_metadata_.unknown_fields();
692  }
693 
694  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
695  return _internal_metadata_.mutable_unknown_fields();
696  }
697 
698  static const ::google::protobuf::Descriptor* descriptor();
699  static const GetXAttrsResponseProto& default_instance();
700 
701  void Swap(GetXAttrsResponseProto* other);
702 
703  // implements Message ----------------------------------------------
704 
705  inline GetXAttrsResponseProto* New() const { return New(NULL); }
706 
707  GetXAttrsResponseProto* New(::google::protobuf::Arena* arena) const;
708  void CopyFrom(const ::google::protobuf::Message& from);
709  void MergeFrom(const ::google::protobuf::Message& from);
710  void CopyFrom(const GetXAttrsResponseProto& from);
711  void MergeFrom(const GetXAttrsResponseProto& from);
712  void Clear();
713  bool IsInitialized() const;
714 
715  int ByteSize() const;
716  bool MergePartialFromCodedStream(
717  ::google::protobuf::io::CodedInputStream* input);
718  void SerializeWithCachedSizes(
719  ::google::protobuf::io::CodedOutputStream* output) const;
720  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
721  bool deterministic, ::google::protobuf::uint8* output) const;
722  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
723  return InternalSerializeWithCachedSizesToArray(false, output);
724  }
725  int GetCachedSize() const { return _cached_size_; }
726  private:
727  void SharedCtor();
728  void SharedDtor();
729  void SetCachedSize(int size) const;
730  void InternalSwap(GetXAttrsResponseProto* other);
731  private:
732  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
733  return _internal_metadata_.arena();
734  }
735  inline void* MaybeArenaPtr() const {
736  return _internal_metadata_.raw_arena_ptr();
737  }
738  public:
739 
740  ::google::protobuf::Metadata GetMetadata() const;
741 
742  // nested types ----------------------------------------------------
743 
744  // accessors -------------------------------------------------------
745 
746  // repeated .hadoop.hdfs.XAttrProto xAttrs = 1;
747  int xattrs_size() const;
748  void clear_xattrs();
749  static const int kXAttrsFieldNumber = 1;
750  const ::hadoop::hdfs::XAttrProto& xattrs(int index) const;
751  ::hadoop::hdfs::XAttrProto* mutable_xattrs(int index);
752  ::hadoop::hdfs::XAttrProto* add_xattrs();
753  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >*
754  mutable_xattrs();
755  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >&
756  xattrs() const;
757 
758  // @@protoc_insertion_point(class_scope:hadoop.hdfs.GetXAttrsResponseProto)
759  private:
760 
761  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
762  ::google::protobuf::uint32 _has_bits_[1];
763  mutable int _cached_size_;
764  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto > xattrs_;
765  friend void protobuf_AddDesc_xattr_2eproto();
766  friend void protobuf_AssignDesc_xattr_2eproto();
767  friend void protobuf_ShutdownFile_xattr_2eproto();
768 
769  void InitAsDefaultInstance();
770  static GetXAttrsResponseProto* default_instance_;
771 };
772 // -------------------------------------------------------------------
773 
774 class ListXAttrsRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ListXAttrsRequestProto) */ {
775  public:
776  ListXAttrsRequestProto();
777  virtual ~ListXAttrsRequestProto();
778 
779  ListXAttrsRequestProto(const ListXAttrsRequestProto& from);
780 
781  inline ListXAttrsRequestProto& operator=(const ListXAttrsRequestProto& from) {
782  CopyFrom(from);
783  return *this;
784  }
785 
786  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
787  return _internal_metadata_.unknown_fields();
788  }
789 
790  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
791  return _internal_metadata_.mutable_unknown_fields();
792  }
793 
794  static const ::google::protobuf::Descriptor* descriptor();
795  static const ListXAttrsRequestProto& default_instance();
796 
797  void Swap(ListXAttrsRequestProto* other);
798 
799  // implements Message ----------------------------------------------
800 
801  inline ListXAttrsRequestProto* New() const { return New(NULL); }
802 
803  ListXAttrsRequestProto* New(::google::protobuf::Arena* arena) const;
804  void CopyFrom(const ::google::protobuf::Message& from);
805  void MergeFrom(const ::google::protobuf::Message& from);
806  void CopyFrom(const ListXAttrsRequestProto& from);
807  void MergeFrom(const ListXAttrsRequestProto& from);
808  void Clear();
809  bool IsInitialized() const;
810 
811  int ByteSize() const;
812  bool MergePartialFromCodedStream(
813  ::google::protobuf::io::CodedInputStream* input);
814  void SerializeWithCachedSizes(
815  ::google::protobuf::io::CodedOutputStream* output) const;
816  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
817  bool deterministic, ::google::protobuf::uint8* output) const;
818  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
819  return InternalSerializeWithCachedSizesToArray(false, output);
820  }
821  int GetCachedSize() const { return _cached_size_; }
822  private:
823  void SharedCtor();
824  void SharedDtor();
825  void SetCachedSize(int size) const;
826  void InternalSwap(ListXAttrsRequestProto* other);
827  private:
828  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
829  return _internal_metadata_.arena();
830  }
831  inline void* MaybeArenaPtr() const {
832  return _internal_metadata_.raw_arena_ptr();
833  }
834  public:
835 
836  ::google::protobuf::Metadata GetMetadata() const;
837 
838  // nested types ----------------------------------------------------
839 
840  // accessors -------------------------------------------------------
841 
842  // required string src = 1;
843  bool has_src() const;
844  void clear_src();
845  static const int kSrcFieldNumber = 1;
846  const ::std::string& src() const;
847  void set_src(const ::std::string& value);
848  void set_src(const char* value);
849  void set_src(const char* value, size_t size);
850  ::std::string* mutable_src();
851  ::std::string* release_src();
852  void set_allocated_src(::std::string* src);
853 
854  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ListXAttrsRequestProto)
855  private:
856  inline void set_has_src();
857  inline void clear_has_src();
858 
859  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
860  ::google::protobuf::uint32 _has_bits_[1];
861  mutable int _cached_size_;
862  ::google::protobuf::internal::ArenaStringPtr src_;
863  friend void protobuf_AddDesc_xattr_2eproto();
864  friend void protobuf_AssignDesc_xattr_2eproto();
865  friend void protobuf_ShutdownFile_xattr_2eproto();
866 
867  void InitAsDefaultInstance();
868  static ListXAttrsRequestProto* default_instance_;
869 };
870 // -------------------------------------------------------------------
871 
872 class ListXAttrsResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ListXAttrsResponseProto) */ {
873  public:
874  ListXAttrsResponseProto();
875  virtual ~ListXAttrsResponseProto();
876 
877  ListXAttrsResponseProto(const ListXAttrsResponseProto& from);
878 
879  inline ListXAttrsResponseProto& operator=(const ListXAttrsResponseProto& from) {
880  CopyFrom(from);
881  return *this;
882  }
883 
884  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
885  return _internal_metadata_.unknown_fields();
886  }
887 
888  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
889  return _internal_metadata_.mutable_unknown_fields();
890  }
891 
892  static const ::google::protobuf::Descriptor* descriptor();
893  static const ListXAttrsResponseProto& default_instance();
894 
895  void Swap(ListXAttrsResponseProto* other);
896 
897  // implements Message ----------------------------------------------
898 
899  inline ListXAttrsResponseProto* New() const { return New(NULL); }
900 
901  ListXAttrsResponseProto* New(::google::protobuf::Arena* arena) const;
902  void CopyFrom(const ::google::protobuf::Message& from);
903  void MergeFrom(const ::google::protobuf::Message& from);
904  void CopyFrom(const ListXAttrsResponseProto& from);
905  void MergeFrom(const ListXAttrsResponseProto& from);
906  void Clear();
907  bool IsInitialized() const;
908 
909  int ByteSize() const;
910  bool MergePartialFromCodedStream(
911  ::google::protobuf::io::CodedInputStream* input);
912  void SerializeWithCachedSizes(
913  ::google::protobuf::io::CodedOutputStream* output) const;
914  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
915  bool deterministic, ::google::protobuf::uint8* output) const;
916  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
917  return InternalSerializeWithCachedSizesToArray(false, output);
918  }
919  int GetCachedSize() const { return _cached_size_; }
920  private:
921  void SharedCtor();
922  void SharedDtor();
923  void SetCachedSize(int size) const;
924  void InternalSwap(ListXAttrsResponseProto* other);
925  private:
926  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
927  return _internal_metadata_.arena();
928  }
929  inline void* MaybeArenaPtr() const {
930  return _internal_metadata_.raw_arena_ptr();
931  }
932  public:
933 
934  ::google::protobuf::Metadata GetMetadata() const;
935 
936  // nested types ----------------------------------------------------
937 
938  // accessors -------------------------------------------------------
939 
940  // repeated .hadoop.hdfs.XAttrProto xAttrs = 1;
941  int xattrs_size() const;
942  void clear_xattrs();
943  static const int kXAttrsFieldNumber = 1;
944  const ::hadoop::hdfs::XAttrProto& xattrs(int index) const;
945  ::hadoop::hdfs::XAttrProto* mutable_xattrs(int index);
946  ::hadoop::hdfs::XAttrProto* add_xattrs();
947  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >*
948  mutable_xattrs();
949  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >&
950  xattrs() const;
951 
952  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ListXAttrsResponseProto)
953  private:
954 
955  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
956  ::google::protobuf::uint32 _has_bits_[1];
957  mutable int _cached_size_;
958  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto > xattrs_;
959  friend void protobuf_AddDesc_xattr_2eproto();
960  friend void protobuf_AssignDesc_xattr_2eproto();
961  friend void protobuf_ShutdownFile_xattr_2eproto();
962 
963  void InitAsDefaultInstance();
964  static ListXAttrsResponseProto* default_instance_;
965 };
966 // -------------------------------------------------------------------
967 
968 class RemoveXAttrRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoveXAttrRequestProto) */ {
969  public:
970  RemoveXAttrRequestProto();
971  virtual ~RemoveXAttrRequestProto();
972 
973  RemoveXAttrRequestProto(const RemoveXAttrRequestProto& from);
974 
975  inline RemoveXAttrRequestProto& operator=(const RemoveXAttrRequestProto& from) {
976  CopyFrom(from);
977  return *this;
978  }
979 
980  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
981  return _internal_metadata_.unknown_fields();
982  }
983 
984  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
985  return _internal_metadata_.mutable_unknown_fields();
986  }
987 
988  static const ::google::protobuf::Descriptor* descriptor();
989  static const RemoveXAttrRequestProto& default_instance();
990 
991  void Swap(RemoveXAttrRequestProto* other);
992 
993  // implements Message ----------------------------------------------
994 
995  inline RemoveXAttrRequestProto* New() const { return New(NULL); }
996 
997  RemoveXAttrRequestProto* New(::google::protobuf::Arena* arena) const;
998  void CopyFrom(const ::google::protobuf::Message& from);
999  void MergeFrom(const ::google::protobuf::Message& from);
1000  void CopyFrom(const RemoveXAttrRequestProto& from);
1001  void MergeFrom(const RemoveXAttrRequestProto& from);
1002  void Clear();
1003  bool IsInitialized() const;
1004 
1005  int ByteSize() const;
1006  bool MergePartialFromCodedStream(
1007  ::google::protobuf::io::CodedInputStream* input);
1008  void SerializeWithCachedSizes(
1009  ::google::protobuf::io::CodedOutputStream* output) const;
1010  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1011  bool deterministic, ::google::protobuf::uint8* output) const;
1012  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1013  return InternalSerializeWithCachedSizesToArray(false, output);
1014  }
1015  int GetCachedSize() const { return _cached_size_; }
1016  private:
1017  void SharedCtor();
1018  void SharedDtor();
1019  void SetCachedSize(int size) const;
1020  void InternalSwap(RemoveXAttrRequestProto* other);
1021  private:
1022  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1023  return _internal_metadata_.arena();
1024  }
1025  inline void* MaybeArenaPtr() const {
1026  return _internal_metadata_.raw_arena_ptr();
1027  }
1028  public:
1029 
1030  ::google::protobuf::Metadata GetMetadata() const;
1031 
1032  // nested types ----------------------------------------------------
1033 
1034  // accessors -------------------------------------------------------
1035 
1036  // required string src = 1;
1037  bool has_src() const;
1038  void clear_src();
1039  static const int kSrcFieldNumber = 1;
1040  const ::std::string& src() const;
1041  void set_src(const ::std::string& value);
1042  void set_src(const char* value);
1043  void set_src(const char* value, size_t size);
1044  ::std::string* mutable_src();
1045  ::std::string* release_src();
1046  void set_allocated_src(::std::string* src);
1047 
1048  // optional .hadoop.hdfs.XAttrProto xAttr = 2;
1049  bool has_xattr() const;
1050  void clear_xattr();
1051  static const int kXAttrFieldNumber = 2;
1052  const ::hadoop::hdfs::XAttrProto& xattr() const;
1053  ::hadoop::hdfs::XAttrProto* mutable_xattr();
1054  ::hadoop::hdfs::XAttrProto* release_xattr();
1055  void set_allocated_xattr(::hadoop::hdfs::XAttrProto* xattr);
1056 
1057  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoveXAttrRequestProto)
1058  private:
1059  inline void set_has_src();
1060  inline void clear_has_src();
1061  inline void set_has_xattr();
1062  inline void clear_has_xattr();
1063 
1064  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1065  ::google::protobuf::uint32 _has_bits_[1];
1066  mutable int _cached_size_;
1067  ::google::protobuf::internal::ArenaStringPtr src_;
1068  ::hadoop::hdfs::XAttrProto* xattr_;
1069  friend void protobuf_AddDesc_xattr_2eproto();
1070  friend void protobuf_AssignDesc_xattr_2eproto();
1071  friend void protobuf_ShutdownFile_xattr_2eproto();
1072 
1073  void InitAsDefaultInstance();
1074  static RemoveXAttrRequestProto* default_instance_;
1075 };
1076 // -------------------------------------------------------------------
1077 
1078 class RemoveXAttrResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoveXAttrResponseProto) */ {
1079  public:
1080  RemoveXAttrResponseProto();
1081  virtual ~RemoveXAttrResponseProto();
1082 
1083  RemoveXAttrResponseProto(const RemoveXAttrResponseProto& from);
1084 
1085  inline RemoveXAttrResponseProto& operator=(const RemoveXAttrResponseProto& from) {
1086  CopyFrom(from);
1087  return *this;
1088  }
1089 
1090  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1091  return _internal_metadata_.unknown_fields();
1092  }
1093 
1094  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1095  return _internal_metadata_.mutable_unknown_fields();
1096  }
1097 
1098  static const ::google::protobuf::Descriptor* descriptor();
1099  static const RemoveXAttrResponseProto& default_instance();
1100 
1101  void Swap(RemoveXAttrResponseProto* other);
1102 
1103  // implements Message ----------------------------------------------
1104 
1105  inline RemoveXAttrResponseProto* New() const { return New(NULL); }
1106 
1107  RemoveXAttrResponseProto* New(::google::protobuf::Arena* arena) const;
1108  void CopyFrom(const ::google::protobuf::Message& from);
1109  void MergeFrom(const ::google::protobuf::Message& from);
1110  void CopyFrom(const RemoveXAttrResponseProto& from);
1111  void MergeFrom(const RemoveXAttrResponseProto& from);
1112  void Clear();
1113  bool IsInitialized() const;
1114 
1115  int ByteSize() const;
1116  bool MergePartialFromCodedStream(
1117  ::google::protobuf::io::CodedInputStream* input);
1118  void SerializeWithCachedSizes(
1119  ::google::protobuf::io::CodedOutputStream* output) const;
1120  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1121  bool deterministic, ::google::protobuf::uint8* output) const;
1122  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1123  return InternalSerializeWithCachedSizesToArray(false, output);
1124  }
1125  int GetCachedSize() const { return _cached_size_; }
1126  private:
1127  void SharedCtor();
1128  void SharedDtor();
1129  void SetCachedSize(int size) const;
1130  void InternalSwap(RemoveXAttrResponseProto* other);
1131  private:
1132  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1133  return _internal_metadata_.arena();
1134  }
1135  inline void* MaybeArenaPtr() const {
1136  return _internal_metadata_.raw_arena_ptr();
1137  }
1138  public:
1139 
1140  ::google::protobuf::Metadata GetMetadata() const;
1141 
1142  // nested types ----------------------------------------------------
1143 
1144  // accessors -------------------------------------------------------
1145 
1146  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoveXAttrResponseProto)
1147  private:
1148 
1149  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1150  ::google::protobuf::uint32 _has_bits_[1];
1151  mutable int _cached_size_;
1152  friend void protobuf_AddDesc_xattr_2eproto();
1153  friend void protobuf_AssignDesc_xattr_2eproto();
1154  friend void protobuf_ShutdownFile_xattr_2eproto();
1155 
1156  void InitAsDefaultInstance();
1157  static RemoveXAttrResponseProto* default_instance_;
1158 };
1159 // ===================================================================
1160 
1161 
1162 // ===================================================================
1163 
1164 #if !PROTOBUF_INLINE_NOT_IN_HEADERS
1165 // XAttrProto
1166 
1167 // required .hadoop.hdfs.XAttrProto.XAttrNamespaceProto namespace = 1;
1168 inline bool XAttrProto::has_namespace_() const {
1169  return (_has_bits_[0] & 0x00000001u) != 0;
1170 }
1171 inline void XAttrProto::set_has_namespace_() {
1172  _has_bits_[0] |= 0x00000001u;
1173 }
1174 inline void XAttrProto::clear_has_namespace_() {
1175  _has_bits_[0] &= ~0x00000001u;
1176 }
1177 inline void XAttrProto::clear_namespace_() {
1178  namespace__ = 0;
1179  clear_has_namespace_();
1180 }
1181 inline ::hadoop::hdfs::XAttrProto_XAttrNamespaceProto XAttrProto::namespace_() const {
1182  // @@protoc_insertion_point(field_get:hadoop.hdfs.XAttrProto.namespace)
1183  return static_cast< ::hadoop::hdfs::XAttrProto_XAttrNamespaceProto >(namespace__);
1184 }
1185 inline void XAttrProto::set_namespace_(::hadoop::hdfs::XAttrProto_XAttrNamespaceProto value) {
1186  assert(::hadoop::hdfs::XAttrProto_XAttrNamespaceProto_IsValid(value));
1187  set_has_namespace_();
1188  namespace__ = value;
1189  // @@protoc_insertion_point(field_set:hadoop.hdfs.XAttrProto.namespace)
1190 }
1191 
1192 // required string name = 2;
1193 inline bool XAttrProto::has_name() const {
1194  return (_has_bits_[0] & 0x00000002u) != 0;
1195 }
1196 inline void XAttrProto::set_has_name() {
1197  _has_bits_[0] |= 0x00000002u;
1198 }
1199 inline void XAttrProto::clear_has_name() {
1200  _has_bits_[0] &= ~0x00000002u;
1201 }
1202 inline void XAttrProto::clear_name() {
1203  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1204  clear_has_name();
1205 }
1206 inline const ::std::string& XAttrProto::name() const {
1207  // @@protoc_insertion_point(field_get:hadoop.hdfs.XAttrProto.name)
1208  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1209 }
1210 inline void XAttrProto::set_name(const ::std::string& value) {
1211  set_has_name();
1212  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1213  // @@protoc_insertion_point(field_set:hadoop.hdfs.XAttrProto.name)
1214 }
1215 inline void XAttrProto::set_name(const char* value) {
1216  set_has_name();
1217  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1218  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.XAttrProto.name)
1219 }
1220 inline void XAttrProto::set_name(const char* value, size_t size) {
1221  set_has_name();
1222  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1223  ::std::string(reinterpret_cast<const char*>(value), size));
1224  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.XAttrProto.name)
1225 }
1226 inline ::std::string* XAttrProto::mutable_name() {
1227  set_has_name();
1228  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.XAttrProto.name)
1229  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1230 }
1231 inline ::std::string* XAttrProto::release_name() {
1232  // @@protoc_insertion_point(field_release:hadoop.hdfs.XAttrProto.name)
1233  clear_has_name();
1234  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1235 }
1236 inline void XAttrProto::set_allocated_name(::std::string* name) {
1237  if (name != NULL) {
1238  set_has_name();
1239  } else {
1240  clear_has_name();
1241  }
1242  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
1243  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.XAttrProto.name)
1244 }
1245 
1246 // optional bytes value = 3;
1247 inline bool XAttrProto::has_value() const {
1248  return (_has_bits_[0] & 0x00000004u) != 0;
1249 }
1250 inline void XAttrProto::set_has_value() {
1251  _has_bits_[0] |= 0x00000004u;
1252 }
1253 inline void XAttrProto::clear_has_value() {
1254  _has_bits_[0] &= ~0x00000004u;
1255 }
1256 inline void XAttrProto::clear_value() {
1257  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1258  clear_has_value();
1259 }
1260 inline const ::std::string& XAttrProto::value() const {
1261  // @@protoc_insertion_point(field_get:hadoop.hdfs.XAttrProto.value)
1262  return value_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1263 }
1264 inline void XAttrProto::set_value(const ::std::string& value) {
1265  set_has_value();
1266  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1267  // @@protoc_insertion_point(field_set:hadoop.hdfs.XAttrProto.value)
1268 }
1269 inline void XAttrProto::set_value(const char* value) {
1270  set_has_value();
1271  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1272  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.XAttrProto.value)
1273 }
1274 inline void XAttrProto::set_value(const void* value, size_t size) {
1275  set_has_value();
1276  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1277  ::std::string(reinterpret_cast<const char*>(value), size));
1278  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.XAttrProto.value)
1279 }
1280 inline ::std::string* XAttrProto::mutable_value() {
1281  set_has_value();
1282  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.XAttrProto.value)
1283  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1284 }
1285 inline ::std::string* XAttrProto::release_value() {
1286  // @@protoc_insertion_point(field_release:hadoop.hdfs.XAttrProto.value)
1287  clear_has_value();
1288  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1289 }
1290 inline void XAttrProto::set_allocated_value(::std::string* value) {
1291  if (value != NULL) {
1292  set_has_value();
1293  } else {
1294  clear_has_value();
1295  }
1296  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1297  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.XAttrProto.value)
1298 }
1299 
1300 // -------------------------------------------------------------------
1301 
1302 // XAttrEditLogProto
1303 
1304 // optional string src = 1;
1305 inline bool XAttrEditLogProto::has_src() const {
1306  return (_has_bits_[0] & 0x00000001u) != 0;
1307 }
1308 inline void XAttrEditLogProto::set_has_src() {
1309  _has_bits_[0] |= 0x00000001u;
1310 }
1311 inline void XAttrEditLogProto::clear_has_src() {
1312  _has_bits_[0] &= ~0x00000001u;
1313 }
1314 inline void XAttrEditLogProto::clear_src() {
1315  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1316  clear_has_src();
1317 }
1318 inline const ::std::string& XAttrEditLogProto::src() const {
1319  // @@protoc_insertion_point(field_get:hadoop.hdfs.XAttrEditLogProto.src)
1320  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1321 }
1322 inline void XAttrEditLogProto::set_src(const ::std::string& value) {
1323  set_has_src();
1324  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1325  // @@protoc_insertion_point(field_set:hadoop.hdfs.XAttrEditLogProto.src)
1326 }
1327 inline void XAttrEditLogProto::set_src(const char* value) {
1328  set_has_src();
1329  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1330  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.XAttrEditLogProto.src)
1331 }
1332 inline void XAttrEditLogProto::set_src(const char* value, size_t size) {
1333  set_has_src();
1334  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1335  ::std::string(reinterpret_cast<const char*>(value), size));
1336  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.XAttrEditLogProto.src)
1337 }
1338 inline ::std::string* XAttrEditLogProto::mutable_src() {
1339  set_has_src();
1340  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.XAttrEditLogProto.src)
1341  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1342 }
1343 inline ::std::string* XAttrEditLogProto::release_src() {
1344  // @@protoc_insertion_point(field_release:hadoop.hdfs.XAttrEditLogProto.src)
1345  clear_has_src();
1346  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1347 }
1348 inline void XAttrEditLogProto::set_allocated_src(::std::string* src) {
1349  if (src != NULL) {
1350  set_has_src();
1351  } else {
1352  clear_has_src();
1353  }
1354  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
1355  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.XAttrEditLogProto.src)
1356 }
1357 
1358 // repeated .hadoop.hdfs.XAttrProto xAttrs = 2;
1359 inline int XAttrEditLogProto::xattrs_size() const {
1360  return xattrs_.size();
1361 }
1362 inline void XAttrEditLogProto::clear_xattrs() {
1363  xattrs_.Clear();
1364 }
1365 inline const ::hadoop::hdfs::XAttrProto& XAttrEditLogProto::xattrs(int index) const {
1366  // @@protoc_insertion_point(field_get:hadoop.hdfs.XAttrEditLogProto.xAttrs)
1367  return xattrs_.Get(index);
1368 }
1369 inline ::hadoop::hdfs::XAttrProto* XAttrEditLogProto::mutable_xattrs(int index) {
1370  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.XAttrEditLogProto.xAttrs)
1371  return xattrs_.Mutable(index);
1372 }
1373 inline ::hadoop::hdfs::XAttrProto* XAttrEditLogProto::add_xattrs() {
1374  // @@protoc_insertion_point(field_add:hadoop.hdfs.XAttrEditLogProto.xAttrs)
1375  return xattrs_.Add();
1376 }
1377 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >*
1378 XAttrEditLogProto::mutable_xattrs() {
1379  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.XAttrEditLogProto.xAttrs)
1380  return &xattrs_;
1381 }
1382 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >&
1383 XAttrEditLogProto::xattrs() const {
1384  // @@protoc_insertion_point(field_list:hadoop.hdfs.XAttrEditLogProto.xAttrs)
1385  return xattrs_;
1386 }
1387 
1388 // -------------------------------------------------------------------
1389 
1390 // SetXAttrRequestProto
1391 
1392 // required string src = 1;
1393 inline bool SetXAttrRequestProto::has_src() const {
1394  return (_has_bits_[0] & 0x00000001u) != 0;
1395 }
1396 inline void SetXAttrRequestProto::set_has_src() {
1397  _has_bits_[0] |= 0x00000001u;
1398 }
1399 inline void SetXAttrRequestProto::clear_has_src() {
1400  _has_bits_[0] &= ~0x00000001u;
1401 }
1402 inline void SetXAttrRequestProto::clear_src() {
1403  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1404  clear_has_src();
1405 }
1406 inline const ::std::string& SetXAttrRequestProto::src() const {
1407  // @@protoc_insertion_point(field_get:hadoop.hdfs.SetXAttrRequestProto.src)
1408  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1409 }
1410 inline void SetXAttrRequestProto::set_src(const ::std::string& value) {
1411  set_has_src();
1412  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1413  // @@protoc_insertion_point(field_set:hadoop.hdfs.SetXAttrRequestProto.src)
1414 }
1415 inline void SetXAttrRequestProto::set_src(const char* value) {
1416  set_has_src();
1417  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1418  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SetXAttrRequestProto.src)
1419 }
1420 inline void SetXAttrRequestProto::set_src(const char* value, size_t size) {
1421  set_has_src();
1422  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1423  ::std::string(reinterpret_cast<const char*>(value), size));
1424  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SetXAttrRequestProto.src)
1425 }
1426 inline ::std::string* SetXAttrRequestProto::mutable_src() {
1427  set_has_src();
1428  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SetXAttrRequestProto.src)
1429  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1430 }
1431 inline ::std::string* SetXAttrRequestProto::release_src() {
1432  // @@protoc_insertion_point(field_release:hadoop.hdfs.SetXAttrRequestProto.src)
1433  clear_has_src();
1434  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1435 }
1436 inline void SetXAttrRequestProto::set_allocated_src(::std::string* src) {
1437  if (src != NULL) {
1438  set_has_src();
1439  } else {
1440  clear_has_src();
1441  }
1442  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
1443  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SetXAttrRequestProto.src)
1444 }
1445 
1446 // optional .hadoop.hdfs.XAttrProto xAttr = 2;
1447 inline bool SetXAttrRequestProto::has_xattr() const {
1448  return (_has_bits_[0] & 0x00000002u) != 0;
1449 }
1450 inline void SetXAttrRequestProto::set_has_xattr() {
1451  _has_bits_[0] |= 0x00000002u;
1452 }
1453 inline void SetXAttrRequestProto::clear_has_xattr() {
1454  _has_bits_[0] &= ~0x00000002u;
1455 }
1456 inline void SetXAttrRequestProto::clear_xattr() {
1457  if (xattr_ != NULL) xattr_->::hadoop::hdfs::XAttrProto::Clear();
1458  clear_has_xattr();
1459 }
1460 inline const ::hadoop::hdfs::XAttrProto& SetXAttrRequestProto::xattr() const {
1461  // @@protoc_insertion_point(field_get:hadoop.hdfs.SetXAttrRequestProto.xAttr)
1462  return xattr_ != NULL ? *xattr_ : *default_instance_->xattr_;
1463 }
1464 inline ::hadoop::hdfs::XAttrProto* SetXAttrRequestProto::mutable_xattr() {
1465  set_has_xattr();
1466  if (xattr_ == NULL) {
1467  xattr_ = new ::hadoop::hdfs::XAttrProto;
1468  }
1469  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SetXAttrRequestProto.xAttr)
1470  return xattr_;
1471 }
1472 inline ::hadoop::hdfs::XAttrProto* SetXAttrRequestProto::release_xattr() {
1473  // @@protoc_insertion_point(field_release:hadoop.hdfs.SetXAttrRequestProto.xAttr)
1474  clear_has_xattr();
1475  ::hadoop::hdfs::XAttrProto* temp = xattr_;
1476  xattr_ = NULL;
1477  return temp;
1478 }
1479 inline void SetXAttrRequestProto::set_allocated_xattr(::hadoop::hdfs::XAttrProto* xattr) {
1480  delete xattr_;
1481  xattr_ = xattr;
1482  if (xattr) {
1483  set_has_xattr();
1484  } else {
1485  clear_has_xattr();
1486  }
1487  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SetXAttrRequestProto.xAttr)
1488 }
1489 
1490 // optional uint32 flag = 3;
1491 inline bool SetXAttrRequestProto::has_flag() const {
1492  return (_has_bits_[0] & 0x00000004u) != 0;
1493 }
1494 inline void SetXAttrRequestProto::set_has_flag() {
1495  _has_bits_[0] |= 0x00000004u;
1496 }
1497 inline void SetXAttrRequestProto::clear_has_flag() {
1498  _has_bits_[0] &= ~0x00000004u;
1499 }
1500 inline void SetXAttrRequestProto::clear_flag() {
1501  flag_ = 0u;
1502  clear_has_flag();
1503 }
1504 inline ::google::protobuf::uint32 SetXAttrRequestProto::flag() const {
1505  // @@protoc_insertion_point(field_get:hadoop.hdfs.SetXAttrRequestProto.flag)
1506  return flag_;
1507 }
1508 inline void SetXAttrRequestProto::set_flag(::google::protobuf::uint32 value) {
1509  set_has_flag();
1510  flag_ = value;
1511  // @@protoc_insertion_point(field_set:hadoop.hdfs.SetXAttrRequestProto.flag)
1512 }
1513 
1514 // -------------------------------------------------------------------
1515 
1516 // SetXAttrResponseProto
1517 
1518 // -------------------------------------------------------------------
1519 
1520 // GetXAttrsRequestProto
1521 
1522 // required string src = 1;
1523 inline bool GetXAttrsRequestProto::has_src() const {
1524  return (_has_bits_[0] & 0x00000001u) != 0;
1525 }
1526 inline void GetXAttrsRequestProto::set_has_src() {
1527  _has_bits_[0] |= 0x00000001u;
1528 }
1529 inline void GetXAttrsRequestProto::clear_has_src() {
1530  _has_bits_[0] &= ~0x00000001u;
1531 }
1532 inline void GetXAttrsRequestProto::clear_src() {
1533  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1534  clear_has_src();
1535 }
1536 inline const ::std::string& GetXAttrsRequestProto::src() const {
1537  // @@protoc_insertion_point(field_get:hadoop.hdfs.GetXAttrsRequestProto.src)
1538  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1539 }
1540 inline void GetXAttrsRequestProto::set_src(const ::std::string& value) {
1541  set_has_src();
1542  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1543  // @@protoc_insertion_point(field_set:hadoop.hdfs.GetXAttrsRequestProto.src)
1544 }
1545 inline void GetXAttrsRequestProto::set_src(const char* value) {
1546  set_has_src();
1547  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1548  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.GetXAttrsRequestProto.src)
1549 }
1550 inline void GetXAttrsRequestProto::set_src(const char* value, size_t size) {
1551  set_has_src();
1552  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1553  ::std::string(reinterpret_cast<const char*>(value), size));
1554  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.GetXAttrsRequestProto.src)
1555 }
1556 inline ::std::string* GetXAttrsRequestProto::mutable_src() {
1557  set_has_src();
1558  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.GetXAttrsRequestProto.src)
1559  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1560 }
1561 inline ::std::string* GetXAttrsRequestProto::release_src() {
1562  // @@protoc_insertion_point(field_release:hadoop.hdfs.GetXAttrsRequestProto.src)
1563  clear_has_src();
1564  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1565 }
1566 inline void GetXAttrsRequestProto::set_allocated_src(::std::string* src) {
1567  if (src != NULL) {
1568  set_has_src();
1569  } else {
1570  clear_has_src();
1571  }
1572  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
1573  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.GetXAttrsRequestProto.src)
1574 }
1575 
1576 // repeated .hadoop.hdfs.XAttrProto xAttrs = 2;
1577 inline int GetXAttrsRequestProto::xattrs_size() const {
1578  return xattrs_.size();
1579 }
1580 inline void GetXAttrsRequestProto::clear_xattrs() {
1581  xattrs_.Clear();
1582 }
1583 inline const ::hadoop::hdfs::XAttrProto& GetXAttrsRequestProto::xattrs(int index) const {
1584  // @@protoc_insertion_point(field_get:hadoop.hdfs.GetXAttrsRequestProto.xAttrs)
1585  return xattrs_.Get(index);
1586 }
1587 inline ::hadoop::hdfs::XAttrProto* GetXAttrsRequestProto::mutable_xattrs(int index) {
1588  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.GetXAttrsRequestProto.xAttrs)
1589  return xattrs_.Mutable(index);
1590 }
1591 inline ::hadoop::hdfs::XAttrProto* GetXAttrsRequestProto::add_xattrs() {
1592  // @@protoc_insertion_point(field_add:hadoop.hdfs.GetXAttrsRequestProto.xAttrs)
1593  return xattrs_.Add();
1594 }
1595 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >*
1596 GetXAttrsRequestProto::mutable_xattrs() {
1597  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.GetXAttrsRequestProto.xAttrs)
1598  return &xattrs_;
1599 }
1600 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >&
1601 GetXAttrsRequestProto::xattrs() const {
1602  // @@protoc_insertion_point(field_list:hadoop.hdfs.GetXAttrsRequestProto.xAttrs)
1603  return xattrs_;
1604 }
1605 
1606 // -------------------------------------------------------------------
1607 
1608 // GetXAttrsResponseProto
1609 
1610 // repeated .hadoop.hdfs.XAttrProto xAttrs = 1;
1611 inline int GetXAttrsResponseProto::xattrs_size() const {
1612  return xattrs_.size();
1613 }
1614 inline void GetXAttrsResponseProto::clear_xattrs() {
1615  xattrs_.Clear();
1616 }
1617 inline const ::hadoop::hdfs::XAttrProto& GetXAttrsResponseProto::xattrs(int index) const {
1618  // @@protoc_insertion_point(field_get:hadoop.hdfs.GetXAttrsResponseProto.xAttrs)
1619  return xattrs_.Get(index);
1620 }
1621 inline ::hadoop::hdfs::XAttrProto* GetXAttrsResponseProto::mutable_xattrs(int index) {
1622  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.GetXAttrsResponseProto.xAttrs)
1623  return xattrs_.Mutable(index);
1624 }
1625 inline ::hadoop::hdfs::XAttrProto* GetXAttrsResponseProto::add_xattrs() {
1626  // @@protoc_insertion_point(field_add:hadoop.hdfs.GetXAttrsResponseProto.xAttrs)
1627  return xattrs_.Add();
1628 }
1629 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >*
1630 GetXAttrsResponseProto::mutable_xattrs() {
1631  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.GetXAttrsResponseProto.xAttrs)
1632  return &xattrs_;
1633 }
1634 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >&
1635 GetXAttrsResponseProto::xattrs() const {
1636  // @@protoc_insertion_point(field_list:hadoop.hdfs.GetXAttrsResponseProto.xAttrs)
1637  return xattrs_;
1638 }
1639 
1640 // -------------------------------------------------------------------
1641 
1642 // ListXAttrsRequestProto
1643 
1644 // required string src = 1;
1645 inline bool ListXAttrsRequestProto::has_src() const {
1646  return (_has_bits_[0] & 0x00000001u) != 0;
1647 }
1648 inline void ListXAttrsRequestProto::set_has_src() {
1649  _has_bits_[0] |= 0x00000001u;
1650 }
1651 inline void ListXAttrsRequestProto::clear_has_src() {
1652  _has_bits_[0] &= ~0x00000001u;
1653 }
1654 inline void ListXAttrsRequestProto::clear_src() {
1655  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1656  clear_has_src();
1657 }
1658 inline const ::std::string& ListXAttrsRequestProto::src() const {
1659  // @@protoc_insertion_point(field_get:hadoop.hdfs.ListXAttrsRequestProto.src)
1660  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1661 }
1662 inline void ListXAttrsRequestProto::set_src(const ::std::string& value) {
1663  set_has_src();
1664  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1665  // @@protoc_insertion_point(field_set:hadoop.hdfs.ListXAttrsRequestProto.src)
1666 }
1667 inline void ListXAttrsRequestProto::set_src(const char* value) {
1668  set_has_src();
1669  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1670  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ListXAttrsRequestProto.src)
1671 }
1672 inline void ListXAttrsRequestProto::set_src(const char* value, size_t size) {
1673  set_has_src();
1674  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1675  ::std::string(reinterpret_cast<const char*>(value), size));
1676  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ListXAttrsRequestProto.src)
1677 }
1678 inline ::std::string* ListXAttrsRequestProto::mutable_src() {
1679  set_has_src();
1680  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ListXAttrsRequestProto.src)
1681  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1682 }
1683 inline ::std::string* ListXAttrsRequestProto::release_src() {
1684  // @@protoc_insertion_point(field_release:hadoop.hdfs.ListXAttrsRequestProto.src)
1685  clear_has_src();
1686  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1687 }
1688 inline void ListXAttrsRequestProto::set_allocated_src(::std::string* src) {
1689  if (src != NULL) {
1690  set_has_src();
1691  } else {
1692  clear_has_src();
1693  }
1694  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
1695  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ListXAttrsRequestProto.src)
1696 }
1697 
1698 // -------------------------------------------------------------------
1699 
1700 // ListXAttrsResponseProto
1701 
1702 // repeated .hadoop.hdfs.XAttrProto xAttrs = 1;
1703 inline int ListXAttrsResponseProto::xattrs_size() const {
1704  return xattrs_.size();
1705 }
1706 inline void ListXAttrsResponseProto::clear_xattrs() {
1707  xattrs_.Clear();
1708 }
1709 inline const ::hadoop::hdfs::XAttrProto& ListXAttrsResponseProto::xattrs(int index) const {
1710  // @@protoc_insertion_point(field_get:hadoop.hdfs.ListXAttrsResponseProto.xAttrs)
1711  return xattrs_.Get(index);
1712 }
1713 inline ::hadoop::hdfs::XAttrProto* ListXAttrsResponseProto::mutable_xattrs(int index) {
1714  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ListXAttrsResponseProto.xAttrs)
1715  return xattrs_.Mutable(index);
1716 }
1717 inline ::hadoop::hdfs::XAttrProto* ListXAttrsResponseProto::add_xattrs() {
1718  // @@protoc_insertion_point(field_add:hadoop.hdfs.ListXAttrsResponseProto.xAttrs)
1719  return xattrs_.Add();
1720 }
1721 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >*
1722 ListXAttrsResponseProto::mutable_xattrs() {
1723  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.ListXAttrsResponseProto.xAttrs)
1724  return &xattrs_;
1725 }
1726 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::XAttrProto >&
1727 ListXAttrsResponseProto::xattrs() const {
1728  // @@protoc_insertion_point(field_list:hadoop.hdfs.ListXAttrsResponseProto.xAttrs)
1729  return xattrs_;
1730 }
1731 
1732 // -------------------------------------------------------------------
1733 
1734 // RemoveXAttrRequestProto
1735 
1736 // required string src = 1;
1737 inline bool RemoveXAttrRequestProto::has_src() const {
1738  return (_has_bits_[0] & 0x00000001u) != 0;
1739 }
1740 inline void RemoveXAttrRequestProto::set_has_src() {
1741  _has_bits_[0] |= 0x00000001u;
1742 }
1743 inline void RemoveXAttrRequestProto::clear_has_src() {
1744  _has_bits_[0] &= ~0x00000001u;
1745 }
1746 inline void RemoveXAttrRequestProto::clear_src() {
1747  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1748  clear_has_src();
1749 }
1750 inline const ::std::string& RemoveXAttrRequestProto::src() const {
1751  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoveXAttrRequestProto.src)
1752  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1753 }
1754 inline void RemoveXAttrRequestProto::set_src(const ::std::string& value) {
1755  set_has_src();
1756  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1757  // @@protoc_insertion_point(field_set:hadoop.hdfs.RemoveXAttrRequestProto.src)
1758 }
1759 inline void RemoveXAttrRequestProto::set_src(const char* value) {
1760  set_has_src();
1761  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1762  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.RemoveXAttrRequestProto.src)
1763 }
1764 inline void RemoveXAttrRequestProto::set_src(const char* value, size_t size) {
1765  set_has_src();
1766  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1767  ::std::string(reinterpret_cast<const char*>(value), size));
1768  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.RemoveXAttrRequestProto.src)
1769 }
1770 inline ::std::string* RemoveXAttrRequestProto::mutable_src() {
1771  set_has_src();
1772  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RemoveXAttrRequestProto.src)
1773  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1774 }
1775 inline ::std::string* RemoveXAttrRequestProto::release_src() {
1776  // @@protoc_insertion_point(field_release:hadoop.hdfs.RemoveXAttrRequestProto.src)
1777  clear_has_src();
1778  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1779 }
1780 inline void RemoveXAttrRequestProto::set_allocated_src(::std::string* src) {
1781  if (src != NULL) {
1782  set_has_src();
1783  } else {
1784  clear_has_src();
1785  }
1786  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
1787  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.RemoveXAttrRequestProto.src)
1788 }
1789 
1790 // optional .hadoop.hdfs.XAttrProto xAttr = 2;
1791 inline bool RemoveXAttrRequestProto::has_xattr() const {
1792  return (_has_bits_[0] & 0x00000002u) != 0;
1793 }
1794 inline void RemoveXAttrRequestProto::set_has_xattr() {
1795  _has_bits_[0] |= 0x00000002u;
1796 }
1797 inline void RemoveXAttrRequestProto::clear_has_xattr() {
1798  _has_bits_[0] &= ~0x00000002u;
1799 }
1800 inline void RemoveXAttrRequestProto::clear_xattr() {
1801  if (xattr_ != NULL) xattr_->::hadoop::hdfs::XAttrProto::Clear();
1802  clear_has_xattr();
1803 }
1804 inline const ::hadoop::hdfs::XAttrProto& RemoveXAttrRequestProto::xattr() const {
1805  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoveXAttrRequestProto.xAttr)
1806  return xattr_ != NULL ? *xattr_ : *default_instance_->xattr_;
1807 }
1808 inline ::hadoop::hdfs::XAttrProto* RemoveXAttrRequestProto::mutable_xattr() {
1809  set_has_xattr();
1810  if (xattr_ == NULL) {
1811  xattr_ = new ::hadoop::hdfs::XAttrProto;
1812  }
1813  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RemoveXAttrRequestProto.xAttr)
1814  return xattr_;
1815 }
1816 inline ::hadoop::hdfs::XAttrProto* RemoveXAttrRequestProto::release_xattr() {
1817  // @@protoc_insertion_point(field_release:hadoop.hdfs.RemoveXAttrRequestProto.xAttr)
1818  clear_has_xattr();
1819  ::hadoop::hdfs::XAttrProto* temp = xattr_;
1820  xattr_ = NULL;
1821  return temp;
1822 }
1823 inline void RemoveXAttrRequestProto::set_allocated_xattr(::hadoop::hdfs::XAttrProto* xattr) {
1824  delete xattr_;
1825  xattr_ = xattr;
1826  if (xattr) {
1827  set_has_xattr();
1828  } else {
1829  clear_has_xattr();
1830  }
1831  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.RemoveXAttrRequestProto.xAttr)
1832 }
1833 
1834 // -------------------------------------------------------------------
1835 
1836 // RemoveXAttrResponseProto
1837 
1838 #endif // !PROTOBUF_INLINE_NOT_IN_HEADERS
1839 // -------------------------------------------------------------------
1840 
1841 // -------------------------------------------------------------------
1842 
1843 // -------------------------------------------------------------------
1844 
1845 // -------------------------------------------------------------------
1846 
1847 // -------------------------------------------------------------------
1848 
1849 // -------------------------------------------------------------------
1850 
1851 // -------------------------------------------------------------------
1852 
1853 // -------------------------------------------------------------------
1854 
1855 // -------------------------------------------------------------------
1856 
1857 
1858 // @@protoc_insertion_point(namespace_scope)
1859 
1860 } // namespace hdfs
1861 } // namespace hadoop
1862 
1863 #ifndef SWIG
1864 namespace google {
1865 namespace protobuf {
1866 
1867 template <> struct is_proto_enum< ::hadoop::hdfs::XAttrProto_XAttrNamespaceProto> : ::google::protobuf::internal::true_type {};
1868 template <>
1869 inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::XAttrProto_XAttrNamespaceProto>() {
1870  return ::hadoop::hdfs::XAttrProto_XAttrNamespaceProto_descriptor();
1871 }
1872 template <> struct is_proto_enum< ::hadoop::hdfs::XAttrSetFlagProto> : ::google::protobuf::internal::true_type {};
1873 template <>
1874 inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::XAttrSetFlagProto>() {
1875  return ::hadoop::hdfs::XAttrSetFlagProto_descriptor();
1876 }
1877 
1878 } // namespace protobuf
1879 } // namespace google
1880 #endif // SWIG
1881 
1882 // @@protoc_insertion_point(global_scope)
1883 
1884 #endif // PROTOBUF_xattr_2eproto__INCLUDED
hadoop::hdfs::XAttrProto
Definition: xattr.pb.h:95
hadoop::hdfs::ListXAttrsResponseProto
Definition: xattr.pb.h:872
hadoop::hdfs::XAttrEditLogProto
Definition: xattr.pb.h:253
hadoop::hdfs::GetXAttrsRequestProto
Definition: xattr.pb.h:567
hadoop::hdfs::RemoveXAttrRequestProto
Definition: xattr.pb.h:968
hadoop::hdfs::SetXAttrResponseProto
Definition: xattr.pb.h:484
hadoop::hdfs::ListXAttrsRequestProto
Definition: xattr.pb.h:774
hadoop::hdfs::GetXAttrsResponseProto
Definition: xattr.pb.h:678
hadoop::hdfs::SetXAttrRequestProto
Definition: xattr.pb.h:364
hadoop::hdfs::RemoveXAttrResponseProto
Definition: xattr.pb.h:1078
Generated by   doxygen 1.8.6