RDFS
The Rice Comp413 2017 class' continuation on the work of the 2016 RDFS.
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Pages
acl.pb.h
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: acl.proto
3 
4 #ifndef PROTOBUF_acl_2eproto__INCLUDED
5 #define PROTOBUF_acl_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 "hdfs.pb.h"
32 // @@protoc_insertion_point(includes)
33 
34 namespace hadoop {
35 namespace hdfs {
36 
37 // Internal implementation detail -- do not call these.
38 void protobuf_AddDesc_acl_2eproto();
39 void protobuf_AssignDesc_acl_2eproto();
40 void protobuf_ShutdownFile_acl_2eproto();
41 
42 class AclEditLogProto;
43 class AclEntryProto;
44 class AclStatusProto;
45 class GetAclStatusRequestProto;
46 class GetAclStatusResponseProto;
47 class ModifyAclEntriesRequestProto;
48 class ModifyAclEntriesResponseProto;
49 class RemoveAclEntriesRequestProto;
50 class RemoveAclEntriesResponseProto;
51 class RemoveAclRequestProto;
52 class RemoveAclResponseProto;
53 class RemoveDefaultAclRequestProto;
54 class RemoveDefaultAclResponseProto;
55 class SetAclRequestProto;
56 class SetAclResponseProto;
57 
58 enum AclEntryProto_AclEntryScopeProto {
59  AclEntryProto_AclEntryScopeProto_ACCESS = 0,
60  AclEntryProto_AclEntryScopeProto_DEFAULT = 1
61 };
62 bool AclEntryProto_AclEntryScopeProto_IsValid(int value);
63 const AclEntryProto_AclEntryScopeProto AclEntryProto_AclEntryScopeProto_AclEntryScopeProto_MIN = AclEntryProto_AclEntryScopeProto_ACCESS;
64 const AclEntryProto_AclEntryScopeProto AclEntryProto_AclEntryScopeProto_AclEntryScopeProto_MAX = AclEntryProto_AclEntryScopeProto_DEFAULT;
65 const int AclEntryProto_AclEntryScopeProto_AclEntryScopeProto_ARRAYSIZE = AclEntryProto_AclEntryScopeProto_AclEntryScopeProto_MAX + 1;
66 
67 const ::google::protobuf::EnumDescriptor* AclEntryProto_AclEntryScopeProto_descriptor();
68 inline const ::std::string& AclEntryProto_AclEntryScopeProto_Name(AclEntryProto_AclEntryScopeProto value) {
69  return ::google::protobuf::internal::NameOfEnum(
70  AclEntryProto_AclEntryScopeProto_descriptor(), value);
71 }
72 inline bool AclEntryProto_AclEntryScopeProto_Parse(
73  const ::std::string& name, AclEntryProto_AclEntryScopeProto* value) {
74  return ::google::protobuf::internal::ParseNamedEnum<AclEntryProto_AclEntryScopeProto>(
75  AclEntryProto_AclEntryScopeProto_descriptor(), name, value);
76 }
77 enum AclEntryProto_AclEntryTypeProto {
78  AclEntryProto_AclEntryTypeProto_USER = 0,
79  AclEntryProto_AclEntryTypeProto_GROUP = 1,
80  AclEntryProto_AclEntryTypeProto_MASK = 2,
81  AclEntryProto_AclEntryTypeProto_OTHER = 3
82 };
83 bool AclEntryProto_AclEntryTypeProto_IsValid(int value);
84 const AclEntryProto_AclEntryTypeProto AclEntryProto_AclEntryTypeProto_AclEntryTypeProto_MIN = AclEntryProto_AclEntryTypeProto_USER;
85 const AclEntryProto_AclEntryTypeProto AclEntryProto_AclEntryTypeProto_AclEntryTypeProto_MAX = AclEntryProto_AclEntryTypeProto_OTHER;
86 const int AclEntryProto_AclEntryTypeProto_AclEntryTypeProto_ARRAYSIZE = AclEntryProto_AclEntryTypeProto_AclEntryTypeProto_MAX + 1;
87 
88 const ::google::protobuf::EnumDescriptor* AclEntryProto_AclEntryTypeProto_descriptor();
89 inline const ::std::string& AclEntryProto_AclEntryTypeProto_Name(AclEntryProto_AclEntryTypeProto value) {
90  return ::google::protobuf::internal::NameOfEnum(
91  AclEntryProto_AclEntryTypeProto_descriptor(), value);
92 }
93 inline bool AclEntryProto_AclEntryTypeProto_Parse(
94  const ::std::string& name, AclEntryProto_AclEntryTypeProto* value) {
95  return ::google::protobuf::internal::ParseNamedEnum<AclEntryProto_AclEntryTypeProto>(
96  AclEntryProto_AclEntryTypeProto_descriptor(), name, value);
97 }
98 enum AclEntryProto_FsActionProto {
99  AclEntryProto_FsActionProto_NONE = 0,
100  AclEntryProto_FsActionProto_EXECUTE = 1,
101  AclEntryProto_FsActionProto_WRITE = 2,
102  AclEntryProto_FsActionProto_WRITE_EXECUTE = 3,
103  AclEntryProto_FsActionProto_READ = 4,
104  AclEntryProto_FsActionProto_READ_EXECUTE = 5,
105  AclEntryProto_FsActionProto_READ_WRITE = 6,
106  AclEntryProto_FsActionProto_PERM_ALL = 7
107 };
108 bool AclEntryProto_FsActionProto_IsValid(int value);
109 const AclEntryProto_FsActionProto AclEntryProto_FsActionProto_FsActionProto_MIN = AclEntryProto_FsActionProto_NONE;
110 const AclEntryProto_FsActionProto AclEntryProto_FsActionProto_FsActionProto_MAX = AclEntryProto_FsActionProto_PERM_ALL;
111 const int AclEntryProto_FsActionProto_FsActionProto_ARRAYSIZE = AclEntryProto_FsActionProto_FsActionProto_MAX + 1;
112 
113 const ::google::protobuf::EnumDescriptor* AclEntryProto_FsActionProto_descriptor();
114 inline const ::std::string& AclEntryProto_FsActionProto_Name(AclEntryProto_FsActionProto value) {
115  return ::google::protobuf::internal::NameOfEnum(
116  AclEntryProto_FsActionProto_descriptor(), value);
117 }
118 inline bool AclEntryProto_FsActionProto_Parse(
119  const ::std::string& name, AclEntryProto_FsActionProto* value) {
120  return ::google::protobuf::internal::ParseNamedEnum<AclEntryProto_FsActionProto>(
121  AclEntryProto_FsActionProto_descriptor(), name, value);
122 }
123 // ===================================================================
124 
125 class AclEntryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.AclEntryProto) */ {
126  public:
127  AclEntryProto();
128  virtual ~AclEntryProto();
129 
130  AclEntryProto(const AclEntryProto& from);
131 
132  inline AclEntryProto& operator=(const AclEntryProto& from) {
133  CopyFrom(from);
134  return *this;
135  }
136 
137  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
138  return _internal_metadata_.unknown_fields();
139  }
140 
141  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
142  return _internal_metadata_.mutable_unknown_fields();
143  }
144 
145  static const ::google::protobuf::Descriptor* descriptor();
146  static const AclEntryProto& default_instance();
147 
148  void Swap(AclEntryProto* other);
149 
150  // implements Message ----------------------------------------------
151 
152  inline AclEntryProto* New() const { return New(NULL); }
153 
154  AclEntryProto* New(::google::protobuf::Arena* arena) const;
155  void CopyFrom(const ::google::protobuf::Message& from);
156  void MergeFrom(const ::google::protobuf::Message& from);
157  void CopyFrom(const AclEntryProto& from);
158  void MergeFrom(const AclEntryProto& from);
159  void Clear();
160  bool IsInitialized() const;
161 
162  int ByteSize() const;
163  bool MergePartialFromCodedStream(
164  ::google::protobuf::io::CodedInputStream* input);
165  void SerializeWithCachedSizes(
166  ::google::protobuf::io::CodedOutputStream* output) const;
167  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
168  bool deterministic, ::google::protobuf::uint8* output) const;
169  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
170  return InternalSerializeWithCachedSizesToArray(false, output);
171  }
172  int GetCachedSize() const { return _cached_size_; }
173  private:
174  void SharedCtor();
175  void SharedDtor();
176  void SetCachedSize(int size) const;
177  void InternalSwap(AclEntryProto* other);
178  private:
179  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
180  return _internal_metadata_.arena();
181  }
182  inline void* MaybeArenaPtr() const {
183  return _internal_metadata_.raw_arena_ptr();
184  }
185  public:
186 
187  ::google::protobuf::Metadata GetMetadata() const;
188 
189  // nested types ----------------------------------------------------
190 
191  typedef AclEntryProto_AclEntryScopeProto AclEntryScopeProto;
192  static const AclEntryScopeProto ACCESS =
193  AclEntryProto_AclEntryScopeProto_ACCESS;
194  static const AclEntryScopeProto DEFAULT =
195  AclEntryProto_AclEntryScopeProto_DEFAULT;
196  static inline bool AclEntryScopeProto_IsValid(int value) {
197  return AclEntryProto_AclEntryScopeProto_IsValid(value);
198  }
199  static const AclEntryScopeProto AclEntryScopeProto_MIN =
200  AclEntryProto_AclEntryScopeProto_AclEntryScopeProto_MIN;
201  static const AclEntryScopeProto AclEntryScopeProto_MAX =
202  AclEntryProto_AclEntryScopeProto_AclEntryScopeProto_MAX;
203  static const int AclEntryScopeProto_ARRAYSIZE =
204  AclEntryProto_AclEntryScopeProto_AclEntryScopeProto_ARRAYSIZE;
205  static inline const ::google::protobuf::EnumDescriptor*
206  AclEntryScopeProto_descriptor() {
207  return AclEntryProto_AclEntryScopeProto_descriptor();
208  }
209  static inline const ::std::string& AclEntryScopeProto_Name(AclEntryScopeProto value) {
210  return AclEntryProto_AclEntryScopeProto_Name(value);
211  }
212  static inline bool AclEntryScopeProto_Parse(const ::std::string& name,
213  AclEntryScopeProto* value) {
214  return AclEntryProto_AclEntryScopeProto_Parse(name, value);
215  }
216 
217  typedef AclEntryProto_AclEntryTypeProto AclEntryTypeProto;
218  static const AclEntryTypeProto USER =
219  AclEntryProto_AclEntryTypeProto_USER;
220  static const AclEntryTypeProto GROUP =
221  AclEntryProto_AclEntryTypeProto_GROUP;
222  static const AclEntryTypeProto MASK =
223  AclEntryProto_AclEntryTypeProto_MASK;
224  static const AclEntryTypeProto OTHER =
225  AclEntryProto_AclEntryTypeProto_OTHER;
226  static inline bool AclEntryTypeProto_IsValid(int value) {
227  return AclEntryProto_AclEntryTypeProto_IsValid(value);
228  }
229  static const AclEntryTypeProto AclEntryTypeProto_MIN =
230  AclEntryProto_AclEntryTypeProto_AclEntryTypeProto_MIN;
231  static const AclEntryTypeProto AclEntryTypeProto_MAX =
232  AclEntryProto_AclEntryTypeProto_AclEntryTypeProto_MAX;
233  static const int AclEntryTypeProto_ARRAYSIZE =
234  AclEntryProto_AclEntryTypeProto_AclEntryTypeProto_ARRAYSIZE;
235  static inline const ::google::protobuf::EnumDescriptor*
236  AclEntryTypeProto_descriptor() {
237  return AclEntryProto_AclEntryTypeProto_descriptor();
238  }
239  static inline const ::std::string& AclEntryTypeProto_Name(AclEntryTypeProto value) {
240  return AclEntryProto_AclEntryTypeProto_Name(value);
241  }
242  static inline bool AclEntryTypeProto_Parse(const ::std::string& name,
243  AclEntryTypeProto* value) {
244  return AclEntryProto_AclEntryTypeProto_Parse(name, value);
245  }
246 
247  typedef AclEntryProto_FsActionProto FsActionProto;
248  static const FsActionProto NONE =
249  AclEntryProto_FsActionProto_NONE;
250  static const FsActionProto EXECUTE =
251  AclEntryProto_FsActionProto_EXECUTE;
252  static const FsActionProto WRITE =
253  AclEntryProto_FsActionProto_WRITE;
254  static const FsActionProto WRITE_EXECUTE =
255  AclEntryProto_FsActionProto_WRITE_EXECUTE;
256  static const FsActionProto READ =
257  AclEntryProto_FsActionProto_READ;
258  static const FsActionProto READ_EXECUTE =
259  AclEntryProto_FsActionProto_READ_EXECUTE;
260  static const FsActionProto READ_WRITE =
261  AclEntryProto_FsActionProto_READ_WRITE;
262  static const FsActionProto PERM_ALL =
263  AclEntryProto_FsActionProto_PERM_ALL;
264  static inline bool FsActionProto_IsValid(int value) {
265  return AclEntryProto_FsActionProto_IsValid(value);
266  }
267  static const FsActionProto FsActionProto_MIN =
268  AclEntryProto_FsActionProto_FsActionProto_MIN;
269  static const FsActionProto FsActionProto_MAX =
270  AclEntryProto_FsActionProto_FsActionProto_MAX;
271  static const int FsActionProto_ARRAYSIZE =
272  AclEntryProto_FsActionProto_FsActionProto_ARRAYSIZE;
273  static inline const ::google::protobuf::EnumDescriptor*
274  FsActionProto_descriptor() {
275  return AclEntryProto_FsActionProto_descriptor();
276  }
277  static inline const ::std::string& FsActionProto_Name(FsActionProto value) {
278  return AclEntryProto_FsActionProto_Name(value);
279  }
280  static inline bool FsActionProto_Parse(const ::std::string& name,
281  FsActionProto* value) {
282  return AclEntryProto_FsActionProto_Parse(name, value);
283  }
284 
285  // accessors -------------------------------------------------------
286 
287  // required .hadoop.hdfs.AclEntryProto.AclEntryTypeProto type = 1;
288  bool has_type() const;
289  void clear_type();
290  static const int kTypeFieldNumber = 1;
291  ::hadoop::hdfs::AclEntryProto_AclEntryTypeProto type() const;
292  void set_type(::hadoop::hdfs::AclEntryProto_AclEntryTypeProto value);
293 
294  // required .hadoop.hdfs.AclEntryProto.AclEntryScopeProto scope = 2;
295  bool has_scope() const;
296  void clear_scope();
297  static const int kScopeFieldNumber = 2;
298  ::hadoop::hdfs::AclEntryProto_AclEntryScopeProto scope() const;
299  void set_scope(::hadoop::hdfs::AclEntryProto_AclEntryScopeProto value);
300 
301  // required .hadoop.hdfs.AclEntryProto.FsActionProto permissions = 3;
302  bool has_permissions() const;
303  void clear_permissions();
304  static const int kPermissionsFieldNumber = 3;
305  ::hadoop::hdfs::AclEntryProto_FsActionProto permissions() const;
306  void set_permissions(::hadoop::hdfs::AclEntryProto_FsActionProto value);
307 
308  // optional string name = 4;
309  bool has_name() const;
310  void clear_name();
311  static const int kNameFieldNumber = 4;
312  const ::std::string& name() const;
313  void set_name(const ::std::string& value);
314  void set_name(const char* value);
315  void set_name(const char* value, size_t size);
316  ::std::string* mutable_name();
317  ::std::string* release_name();
318  void set_allocated_name(::std::string* name);
319 
320  // @@protoc_insertion_point(class_scope:hadoop.hdfs.AclEntryProto)
321  private:
322  inline void set_has_type();
323  inline void clear_has_type();
324  inline void set_has_scope();
325  inline void clear_has_scope();
326  inline void set_has_permissions();
327  inline void clear_has_permissions();
328  inline void set_has_name();
329  inline void clear_has_name();
330 
331  // helper for ByteSize()
332  int RequiredFieldsByteSizeFallback() const;
333 
334  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
335  ::google::protobuf::uint32 _has_bits_[1];
336  mutable int _cached_size_;
337  int type_;
338  int scope_;
339  ::google::protobuf::internal::ArenaStringPtr name_;
340  int permissions_;
341  friend void protobuf_AddDesc_acl_2eproto();
342  friend void protobuf_AssignDesc_acl_2eproto();
343  friend void protobuf_ShutdownFile_acl_2eproto();
344 
345  void InitAsDefaultInstance();
346  static AclEntryProto* default_instance_;
347 };
348 // -------------------------------------------------------------------
349 
350 class AclStatusProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.AclStatusProto) */ {
351  public:
352  AclStatusProto();
353  virtual ~AclStatusProto();
354 
355  AclStatusProto(const AclStatusProto& from);
356 
357  inline AclStatusProto& operator=(const AclStatusProto& from) {
358  CopyFrom(from);
359  return *this;
360  }
361 
362  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
363  return _internal_metadata_.unknown_fields();
364  }
365 
366  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
367  return _internal_metadata_.mutable_unknown_fields();
368  }
369 
370  static const ::google::protobuf::Descriptor* descriptor();
371  static const AclStatusProto& default_instance();
372 
373  void Swap(AclStatusProto* other);
374 
375  // implements Message ----------------------------------------------
376 
377  inline AclStatusProto* New() const { return New(NULL); }
378 
379  AclStatusProto* New(::google::protobuf::Arena* arena) const;
380  void CopyFrom(const ::google::protobuf::Message& from);
381  void MergeFrom(const ::google::protobuf::Message& from);
382  void CopyFrom(const AclStatusProto& from);
383  void MergeFrom(const AclStatusProto& from);
384  void Clear();
385  bool IsInitialized() const;
386 
387  int ByteSize() const;
388  bool MergePartialFromCodedStream(
389  ::google::protobuf::io::CodedInputStream* input);
390  void SerializeWithCachedSizes(
391  ::google::protobuf::io::CodedOutputStream* output) const;
392  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
393  bool deterministic, ::google::protobuf::uint8* output) const;
394  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
395  return InternalSerializeWithCachedSizesToArray(false, output);
396  }
397  int GetCachedSize() const { return _cached_size_; }
398  private:
399  void SharedCtor();
400  void SharedDtor();
401  void SetCachedSize(int size) const;
402  void InternalSwap(AclStatusProto* other);
403  private:
404  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
405  return _internal_metadata_.arena();
406  }
407  inline void* MaybeArenaPtr() const {
408  return _internal_metadata_.raw_arena_ptr();
409  }
410  public:
411 
412  ::google::protobuf::Metadata GetMetadata() const;
413 
414  // nested types ----------------------------------------------------
415 
416  // accessors -------------------------------------------------------
417 
418  // required string owner = 1;
419  bool has_owner() const;
420  void clear_owner();
421  static const int kOwnerFieldNumber = 1;
422  const ::std::string& owner() const;
423  void set_owner(const ::std::string& value);
424  void set_owner(const char* value);
425  void set_owner(const char* value, size_t size);
426  ::std::string* mutable_owner();
427  ::std::string* release_owner();
428  void set_allocated_owner(::std::string* owner);
429 
430  // required string group = 2;
431  bool has_group() const;
432  void clear_group();
433  static const int kGroupFieldNumber = 2;
434  const ::std::string& group() const;
435  void set_group(const ::std::string& value);
436  void set_group(const char* value);
437  void set_group(const char* value, size_t size);
438  ::std::string* mutable_group();
439  ::std::string* release_group();
440  void set_allocated_group(::std::string* group);
441 
442  // required bool sticky = 3;
443  bool has_sticky() const;
444  void clear_sticky();
445  static const int kStickyFieldNumber = 3;
446  bool sticky() const;
447  void set_sticky(bool value);
448 
449  // repeated .hadoop.hdfs.AclEntryProto entries = 4;
450  int entries_size() const;
451  void clear_entries();
452  static const int kEntriesFieldNumber = 4;
453  const ::hadoop::hdfs::AclEntryProto& entries(int index) const;
454  ::hadoop::hdfs::AclEntryProto* mutable_entries(int index);
455  ::hadoop::hdfs::AclEntryProto* add_entries();
456  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
457  mutable_entries();
458  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
459  entries() const;
460 
461  // optional .hadoop.hdfs.FsPermissionProto permission = 5;
462  bool has_permission() const;
463  void clear_permission();
464  static const int kPermissionFieldNumber = 5;
465  const ::hadoop::hdfs::FsPermissionProto& permission() const;
466  ::hadoop::hdfs::FsPermissionProto* mutable_permission();
467  ::hadoop::hdfs::FsPermissionProto* release_permission();
468  void set_allocated_permission(::hadoop::hdfs::FsPermissionProto* permission);
469 
470  // @@protoc_insertion_point(class_scope:hadoop.hdfs.AclStatusProto)
471  private:
472  inline void set_has_owner();
473  inline void clear_has_owner();
474  inline void set_has_group();
475  inline void clear_has_group();
476  inline void set_has_sticky();
477  inline void clear_has_sticky();
478  inline void set_has_permission();
479  inline void clear_has_permission();
480 
481  // helper for ByteSize()
482  int RequiredFieldsByteSizeFallback() const;
483 
484  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
485  ::google::protobuf::uint32 _has_bits_[1];
486  mutable int _cached_size_;
487  ::google::protobuf::internal::ArenaStringPtr owner_;
488  ::google::protobuf::internal::ArenaStringPtr group_;
489  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto > entries_;
490  ::hadoop::hdfs::FsPermissionProto* permission_;
491  bool sticky_;
492  friend void protobuf_AddDesc_acl_2eproto();
493  friend void protobuf_AssignDesc_acl_2eproto();
494  friend void protobuf_ShutdownFile_acl_2eproto();
495 
496  void InitAsDefaultInstance();
497  static AclStatusProto* default_instance_;
498 };
499 // -------------------------------------------------------------------
500 
501 class AclEditLogProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.AclEditLogProto) */ {
502  public:
503  AclEditLogProto();
504  virtual ~AclEditLogProto();
505 
506  AclEditLogProto(const AclEditLogProto& from);
507 
508  inline AclEditLogProto& operator=(const AclEditLogProto& from) {
509  CopyFrom(from);
510  return *this;
511  }
512 
513  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
514  return _internal_metadata_.unknown_fields();
515  }
516 
517  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
518  return _internal_metadata_.mutable_unknown_fields();
519  }
520 
521  static const ::google::protobuf::Descriptor* descriptor();
522  static const AclEditLogProto& default_instance();
523 
524  void Swap(AclEditLogProto* other);
525 
526  // implements Message ----------------------------------------------
527 
528  inline AclEditLogProto* New() const { return New(NULL); }
529 
530  AclEditLogProto* New(::google::protobuf::Arena* arena) const;
531  void CopyFrom(const ::google::protobuf::Message& from);
532  void MergeFrom(const ::google::protobuf::Message& from);
533  void CopyFrom(const AclEditLogProto& from);
534  void MergeFrom(const AclEditLogProto& from);
535  void Clear();
536  bool IsInitialized() const;
537 
538  int ByteSize() const;
539  bool MergePartialFromCodedStream(
540  ::google::protobuf::io::CodedInputStream* input);
541  void SerializeWithCachedSizes(
542  ::google::protobuf::io::CodedOutputStream* output) const;
543  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
544  bool deterministic, ::google::protobuf::uint8* output) const;
545  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
546  return InternalSerializeWithCachedSizesToArray(false, output);
547  }
548  int GetCachedSize() const { return _cached_size_; }
549  private:
550  void SharedCtor();
551  void SharedDtor();
552  void SetCachedSize(int size) const;
553  void InternalSwap(AclEditLogProto* other);
554  private:
555  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
556  return _internal_metadata_.arena();
557  }
558  inline void* MaybeArenaPtr() const {
559  return _internal_metadata_.raw_arena_ptr();
560  }
561  public:
562 
563  ::google::protobuf::Metadata GetMetadata() const;
564 
565  // nested types ----------------------------------------------------
566 
567  // accessors -------------------------------------------------------
568 
569  // required string src = 1;
570  bool has_src() const;
571  void clear_src();
572  static const int kSrcFieldNumber = 1;
573  const ::std::string& src() const;
574  void set_src(const ::std::string& value);
575  void set_src(const char* value);
576  void set_src(const char* value, size_t size);
577  ::std::string* mutable_src();
578  ::std::string* release_src();
579  void set_allocated_src(::std::string* src);
580 
581  // repeated .hadoop.hdfs.AclEntryProto entries = 2;
582  int entries_size() const;
583  void clear_entries();
584  static const int kEntriesFieldNumber = 2;
585  const ::hadoop::hdfs::AclEntryProto& entries(int index) const;
586  ::hadoop::hdfs::AclEntryProto* mutable_entries(int index);
587  ::hadoop::hdfs::AclEntryProto* add_entries();
588  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
589  mutable_entries();
590  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
591  entries() const;
592 
593  // @@protoc_insertion_point(class_scope:hadoop.hdfs.AclEditLogProto)
594  private:
595  inline void set_has_src();
596  inline void clear_has_src();
597 
598  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
599  ::google::protobuf::uint32 _has_bits_[1];
600  mutable int _cached_size_;
601  ::google::protobuf::internal::ArenaStringPtr src_;
602  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto > entries_;
603  friend void protobuf_AddDesc_acl_2eproto();
604  friend void protobuf_AssignDesc_acl_2eproto();
605  friend void protobuf_ShutdownFile_acl_2eproto();
606 
607  void InitAsDefaultInstance();
608  static AclEditLogProto* default_instance_;
609 };
610 // -------------------------------------------------------------------
611 
612 class ModifyAclEntriesRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ModifyAclEntriesRequestProto) */ {
613  public:
614  ModifyAclEntriesRequestProto();
615  virtual ~ModifyAclEntriesRequestProto();
616 
617  ModifyAclEntriesRequestProto(const ModifyAclEntriesRequestProto& from);
618 
619  inline ModifyAclEntriesRequestProto& operator=(const ModifyAclEntriesRequestProto& from) {
620  CopyFrom(from);
621  return *this;
622  }
623 
624  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
625  return _internal_metadata_.unknown_fields();
626  }
627 
628  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
629  return _internal_metadata_.mutable_unknown_fields();
630  }
631 
632  static const ::google::protobuf::Descriptor* descriptor();
633  static const ModifyAclEntriesRequestProto& default_instance();
634 
635  void Swap(ModifyAclEntriesRequestProto* other);
636 
637  // implements Message ----------------------------------------------
638 
639  inline ModifyAclEntriesRequestProto* New() const { return New(NULL); }
640 
641  ModifyAclEntriesRequestProto* New(::google::protobuf::Arena* arena) const;
642  void CopyFrom(const ::google::protobuf::Message& from);
643  void MergeFrom(const ::google::protobuf::Message& from);
644  void CopyFrom(const ModifyAclEntriesRequestProto& from);
645  void MergeFrom(const ModifyAclEntriesRequestProto& from);
646  void Clear();
647  bool IsInitialized() const;
648 
649  int ByteSize() const;
650  bool MergePartialFromCodedStream(
651  ::google::protobuf::io::CodedInputStream* input);
652  void SerializeWithCachedSizes(
653  ::google::protobuf::io::CodedOutputStream* output) const;
654  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
655  bool deterministic, ::google::protobuf::uint8* output) const;
656  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
657  return InternalSerializeWithCachedSizesToArray(false, output);
658  }
659  int GetCachedSize() const { return _cached_size_; }
660  private:
661  void SharedCtor();
662  void SharedDtor();
663  void SetCachedSize(int size) const;
664  void InternalSwap(ModifyAclEntriesRequestProto* other);
665  private:
666  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
667  return _internal_metadata_.arena();
668  }
669  inline void* MaybeArenaPtr() const {
670  return _internal_metadata_.raw_arena_ptr();
671  }
672  public:
673 
674  ::google::protobuf::Metadata GetMetadata() const;
675 
676  // nested types ----------------------------------------------------
677 
678  // accessors -------------------------------------------------------
679 
680  // required string src = 1;
681  bool has_src() const;
682  void clear_src();
683  static const int kSrcFieldNumber = 1;
684  const ::std::string& src() const;
685  void set_src(const ::std::string& value);
686  void set_src(const char* value);
687  void set_src(const char* value, size_t size);
688  ::std::string* mutable_src();
689  ::std::string* release_src();
690  void set_allocated_src(::std::string* src);
691 
692  // repeated .hadoop.hdfs.AclEntryProto aclSpec = 2;
693  int aclspec_size() const;
694  void clear_aclspec();
695  static const int kAclSpecFieldNumber = 2;
696  const ::hadoop::hdfs::AclEntryProto& aclspec(int index) const;
697  ::hadoop::hdfs::AclEntryProto* mutable_aclspec(int index);
698  ::hadoop::hdfs::AclEntryProto* add_aclspec();
699  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
700  mutable_aclspec();
701  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
702  aclspec() const;
703 
704  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ModifyAclEntriesRequestProto)
705  private:
706  inline void set_has_src();
707  inline void clear_has_src();
708 
709  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
710  ::google::protobuf::uint32 _has_bits_[1];
711  mutable int _cached_size_;
712  ::google::protobuf::internal::ArenaStringPtr src_;
713  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto > aclspec_;
714  friend void protobuf_AddDesc_acl_2eproto();
715  friend void protobuf_AssignDesc_acl_2eproto();
716  friend void protobuf_ShutdownFile_acl_2eproto();
717 
718  void InitAsDefaultInstance();
719  static ModifyAclEntriesRequestProto* default_instance_;
720 };
721 // -------------------------------------------------------------------
722 
723 class ModifyAclEntriesResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.ModifyAclEntriesResponseProto) */ {
724  public:
725  ModifyAclEntriesResponseProto();
726  virtual ~ModifyAclEntriesResponseProto();
727 
728  ModifyAclEntriesResponseProto(const ModifyAclEntriesResponseProto& from);
729 
730  inline ModifyAclEntriesResponseProto& operator=(const ModifyAclEntriesResponseProto& from) {
731  CopyFrom(from);
732  return *this;
733  }
734 
735  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
736  return _internal_metadata_.unknown_fields();
737  }
738 
739  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
740  return _internal_metadata_.mutable_unknown_fields();
741  }
742 
743  static const ::google::protobuf::Descriptor* descriptor();
744  static const ModifyAclEntriesResponseProto& default_instance();
745 
746  void Swap(ModifyAclEntriesResponseProto* other);
747 
748  // implements Message ----------------------------------------------
749 
750  inline ModifyAclEntriesResponseProto* New() const { return New(NULL); }
751 
752  ModifyAclEntriesResponseProto* New(::google::protobuf::Arena* arena) const;
753  void CopyFrom(const ::google::protobuf::Message& from);
754  void MergeFrom(const ::google::protobuf::Message& from);
755  void CopyFrom(const ModifyAclEntriesResponseProto& from);
756  void MergeFrom(const ModifyAclEntriesResponseProto& from);
757  void Clear();
758  bool IsInitialized() const;
759 
760  int ByteSize() const;
761  bool MergePartialFromCodedStream(
762  ::google::protobuf::io::CodedInputStream* input);
763  void SerializeWithCachedSizes(
764  ::google::protobuf::io::CodedOutputStream* output) const;
765  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
766  bool deterministic, ::google::protobuf::uint8* output) const;
767  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
768  return InternalSerializeWithCachedSizesToArray(false, output);
769  }
770  int GetCachedSize() const { return _cached_size_; }
771  private:
772  void SharedCtor();
773  void SharedDtor();
774  void SetCachedSize(int size) const;
775  void InternalSwap(ModifyAclEntriesResponseProto* other);
776  private:
777  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
778  return _internal_metadata_.arena();
779  }
780  inline void* MaybeArenaPtr() const {
781  return _internal_metadata_.raw_arena_ptr();
782  }
783  public:
784 
785  ::google::protobuf::Metadata GetMetadata() const;
786 
787  // nested types ----------------------------------------------------
788 
789  // accessors -------------------------------------------------------
790 
791  // @@protoc_insertion_point(class_scope:hadoop.hdfs.ModifyAclEntriesResponseProto)
792  private:
793 
794  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
795  ::google::protobuf::uint32 _has_bits_[1];
796  mutable int _cached_size_;
797  friend void protobuf_AddDesc_acl_2eproto();
798  friend void protobuf_AssignDesc_acl_2eproto();
799  friend void protobuf_ShutdownFile_acl_2eproto();
800 
801  void InitAsDefaultInstance();
802  static ModifyAclEntriesResponseProto* default_instance_;
803 };
804 // -------------------------------------------------------------------
805 
806 class RemoveAclRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoveAclRequestProto) */ {
807  public:
808  RemoveAclRequestProto();
809  virtual ~RemoveAclRequestProto();
810 
811  RemoveAclRequestProto(const RemoveAclRequestProto& from);
812 
813  inline RemoveAclRequestProto& operator=(const RemoveAclRequestProto& from) {
814  CopyFrom(from);
815  return *this;
816  }
817 
818  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
819  return _internal_metadata_.unknown_fields();
820  }
821 
822  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
823  return _internal_metadata_.mutable_unknown_fields();
824  }
825 
826  static const ::google::protobuf::Descriptor* descriptor();
827  static const RemoveAclRequestProto& default_instance();
828 
829  void Swap(RemoveAclRequestProto* other);
830 
831  // implements Message ----------------------------------------------
832 
833  inline RemoveAclRequestProto* New() const { return New(NULL); }
834 
835  RemoveAclRequestProto* New(::google::protobuf::Arena* arena) const;
836  void CopyFrom(const ::google::protobuf::Message& from);
837  void MergeFrom(const ::google::protobuf::Message& from);
838  void CopyFrom(const RemoveAclRequestProto& from);
839  void MergeFrom(const RemoveAclRequestProto& from);
840  void Clear();
841  bool IsInitialized() const;
842 
843  int ByteSize() const;
844  bool MergePartialFromCodedStream(
845  ::google::protobuf::io::CodedInputStream* input);
846  void SerializeWithCachedSizes(
847  ::google::protobuf::io::CodedOutputStream* output) const;
848  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
849  bool deterministic, ::google::protobuf::uint8* output) const;
850  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
851  return InternalSerializeWithCachedSizesToArray(false, output);
852  }
853  int GetCachedSize() const { return _cached_size_; }
854  private:
855  void SharedCtor();
856  void SharedDtor();
857  void SetCachedSize(int size) const;
858  void InternalSwap(RemoveAclRequestProto* other);
859  private:
860  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
861  return _internal_metadata_.arena();
862  }
863  inline void* MaybeArenaPtr() const {
864  return _internal_metadata_.raw_arena_ptr();
865  }
866  public:
867 
868  ::google::protobuf::Metadata GetMetadata() const;
869 
870  // nested types ----------------------------------------------------
871 
872  // accessors -------------------------------------------------------
873 
874  // required string src = 1;
875  bool has_src() const;
876  void clear_src();
877  static const int kSrcFieldNumber = 1;
878  const ::std::string& src() const;
879  void set_src(const ::std::string& value);
880  void set_src(const char* value);
881  void set_src(const char* value, size_t size);
882  ::std::string* mutable_src();
883  ::std::string* release_src();
884  void set_allocated_src(::std::string* src);
885 
886  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoveAclRequestProto)
887  private:
888  inline void set_has_src();
889  inline void clear_has_src();
890 
891  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
892  ::google::protobuf::uint32 _has_bits_[1];
893  mutable int _cached_size_;
894  ::google::protobuf::internal::ArenaStringPtr src_;
895  friend void protobuf_AddDesc_acl_2eproto();
896  friend void protobuf_AssignDesc_acl_2eproto();
897  friend void protobuf_ShutdownFile_acl_2eproto();
898 
899  void InitAsDefaultInstance();
900  static RemoveAclRequestProto* default_instance_;
901 };
902 // -------------------------------------------------------------------
903 
904 class RemoveAclResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoveAclResponseProto) */ {
905  public:
906  RemoveAclResponseProto();
907  virtual ~RemoveAclResponseProto();
908 
909  RemoveAclResponseProto(const RemoveAclResponseProto& from);
910 
911  inline RemoveAclResponseProto& operator=(const RemoveAclResponseProto& from) {
912  CopyFrom(from);
913  return *this;
914  }
915 
916  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
917  return _internal_metadata_.unknown_fields();
918  }
919 
920  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
921  return _internal_metadata_.mutable_unknown_fields();
922  }
923 
924  static const ::google::protobuf::Descriptor* descriptor();
925  static const RemoveAclResponseProto& default_instance();
926 
927  void Swap(RemoveAclResponseProto* other);
928 
929  // implements Message ----------------------------------------------
930 
931  inline RemoveAclResponseProto* New() const { return New(NULL); }
932 
933  RemoveAclResponseProto* New(::google::protobuf::Arena* arena) const;
934  void CopyFrom(const ::google::protobuf::Message& from);
935  void MergeFrom(const ::google::protobuf::Message& from);
936  void CopyFrom(const RemoveAclResponseProto& from);
937  void MergeFrom(const RemoveAclResponseProto& from);
938  void Clear();
939  bool IsInitialized() const;
940 
941  int ByteSize() const;
942  bool MergePartialFromCodedStream(
943  ::google::protobuf::io::CodedInputStream* input);
944  void SerializeWithCachedSizes(
945  ::google::protobuf::io::CodedOutputStream* output) const;
946  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
947  bool deterministic, ::google::protobuf::uint8* output) const;
948  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
949  return InternalSerializeWithCachedSizesToArray(false, output);
950  }
951  int GetCachedSize() const { return _cached_size_; }
952  private:
953  void SharedCtor();
954  void SharedDtor();
955  void SetCachedSize(int size) const;
956  void InternalSwap(RemoveAclResponseProto* other);
957  private:
958  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
959  return _internal_metadata_.arena();
960  }
961  inline void* MaybeArenaPtr() const {
962  return _internal_metadata_.raw_arena_ptr();
963  }
964  public:
965 
966  ::google::protobuf::Metadata GetMetadata() const;
967 
968  // nested types ----------------------------------------------------
969 
970  // accessors -------------------------------------------------------
971 
972  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoveAclResponseProto)
973  private:
974 
975  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
976  ::google::protobuf::uint32 _has_bits_[1];
977  mutable int _cached_size_;
978  friend void protobuf_AddDesc_acl_2eproto();
979  friend void protobuf_AssignDesc_acl_2eproto();
980  friend void protobuf_ShutdownFile_acl_2eproto();
981 
982  void InitAsDefaultInstance();
983  static RemoveAclResponseProto* default_instance_;
984 };
985 // -------------------------------------------------------------------
986 
987 class RemoveAclEntriesRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoveAclEntriesRequestProto) */ {
988  public:
989  RemoveAclEntriesRequestProto();
990  virtual ~RemoveAclEntriesRequestProto();
991 
992  RemoveAclEntriesRequestProto(const RemoveAclEntriesRequestProto& from);
993 
994  inline RemoveAclEntriesRequestProto& operator=(const RemoveAclEntriesRequestProto& from) {
995  CopyFrom(from);
996  return *this;
997  }
998 
999  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1000  return _internal_metadata_.unknown_fields();
1001  }
1002 
1003  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1004  return _internal_metadata_.mutable_unknown_fields();
1005  }
1006 
1007  static const ::google::protobuf::Descriptor* descriptor();
1008  static const RemoveAclEntriesRequestProto& default_instance();
1009 
1010  void Swap(RemoveAclEntriesRequestProto* other);
1011 
1012  // implements Message ----------------------------------------------
1013 
1014  inline RemoveAclEntriesRequestProto* New() const { return New(NULL); }
1015 
1016  RemoveAclEntriesRequestProto* New(::google::protobuf::Arena* arena) const;
1017  void CopyFrom(const ::google::protobuf::Message& from);
1018  void MergeFrom(const ::google::protobuf::Message& from);
1019  void CopyFrom(const RemoveAclEntriesRequestProto& from);
1020  void MergeFrom(const RemoveAclEntriesRequestProto& from);
1021  void Clear();
1022  bool IsInitialized() const;
1023 
1024  int ByteSize() const;
1025  bool MergePartialFromCodedStream(
1026  ::google::protobuf::io::CodedInputStream* input);
1027  void SerializeWithCachedSizes(
1028  ::google::protobuf::io::CodedOutputStream* output) const;
1029  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1030  bool deterministic, ::google::protobuf::uint8* output) const;
1031  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1032  return InternalSerializeWithCachedSizesToArray(false, output);
1033  }
1034  int GetCachedSize() const { return _cached_size_; }
1035  private:
1036  void SharedCtor();
1037  void SharedDtor();
1038  void SetCachedSize(int size) const;
1039  void InternalSwap(RemoveAclEntriesRequestProto* other);
1040  private:
1041  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1042  return _internal_metadata_.arena();
1043  }
1044  inline void* MaybeArenaPtr() const {
1045  return _internal_metadata_.raw_arena_ptr();
1046  }
1047  public:
1048 
1049  ::google::protobuf::Metadata GetMetadata() const;
1050 
1051  // nested types ----------------------------------------------------
1052 
1053  // accessors -------------------------------------------------------
1054 
1055  // required string src = 1;
1056  bool has_src() const;
1057  void clear_src();
1058  static const int kSrcFieldNumber = 1;
1059  const ::std::string& src() const;
1060  void set_src(const ::std::string& value);
1061  void set_src(const char* value);
1062  void set_src(const char* value, size_t size);
1063  ::std::string* mutable_src();
1064  ::std::string* release_src();
1065  void set_allocated_src(::std::string* src);
1066 
1067  // repeated .hadoop.hdfs.AclEntryProto aclSpec = 2;
1068  int aclspec_size() const;
1069  void clear_aclspec();
1070  static const int kAclSpecFieldNumber = 2;
1071  const ::hadoop::hdfs::AclEntryProto& aclspec(int index) const;
1072  ::hadoop::hdfs::AclEntryProto* mutable_aclspec(int index);
1073  ::hadoop::hdfs::AclEntryProto* add_aclspec();
1074  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
1075  mutable_aclspec();
1076  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
1077  aclspec() const;
1078 
1079  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoveAclEntriesRequestProto)
1080  private:
1081  inline void set_has_src();
1082  inline void clear_has_src();
1083 
1084  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1085  ::google::protobuf::uint32 _has_bits_[1];
1086  mutable int _cached_size_;
1087  ::google::protobuf::internal::ArenaStringPtr src_;
1088  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto > aclspec_;
1089  friend void protobuf_AddDesc_acl_2eproto();
1090  friend void protobuf_AssignDesc_acl_2eproto();
1091  friend void protobuf_ShutdownFile_acl_2eproto();
1092 
1093  void InitAsDefaultInstance();
1094  static RemoveAclEntriesRequestProto* default_instance_;
1095 };
1096 // -------------------------------------------------------------------
1097 
1098 class RemoveAclEntriesResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoveAclEntriesResponseProto) */ {
1099  public:
1100  RemoveAclEntriesResponseProto();
1101  virtual ~RemoveAclEntriesResponseProto();
1102 
1103  RemoveAclEntriesResponseProto(const RemoveAclEntriesResponseProto& from);
1104 
1105  inline RemoveAclEntriesResponseProto& operator=(const RemoveAclEntriesResponseProto& from) {
1106  CopyFrom(from);
1107  return *this;
1108  }
1109 
1110  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1111  return _internal_metadata_.unknown_fields();
1112  }
1113 
1114  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1115  return _internal_metadata_.mutable_unknown_fields();
1116  }
1117 
1118  static const ::google::protobuf::Descriptor* descriptor();
1119  static const RemoveAclEntriesResponseProto& default_instance();
1120 
1121  void Swap(RemoveAclEntriesResponseProto* other);
1122 
1123  // implements Message ----------------------------------------------
1124 
1125  inline RemoveAclEntriesResponseProto* New() const { return New(NULL); }
1126 
1127  RemoveAclEntriesResponseProto* New(::google::protobuf::Arena* arena) const;
1128  void CopyFrom(const ::google::protobuf::Message& from);
1129  void MergeFrom(const ::google::protobuf::Message& from);
1130  void CopyFrom(const RemoveAclEntriesResponseProto& from);
1131  void MergeFrom(const RemoveAclEntriesResponseProto& from);
1132  void Clear();
1133  bool IsInitialized() const;
1134 
1135  int ByteSize() const;
1136  bool MergePartialFromCodedStream(
1137  ::google::protobuf::io::CodedInputStream* input);
1138  void SerializeWithCachedSizes(
1139  ::google::protobuf::io::CodedOutputStream* output) const;
1140  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1141  bool deterministic, ::google::protobuf::uint8* output) const;
1142  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1143  return InternalSerializeWithCachedSizesToArray(false, output);
1144  }
1145  int GetCachedSize() const { return _cached_size_; }
1146  private:
1147  void SharedCtor();
1148  void SharedDtor();
1149  void SetCachedSize(int size) const;
1150  void InternalSwap(RemoveAclEntriesResponseProto* other);
1151  private:
1152  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1153  return _internal_metadata_.arena();
1154  }
1155  inline void* MaybeArenaPtr() const {
1156  return _internal_metadata_.raw_arena_ptr();
1157  }
1158  public:
1159 
1160  ::google::protobuf::Metadata GetMetadata() const;
1161 
1162  // nested types ----------------------------------------------------
1163 
1164  // accessors -------------------------------------------------------
1165 
1166  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoveAclEntriesResponseProto)
1167  private:
1168 
1169  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1170  ::google::protobuf::uint32 _has_bits_[1];
1171  mutable int _cached_size_;
1172  friend void protobuf_AddDesc_acl_2eproto();
1173  friend void protobuf_AssignDesc_acl_2eproto();
1174  friend void protobuf_ShutdownFile_acl_2eproto();
1175 
1176  void InitAsDefaultInstance();
1177  static RemoveAclEntriesResponseProto* default_instance_;
1178 };
1179 // -------------------------------------------------------------------
1180 
1181 class RemoveDefaultAclRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoveDefaultAclRequestProto) */ {
1182  public:
1183  RemoveDefaultAclRequestProto();
1184  virtual ~RemoveDefaultAclRequestProto();
1185 
1186  RemoveDefaultAclRequestProto(const RemoveDefaultAclRequestProto& from);
1187 
1188  inline RemoveDefaultAclRequestProto& operator=(const RemoveDefaultAclRequestProto& from) {
1189  CopyFrom(from);
1190  return *this;
1191  }
1192 
1193  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1194  return _internal_metadata_.unknown_fields();
1195  }
1196 
1197  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1198  return _internal_metadata_.mutable_unknown_fields();
1199  }
1200 
1201  static const ::google::protobuf::Descriptor* descriptor();
1202  static const RemoveDefaultAclRequestProto& default_instance();
1203 
1204  void Swap(RemoveDefaultAclRequestProto* other);
1205 
1206  // implements Message ----------------------------------------------
1207 
1208  inline RemoveDefaultAclRequestProto* New() const { return New(NULL); }
1209 
1210  RemoveDefaultAclRequestProto* New(::google::protobuf::Arena* arena) const;
1211  void CopyFrom(const ::google::protobuf::Message& from);
1212  void MergeFrom(const ::google::protobuf::Message& from);
1213  void CopyFrom(const RemoveDefaultAclRequestProto& from);
1214  void MergeFrom(const RemoveDefaultAclRequestProto& from);
1215  void Clear();
1216  bool IsInitialized() const;
1217 
1218  int ByteSize() const;
1219  bool MergePartialFromCodedStream(
1220  ::google::protobuf::io::CodedInputStream* input);
1221  void SerializeWithCachedSizes(
1222  ::google::protobuf::io::CodedOutputStream* output) const;
1223  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1224  bool deterministic, ::google::protobuf::uint8* output) const;
1225  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1226  return InternalSerializeWithCachedSizesToArray(false, output);
1227  }
1228  int GetCachedSize() const { return _cached_size_; }
1229  private:
1230  void SharedCtor();
1231  void SharedDtor();
1232  void SetCachedSize(int size) const;
1233  void InternalSwap(RemoveDefaultAclRequestProto* other);
1234  private:
1235  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1236  return _internal_metadata_.arena();
1237  }
1238  inline void* MaybeArenaPtr() const {
1239  return _internal_metadata_.raw_arena_ptr();
1240  }
1241  public:
1242 
1243  ::google::protobuf::Metadata GetMetadata() const;
1244 
1245  // nested types ----------------------------------------------------
1246 
1247  // accessors -------------------------------------------------------
1248 
1249  // required string src = 1;
1250  bool has_src() const;
1251  void clear_src();
1252  static const int kSrcFieldNumber = 1;
1253  const ::std::string& src() const;
1254  void set_src(const ::std::string& value);
1255  void set_src(const char* value);
1256  void set_src(const char* value, size_t size);
1257  ::std::string* mutable_src();
1258  ::std::string* release_src();
1259  void set_allocated_src(::std::string* src);
1260 
1261  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoveDefaultAclRequestProto)
1262  private:
1263  inline void set_has_src();
1264  inline void clear_has_src();
1265 
1266  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1267  ::google::protobuf::uint32 _has_bits_[1];
1268  mutable int _cached_size_;
1269  ::google::protobuf::internal::ArenaStringPtr src_;
1270  friend void protobuf_AddDesc_acl_2eproto();
1271  friend void protobuf_AssignDesc_acl_2eproto();
1272  friend void protobuf_ShutdownFile_acl_2eproto();
1273 
1274  void InitAsDefaultInstance();
1275  static RemoveDefaultAclRequestProto* default_instance_;
1276 };
1277 // -------------------------------------------------------------------
1278 
1279 class RemoveDefaultAclResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.RemoveDefaultAclResponseProto) */ {
1280  public:
1281  RemoveDefaultAclResponseProto();
1282  virtual ~RemoveDefaultAclResponseProto();
1283 
1284  RemoveDefaultAclResponseProto(const RemoveDefaultAclResponseProto& from);
1285 
1286  inline RemoveDefaultAclResponseProto& operator=(const RemoveDefaultAclResponseProto& from) {
1287  CopyFrom(from);
1288  return *this;
1289  }
1290 
1291  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1292  return _internal_metadata_.unknown_fields();
1293  }
1294 
1295  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1296  return _internal_metadata_.mutable_unknown_fields();
1297  }
1298 
1299  static const ::google::protobuf::Descriptor* descriptor();
1300  static const RemoveDefaultAclResponseProto& default_instance();
1301 
1302  void Swap(RemoveDefaultAclResponseProto* other);
1303 
1304  // implements Message ----------------------------------------------
1305 
1306  inline RemoveDefaultAclResponseProto* New() const { return New(NULL); }
1307 
1308  RemoveDefaultAclResponseProto* New(::google::protobuf::Arena* arena) const;
1309  void CopyFrom(const ::google::protobuf::Message& from);
1310  void MergeFrom(const ::google::protobuf::Message& from);
1311  void CopyFrom(const RemoveDefaultAclResponseProto& from);
1312  void MergeFrom(const RemoveDefaultAclResponseProto& from);
1313  void Clear();
1314  bool IsInitialized() const;
1315 
1316  int ByteSize() const;
1317  bool MergePartialFromCodedStream(
1318  ::google::protobuf::io::CodedInputStream* input);
1319  void SerializeWithCachedSizes(
1320  ::google::protobuf::io::CodedOutputStream* output) const;
1321  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1322  bool deterministic, ::google::protobuf::uint8* output) const;
1323  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1324  return InternalSerializeWithCachedSizesToArray(false, output);
1325  }
1326  int GetCachedSize() const { return _cached_size_; }
1327  private:
1328  void SharedCtor();
1329  void SharedDtor();
1330  void SetCachedSize(int size) const;
1331  void InternalSwap(RemoveDefaultAclResponseProto* other);
1332  private:
1333  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1334  return _internal_metadata_.arena();
1335  }
1336  inline void* MaybeArenaPtr() const {
1337  return _internal_metadata_.raw_arena_ptr();
1338  }
1339  public:
1340 
1341  ::google::protobuf::Metadata GetMetadata() const;
1342 
1343  // nested types ----------------------------------------------------
1344 
1345  // accessors -------------------------------------------------------
1346 
1347  // @@protoc_insertion_point(class_scope:hadoop.hdfs.RemoveDefaultAclResponseProto)
1348  private:
1349 
1350  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1351  ::google::protobuf::uint32 _has_bits_[1];
1352  mutable int _cached_size_;
1353  friend void protobuf_AddDesc_acl_2eproto();
1354  friend void protobuf_AssignDesc_acl_2eproto();
1355  friend void protobuf_ShutdownFile_acl_2eproto();
1356 
1357  void InitAsDefaultInstance();
1358  static RemoveDefaultAclResponseProto* default_instance_;
1359 };
1360 // -------------------------------------------------------------------
1361 
1362 class SetAclRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SetAclRequestProto) */ {
1363  public:
1364  SetAclRequestProto();
1365  virtual ~SetAclRequestProto();
1366 
1367  SetAclRequestProto(const SetAclRequestProto& from);
1368 
1369  inline SetAclRequestProto& operator=(const SetAclRequestProto& from) {
1370  CopyFrom(from);
1371  return *this;
1372  }
1373 
1374  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1375  return _internal_metadata_.unknown_fields();
1376  }
1377 
1378  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1379  return _internal_metadata_.mutable_unknown_fields();
1380  }
1381 
1382  static const ::google::protobuf::Descriptor* descriptor();
1383  static const SetAclRequestProto& default_instance();
1384 
1385  void Swap(SetAclRequestProto* other);
1386 
1387  // implements Message ----------------------------------------------
1388 
1389  inline SetAclRequestProto* New() const { return New(NULL); }
1390 
1391  SetAclRequestProto* New(::google::protobuf::Arena* arena) const;
1392  void CopyFrom(const ::google::protobuf::Message& from);
1393  void MergeFrom(const ::google::protobuf::Message& from);
1394  void CopyFrom(const SetAclRequestProto& from);
1395  void MergeFrom(const SetAclRequestProto& from);
1396  void Clear();
1397  bool IsInitialized() const;
1398 
1399  int ByteSize() const;
1400  bool MergePartialFromCodedStream(
1401  ::google::protobuf::io::CodedInputStream* input);
1402  void SerializeWithCachedSizes(
1403  ::google::protobuf::io::CodedOutputStream* output) const;
1404  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1405  bool deterministic, ::google::protobuf::uint8* output) const;
1406  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1407  return InternalSerializeWithCachedSizesToArray(false, output);
1408  }
1409  int GetCachedSize() const { return _cached_size_; }
1410  private:
1411  void SharedCtor();
1412  void SharedDtor();
1413  void SetCachedSize(int size) const;
1414  void InternalSwap(SetAclRequestProto* other);
1415  private:
1416  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1417  return _internal_metadata_.arena();
1418  }
1419  inline void* MaybeArenaPtr() const {
1420  return _internal_metadata_.raw_arena_ptr();
1421  }
1422  public:
1423 
1424  ::google::protobuf::Metadata GetMetadata() const;
1425 
1426  // nested types ----------------------------------------------------
1427 
1428  // accessors -------------------------------------------------------
1429 
1430  // required string src = 1;
1431  bool has_src() const;
1432  void clear_src();
1433  static const int kSrcFieldNumber = 1;
1434  const ::std::string& src() const;
1435  void set_src(const ::std::string& value);
1436  void set_src(const char* value);
1437  void set_src(const char* value, size_t size);
1438  ::std::string* mutable_src();
1439  ::std::string* release_src();
1440  void set_allocated_src(::std::string* src);
1441 
1442  // repeated .hadoop.hdfs.AclEntryProto aclSpec = 2;
1443  int aclspec_size() const;
1444  void clear_aclspec();
1445  static const int kAclSpecFieldNumber = 2;
1446  const ::hadoop::hdfs::AclEntryProto& aclspec(int index) const;
1447  ::hadoop::hdfs::AclEntryProto* mutable_aclspec(int index);
1448  ::hadoop::hdfs::AclEntryProto* add_aclspec();
1449  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
1450  mutable_aclspec();
1451  const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
1452  aclspec() const;
1453 
1454  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SetAclRequestProto)
1455  private:
1456  inline void set_has_src();
1457  inline void clear_has_src();
1458 
1459  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1460  ::google::protobuf::uint32 _has_bits_[1];
1461  mutable int _cached_size_;
1462  ::google::protobuf::internal::ArenaStringPtr src_;
1463  ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto > aclspec_;
1464  friend void protobuf_AddDesc_acl_2eproto();
1465  friend void protobuf_AssignDesc_acl_2eproto();
1466  friend void protobuf_ShutdownFile_acl_2eproto();
1467 
1468  void InitAsDefaultInstance();
1469  static SetAclRequestProto* default_instance_;
1470 };
1471 // -------------------------------------------------------------------
1472 
1473 class SetAclResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.SetAclResponseProto) */ {
1474  public:
1475  SetAclResponseProto();
1476  virtual ~SetAclResponseProto();
1477 
1478  SetAclResponseProto(const SetAclResponseProto& from);
1479 
1480  inline SetAclResponseProto& operator=(const SetAclResponseProto& from) {
1481  CopyFrom(from);
1482  return *this;
1483  }
1484 
1485  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1486  return _internal_metadata_.unknown_fields();
1487  }
1488 
1489  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1490  return _internal_metadata_.mutable_unknown_fields();
1491  }
1492 
1493  static const ::google::protobuf::Descriptor* descriptor();
1494  static const SetAclResponseProto& default_instance();
1495 
1496  void Swap(SetAclResponseProto* other);
1497 
1498  // implements Message ----------------------------------------------
1499 
1500  inline SetAclResponseProto* New() const { return New(NULL); }
1501 
1502  SetAclResponseProto* New(::google::protobuf::Arena* arena) const;
1503  void CopyFrom(const ::google::protobuf::Message& from);
1504  void MergeFrom(const ::google::protobuf::Message& from);
1505  void CopyFrom(const SetAclResponseProto& from);
1506  void MergeFrom(const SetAclResponseProto& from);
1507  void Clear();
1508  bool IsInitialized() const;
1509 
1510  int ByteSize() const;
1511  bool MergePartialFromCodedStream(
1512  ::google::protobuf::io::CodedInputStream* input);
1513  void SerializeWithCachedSizes(
1514  ::google::protobuf::io::CodedOutputStream* output) const;
1515  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1516  bool deterministic, ::google::protobuf::uint8* output) const;
1517  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1518  return InternalSerializeWithCachedSizesToArray(false, output);
1519  }
1520  int GetCachedSize() const { return _cached_size_; }
1521  private:
1522  void SharedCtor();
1523  void SharedDtor();
1524  void SetCachedSize(int size) const;
1525  void InternalSwap(SetAclResponseProto* other);
1526  private:
1527  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1528  return _internal_metadata_.arena();
1529  }
1530  inline void* MaybeArenaPtr() const {
1531  return _internal_metadata_.raw_arena_ptr();
1532  }
1533  public:
1534 
1535  ::google::protobuf::Metadata GetMetadata() const;
1536 
1537  // nested types ----------------------------------------------------
1538 
1539  // accessors -------------------------------------------------------
1540 
1541  // @@protoc_insertion_point(class_scope:hadoop.hdfs.SetAclResponseProto)
1542  private:
1543 
1544  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1545  ::google::protobuf::uint32 _has_bits_[1];
1546  mutable int _cached_size_;
1547  friend void protobuf_AddDesc_acl_2eproto();
1548  friend void protobuf_AssignDesc_acl_2eproto();
1549  friend void protobuf_ShutdownFile_acl_2eproto();
1550 
1551  void InitAsDefaultInstance();
1552  static SetAclResponseProto* default_instance_;
1553 };
1554 // -------------------------------------------------------------------
1555 
1556 class GetAclStatusRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.GetAclStatusRequestProto) */ {
1557  public:
1558  GetAclStatusRequestProto();
1559  virtual ~GetAclStatusRequestProto();
1560 
1561  GetAclStatusRequestProto(const GetAclStatusRequestProto& from);
1562 
1563  inline GetAclStatusRequestProto& operator=(const GetAclStatusRequestProto& from) {
1564  CopyFrom(from);
1565  return *this;
1566  }
1567 
1568  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1569  return _internal_metadata_.unknown_fields();
1570  }
1571 
1572  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1573  return _internal_metadata_.mutable_unknown_fields();
1574  }
1575 
1576  static const ::google::protobuf::Descriptor* descriptor();
1577  static const GetAclStatusRequestProto& default_instance();
1578 
1579  void Swap(GetAclStatusRequestProto* other);
1580 
1581  // implements Message ----------------------------------------------
1582 
1583  inline GetAclStatusRequestProto* New() const { return New(NULL); }
1584 
1585  GetAclStatusRequestProto* New(::google::protobuf::Arena* arena) const;
1586  void CopyFrom(const ::google::protobuf::Message& from);
1587  void MergeFrom(const ::google::protobuf::Message& from);
1588  void CopyFrom(const GetAclStatusRequestProto& from);
1589  void MergeFrom(const GetAclStatusRequestProto& from);
1590  void Clear();
1591  bool IsInitialized() const;
1592 
1593  int ByteSize() const;
1594  bool MergePartialFromCodedStream(
1595  ::google::protobuf::io::CodedInputStream* input);
1596  void SerializeWithCachedSizes(
1597  ::google::protobuf::io::CodedOutputStream* output) const;
1598  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1599  bool deterministic, ::google::protobuf::uint8* output) const;
1600  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1601  return InternalSerializeWithCachedSizesToArray(false, output);
1602  }
1603  int GetCachedSize() const { return _cached_size_; }
1604  private:
1605  void SharedCtor();
1606  void SharedDtor();
1607  void SetCachedSize(int size) const;
1608  void InternalSwap(GetAclStatusRequestProto* other);
1609  private:
1610  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1611  return _internal_metadata_.arena();
1612  }
1613  inline void* MaybeArenaPtr() const {
1614  return _internal_metadata_.raw_arena_ptr();
1615  }
1616  public:
1617 
1618  ::google::protobuf::Metadata GetMetadata() const;
1619 
1620  // nested types ----------------------------------------------------
1621 
1622  // accessors -------------------------------------------------------
1623 
1624  // required string src = 1;
1625  bool has_src() const;
1626  void clear_src();
1627  static const int kSrcFieldNumber = 1;
1628  const ::std::string& src() const;
1629  void set_src(const ::std::string& value);
1630  void set_src(const char* value);
1631  void set_src(const char* value, size_t size);
1632  ::std::string* mutable_src();
1633  ::std::string* release_src();
1634  void set_allocated_src(::std::string* src);
1635 
1636  // @@protoc_insertion_point(class_scope:hadoop.hdfs.GetAclStatusRequestProto)
1637  private:
1638  inline void set_has_src();
1639  inline void clear_has_src();
1640 
1641  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1642  ::google::protobuf::uint32 _has_bits_[1];
1643  mutable int _cached_size_;
1644  ::google::protobuf::internal::ArenaStringPtr src_;
1645  friend void protobuf_AddDesc_acl_2eproto();
1646  friend void protobuf_AssignDesc_acl_2eproto();
1647  friend void protobuf_ShutdownFile_acl_2eproto();
1648 
1649  void InitAsDefaultInstance();
1650  static GetAclStatusRequestProto* default_instance_;
1651 };
1652 // -------------------------------------------------------------------
1653 
1654 class GetAclStatusResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:hadoop.hdfs.GetAclStatusResponseProto) */ {
1655  public:
1656  GetAclStatusResponseProto();
1657  virtual ~GetAclStatusResponseProto();
1658 
1659  GetAclStatusResponseProto(const GetAclStatusResponseProto& from);
1660 
1661  inline GetAclStatusResponseProto& operator=(const GetAclStatusResponseProto& from) {
1662  CopyFrom(from);
1663  return *this;
1664  }
1665 
1666  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1667  return _internal_metadata_.unknown_fields();
1668  }
1669 
1670  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1671  return _internal_metadata_.mutable_unknown_fields();
1672  }
1673 
1674  static const ::google::protobuf::Descriptor* descriptor();
1675  static const GetAclStatusResponseProto& default_instance();
1676 
1677  void Swap(GetAclStatusResponseProto* other);
1678 
1679  // implements Message ----------------------------------------------
1680 
1681  inline GetAclStatusResponseProto* New() const { return New(NULL); }
1682 
1683  GetAclStatusResponseProto* New(::google::protobuf::Arena* arena) const;
1684  void CopyFrom(const ::google::protobuf::Message& from);
1685  void MergeFrom(const ::google::protobuf::Message& from);
1686  void CopyFrom(const GetAclStatusResponseProto& from);
1687  void MergeFrom(const GetAclStatusResponseProto& from);
1688  void Clear();
1689  bool IsInitialized() const;
1690 
1691  int ByteSize() const;
1692  bool MergePartialFromCodedStream(
1693  ::google::protobuf::io::CodedInputStream* input);
1694  void SerializeWithCachedSizes(
1695  ::google::protobuf::io::CodedOutputStream* output) const;
1696  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1697  bool deterministic, ::google::protobuf::uint8* output) const;
1698  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
1699  return InternalSerializeWithCachedSizesToArray(false, output);
1700  }
1701  int GetCachedSize() const { return _cached_size_; }
1702  private:
1703  void SharedCtor();
1704  void SharedDtor();
1705  void SetCachedSize(int size) const;
1706  void InternalSwap(GetAclStatusResponseProto* other);
1707  private:
1708  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1709  return _internal_metadata_.arena();
1710  }
1711  inline void* MaybeArenaPtr() const {
1712  return _internal_metadata_.raw_arena_ptr();
1713  }
1714  public:
1715 
1716  ::google::protobuf::Metadata GetMetadata() const;
1717 
1718  // nested types ----------------------------------------------------
1719 
1720  // accessors -------------------------------------------------------
1721 
1722  // required .hadoop.hdfs.AclStatusProto result = 1;
1723  bool has_result() const;
1724  void clear_result();
1725  static const int kResultFieldNumber = 1;
1726  const ::hadoop::hdfs::AclStatusProto& result() const;
1727  ::hadoop::hdfs::AclStatusProto* mutable_result();
1728  ::hadoop::hdfs::AclStatusProto* release_result();
1729  void set_allocated_result(::hadoop::hdfs::AclStatusProto* result);
1730 
1731  // @@protoc_insertion_point(class_scope:hadoop.hdfs.GetAclStatusResponseProto)
1732  private:
1733  inline void set_has_result();
1734  inline void clear_has_result();
1735 
1736  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1737  ::google::protobuf::uint32 _has_bits_[1];
1738  mutable int _cached_size_;
1739  ::hadoop::hdfs::AclStatusProto* result_;
1740  friend void protobuf_AddDesc_acl_2eproto();
1741  friend void protobuf_AssignDesc_acl_2eproto();
1742  friend void protobuf_ShutdownFile_acl_2eproto();
1743 
1744  void InitAsDefaultInstance();
1745  static GetAclStatusResponseProto* default_instance_;
1746 };
1747 // ===================================================================
1748 
1749 
1750 // ===================================================================
1751 
1752 #if !PROTOBUF_INLINE_NOT_IN_HEADERS
1753 // AclEntryProto
1754 
1755 // required .hadoop.hdfs.AclEntryProto.AclEntryTypeProto type = 1;
1756 inline bool AclEntryProto::has_type() const {
1757  return (_has_bits_[0] & 0x00000001u) != 0;
1758 }
1759 inline void AclEntryProto::set_has_type() {
1760  _has_bits_[0] |= 0x00000001u;
1761 }
1762 inline void AclEntryProto::clear_has_type() {
1763  _has_bits_[0] &= ~0x00000001u;
1764 }
1765 inline void AclEntryProto::clear_type() {
1766  type_ = 0;
1767  clear_has_type();
1768 }
1769 inline ::hadoop::hdfs::AclEntryProto_AclEntryTypeProto AclEntryProto::type() const {
1770  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclEntryProto.type)
1771  return static_cast< ::hadoop::hdfs::AclEntryProto_AclEntryTypeProto >(type_);
1772 }
1773 inline void AclEntryProto::set_type(::hadoop::hdfs::AclEntryProto_AclEntryTypeProto value) {
1774  assert(::hadoop::hdfs::AclEntryProto_AclEntryTypeProto_IsValid(value));
1775  set_has_type();
1776  type_ = value;
1777  // @@protoc_insertion_point(field_set:hadoop.hdfs.AclEntryProto.type)
1778 }
1779 
1780 // required .hadoop.hdfs.AclEntryProto.AclEntryScopeProto scope = 2;
1781 inline bool AclEntryProto::has_scope() const {
1782  return (_has_bits_[0] & 0x00000002u) != 0;
1783 }
1784 inline void AclEntryProto::set_has_scope() {
1785  _has_bits_[0] |= 0x00000002u;
1786 }
1787 inline void AclEntryProto::clear_has_scope() {
1788  _has_bits_[0] &= ~0x00000002u;
1789 }
1790 inline void AclEntryProto::clear_scope() {
1791  scope_ = 0;
1792  clear_has_scope();
1793 }
1794 inline ::hadoop::hdfs::AclEntryProto_AclEntryScopeProto AclEntryProto::scope() const {
1795  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclEntryProto.scope)
1796  return static_cast< ::hadoop::hdfs::AclEntryProto_AclEntryScopeProto >(scope_);
1797 }
1798 inline void AclEntryProto::set_scope(::hadoop::hdfs::AclEntryProto_AclEntryScopeProto value) {
1799  assert(::hadoop::hdfs::AclEntryProto_AclEntryScopeProto_IsValid(value));
1800  set_has_scope();
1801  scope_ = value;
1802  // @@protoc_insertion_point(field_set:hadoop.hdfs.AclEntryProto.scope)
1803 }
1804 
1805 // required .hadoop.hdfs.AclEntryProto.FsActionProto permissions = 3;
1806 inline bool AclEntryProto::has_permissions() const {
1807  return (_has_bits_[0] & 0x00000004u) != 0;
1808 }
1809 inline void AclEntryProto::set_has_permissions() {
1810  _has_bits_[0] |= 0x00000004u;
1811 }
1812 inline void AclEntryProto::clear_has_permissions() {
1813  _has_bits_[0] &= ~0x00000004u;
1814 }
1815 inline void AclEntryProto::clear_permissions() {
1816  permissions_ = 0;
1817  clear_has_permissions();
1818 }
1819 inline ::hadoop::hdfs::AclEntryProto_FsActionProto AclEntryProto::permissions() const {
1820  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclEntryProto.permissions)
1821  return static_cast< ::hadoop::hdfs::AclEntryProto_FsActionProto >(permissions_);
1822 }
1823 inline void AclEntryProto::set_permissions(::hadoop::hdfs::AclEntryProto_FsActionProto value) {
1824  assert(::hadoop::hdfs::AclEntryProto_FsActionProto_IsValid(value));
1825  set_has_permissions();
1826  permissions_ = value;
1827  // @@protoc_insertion_point(field_set:hadoop.hdfs.AclEntryProto.permissions)
1828 }
1829 
1830 // optional string name = 4;
1831 inline bool AclEntryProto::has_name() const {
1832  return (_has_bits_[0] & 0x00000008u) != 0;
1833 }
1834 inline void AclEntryProto::set_has_name() {
1835  _has_bits_[0] |= 0x00000008u;
1836 }
1837 inline void AclEntryProto::clear_has_name() {
1838  _has_bits_[0] &= ~0x00000008u;
1839 }
1840 inline void AclEntryProto::clear_name() {
1841  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1842  clear_has_name();
1843 }
1844 inline const ::std::string& AclEntryProto::name() const {
1845  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclEntryProto.name)
1846  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1847 }
1848 inline void AclEntryProto::set_name(const ::std::string& value) {
1849  set_has_name();
1850  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1851  // @@protoc_insertion_point(field_set:hadoop.hdfs.AclEntryProto.name)
1852 }
1853 inline void AclEntryProto::set_name(const char* value) {
1854  set_has_name();
1855  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1856  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.AclEntryProto.name)
1857 }
1858 inline void AclEntryProto::set_name(const char* value, size_t size) {
1859  set_has_name();
1860  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1861  ::std::string(reinterpret_cast<const char*>(value), size));
1862  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.AclEntryProto.name)
1863 }
1864 inline ::std::string* AclEntryProto::mutable_name() {
1865  set_has_name();
1866  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.AclEntryProto.name)
1867  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1868 }
1869 inline ::std::string* AclEntryProto::release_name() {
1870  // @@protoc_insertion_point(field_release:hadoop.hdfs.AclEntryProto.name)
1871  clear_has_name();
1872  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1873 }
1874 inline void AclEntryProto::set_allocated_name(::std::string* name) {
1875  if (name != NULL) {
1876  set_has_name();
1877  } else {
1878  clear_has_name();
1879  }
1880  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
1881  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.AclEntryProto.name)
1882 }
1883 
1884 // -------------------------------------------------------------------
1885 
1886 // AclStatusProto
1887 
1888 // required string owner = 1;
1889 inline bool AclStatusProto::has_owner() const {
1890  return (_has_bits_[0] & 0x00000001u) != 0;
1891 }
1892 inline void AclStatusProto::set_has_owner() {
1893  _has_bits_[0] |= 0x00000001u;
1894 }
1895 inline void AclStatusProto::clear_has_owner() {
1896  _has_bits_[0] &= ~0x00000001u;
1897 }
1898 inline void AclStatusProto::clear_owner() {
1899  owner_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1900  clear_has_owner();
1901 }
1902 inline const ::std::string& AclStatusProto::owner() const {
1903  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclStatusProto.owner)
1904  return owner_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1905 }
1906 inline void AclStatusProto::set_owner(const ::std::string& value) {
1907  set_has_owner();
1908  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1909  // @@protoc_insertion_point(field_set:hadoop.hdfs.AclStatusProto.owner)
1910 }
1911 inline void AclStatusProto::set_owner(const char* value) {
1912  set_has_owner();
1913  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1914  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.AclStatusProto.owner)
1915 }
1916 inline void AclStatusProto::set_owner(const char* value, size_t size) {
1917  set_has_owner();
1918  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1919  ::std::string(reinterpret_cast<const char*>(value), size));
1920  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.AclStatusProto.owner)
1921 }
1922 inline ::std::string* AclStatusProto::mutable_owner() {
1923  set_has_owner();
1924  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.AclStatusProto.owner)
1925  return owner_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1926 }
1927 inline ::std::string* AclStatusProto::release_owner() {
1928  // @@protoc_insertion_point(field_release:hadoop.hdfs.AclStatusProto.owner)
1929  clear_has_owner();
1930  return owner_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1931 }
1932 inline void AclStatusProto::set_allocated_owner(::std::string* owner) {
1933  if (owner != NULL) {
1934  set_has_owner();
1935  } else {
1936  clear_has_owner();
1937  }
1938  owner_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), owner);
1939  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.AclStatusProto.owner)
1940 }
1941 
1942 // required string group = 2;
1943 inline bool AclStatusProto::has_group() const {
1944  return (_has_bits_[0] & 0x00000002u) != 0;
1945 }
1946 inline void AclStatusProto::set_has_group() {
1947  _has_bits_[0] |= 0x00000002u;
1948 }
1949 inline void AclStatusProto::clear_has_group() {
1950  _has_bits_[0] &= ~0x00000002u;
1951 }
1952 inline void AclStatusProto::clear_group() {
1953  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1954  clear_has_group();
1955 }
1956 inline const ::std::string& AclStatusProto::group() const {
1957  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclStatusProto.group)
1958  return group_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1959 }
1960 inline void AclStatusProto::set_group(const ::std::string& value) {
1961  set_has_group();
1962  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1963  // @@protoc_insertion_point(field_set:hadoop.hdfs.AclStatusProto.group)
1964 }
1965 inline void AclStatusProto::set_group(const char* value) {
1966  set_has_group();
1967  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1968  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.AclStatusProto.group)
1969 }
1970 inline void AclStatusProto::set_group(const char* value, size_t size) {
1971  set_has_group();
1972  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1973  ::std::string(reinterpret_cast<const char*>(value), size));
1974  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.AclStatusProto.group)
1975 }
1976 inline ::std::string* AclStatusProto::mutable_group() {
1977  set_has_group();
1978  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.AclStatusProto.group)
1979  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1980 }
1981 inline ::std::string* AclStatusProto::release_group() {
1982  // @@protoc_insertion_point(field_release:hadoop.hdfs.AclStatusProto.group)
1983  clear_has_group();
1984  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1985 }
1986 inline void AclStatusProto::set_allocated_group(::std::string* group) {
1987  if (group != NULL) {
1988  set_has_group();
1989  } else {
1990  clear_has_group();
1991  }
1992  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
1993  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.AclStatusProto.group)
1994 }
1995 
1996 // required bool sticky = 3;
1997 inline bool AclStatusProto::has_sticky() const {
1998  return (_has_bits_[0] & 0x00000004u) != 0;
1999 }
2000 inline void AclStatusProto::set_has_sticky() {
2001  _has_bits_[0] |= 0x00000004u;
2002 }
2003 inline void AclStatusProto::clear_has_sticky() {
2004  _has_bits_[0] &= ~0x00000004u;
2005 }
2006 inline void AclStatusProto::clear_sticky() {
2007  sticky_ = false;
2008  clear_has_sticky();
2009 }
2010 inline bool AclStatusProto::sticky() const {
2011  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclStatusProto.sticky)
2012  return sticky_;
2013 }
2014 inline void AclStatusProto::set_sticky(bool value) {
2015  set_has_sticky();
2016  sticky_ = value;
2017  // @@protoc_insertion_point(field_set:hadoop.hdfs.AclStatusProto.sticky)
2018 }
2019 
2020 // repeated .hadoop.hdfs.AclEntryProto entries = 4;
2021 inline int AclStatusProto::entries_size() const {
2022  return entries_.size();
2023 }
2024 inline void AclStatusProto::clear_entries() {
2025  entries_.Clear();
2026 }
2027 inline const ::hadoop::hdfs::AclEntryProto& AclStatusProto::entries(int index) const {
2028  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclStatusProto.entries)
2029  return entries_.Get(index);
2030 }
2031 inline ::hadoop::hdfs::AclEntryProto* AclStatusProto::mutable_entries(int index) {
2032  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.AclStatusProto.entries)
2033  return entries_.Mutable(index);
2034 }
2035 inline ::hadoop::hdfs::AclEntryProto* AclStatusProto::add_entries() {
2036  // @@protoc_insertion_point(field_add:hadoop.hdfs.AclStatusProto.entries)
2037  return entries_.Add();
2038 }
2039 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
2040 AclStatusProto::mutable_entries() {
2041  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.AclStatusProto.entries)
2042  return &entries_;
2043 }
2044 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
2045 AclStatusProto::entries() const {
2046  // @@protoc_insertion_point(field_list:hadoop.hdfs.AclStatusProto.entries)
2047  return entries_;
2048 }
2049 
2050 // optional .hadoop.hdfs.FsPermissionProto permission = 5;
2051 inline bool AclStatusProto::has_permission() const {
2052  return (_has_bits_[0] & 0x00000010u) != 0;
2053 }
2054 inline void AclStatusProto::set_has_permission() {
2055  _has_bits_[0] |= 0x00000010u;
2056 }
2057 inline void AclStatusProto::clear_has_permission() {
2058  _has_bits_[0] &= ~0x00000010u;
2059 }
2060 inline void AclStatusProto::clear_permission() {
2061  if (permission_ != NULL) permission_->::hadoop::hdfs::FsPermissionProto::Clear();
2062  clear_has_permission();
2063 }
2064 inline const ::hadoop::hdfs::FsPermissionProto& AclStatusProto::permission() const {
2065  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclStatusProto.permission)
2066  return permission_ != NULL ? *permission_ : *default_instance_->permission_;
2067 }
2068 inline ::hadoop::hdfs::FsPermissionProto* AclStatusProto::mutable_permission() {
2069  set_has_permission();
2070  if (permission_ == NULL) {
2071  permission_ = new ::hadoop::hdfs::FsPermissionProto;
2072  }
2073  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.AclStatusProto.permission)
2074  return permission_;
2075 }
2076 inline ::hadoop::hdfs::FsPermissionProto* AclStatusProto::release_permission() {
2077  // @@protoc_insertion_point(field_release:hadoop.hdfs.AclStatusProto.permission)
2078  clear_has_permission();
2079  ::hadoop::hdfs::FsPermissionProto* temp = permission_;
2080  permission_ = NULL;
2081  return temp;
2082 }
2083 inline void AclStatusProto::set_allocated_permission(::hadoop::hdfs::FsPermissionProto* permission) {
2084  delete permission_;
2085  permission_ = permission;
2086  if (permission) {
2087  set_has_permission();
2088  } else {
2089  clear_has_permission();
2090  }
2091  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.AclStatusProto.permission)
2092 }
2093 
2094 // -------------------------------------------------------------------
2095 
2096 // AclEditLogProto
2097 
2098 // required string src = 1;
2099 inline bool AclEditLogProto::has_src() const {
2100  return (_has_bits_[0] & 0x00000001u) != 0;
2101 }
2102 inline void AclEditLogProto::set_has_src() {
2103  _has_bits_[0] |= 0x00000001u;
2104 }
2105 inline void AclEditLogProto::clear_has_src() {
2106  _has_bits_[0] &= ~0x00000001u;
2107 }
2108 inline void AclEditLogProto::clear_src() {
2109  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2110  clear_has_src();
2111 }
2112 inline const ::std::string& AclEditLogProto::src() const {
2113  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclEditLogProto.src)
2114  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2115 }
2116 inline void AclEditLogProto::set_src(const ::std::string& value) {
2117  set_has_src();
2118  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2119  // @@protoc_insertion_point(field_set:hadoop.hdfs.AclEditLogProto.src)
2120 }
2121 inline void AclEditLogProto::set_src(const char* value) {
2122  set_has_src();
2123  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2124  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.AclEditLogProto.src)
2125 }
2126 inline void AclEditLogProto::set_src(const char* value, size_t size) {
2127  set_has_src();
2128  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2129  ::std::string(reinterpret_cast<const char*>(value), size));
2130  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.AclEditLogProto.src)
2131 }
2132 inline ::std::string* AclEditLogProto::mutable_src() {
2133  set_has_src();
2134  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.AclEditLogProto.src)
2135  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2136 }
2137 inline ::std::string* AclEditLogProto::release_src() {
2138  // @@protoc_insertion_point(field_release:hadoop.hdfs.AclEditLogProto.src)
2139  clear_has_src();
2140  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2141 }
2142 inline void AclEditLogProto::set_allocated_src(::std::string* src) {
2143  if (src != NULL) {
2144  set_has_src();
2145  } else {
2146  clear_has_src();
2147  }
2148  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
2149  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.AclEditLogProto.src)
2150 }
2151 
2152 // repeated .hadoop.hdfs.AclEntryProto entries = 2;
2153 inline int AclEditLogProto::entries_size() const {
2154  return entries_.size();
2155 }
2156 inline void AclEditLogProto::clear_entries() {
2157  entries_.Clear();
2158 }
2159 inline const ::hadoop::hdfs::AclEntryProto& AclEditLogProto::entries(int index) const {
2160  // @@protoc_insertion_point(field_get:hadoop.hdfs.AclEditLogProto.entries)
2161  return entries_.Get(index);
2162 }
2163 inline ::hadoop::hdfs::AclEntryProto* AclEditLogProto::mutable_entries(int index) {
2164  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.AclEditLogProto.entries)
2165  return entries_.Mutable(index);
2166 }
2167 inline ::hadoop::hdfs::AclEntryProto* AclEditLogProto::add_entries() {
2168  // @@protoc_insertion_point(field_add:hadoop.hdfs.AclEditLogProto.entries)
2169  return entries_.Add();
2170 }
2171 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
2172 AclEditLogProto::mutable_entries() {
2173  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.AclEditLogProto.entries)
2174  return &entries_;
2175 }
2176 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
2177 AclEditLogProto::entries() const {
2178  // @@protoc_insertion_point(field_list:hadoop.hdfs.AclEditLogProto.entries)
2179  return entries_;
2180 }
2181 
2182 // -------------------------------------------------------------------
2183 
2184 // ModifyAclEntriesRequestProto
2185 
2186 // required string src = 1;
2187 inline bool ModifyAclEntriesRequestProto::has_src() const {
2188  return (_has_bits_[0] & 0x00000001u) != 0;
2189 }
2190 inline void ModifyAclEntriesRequestProto::set_has_src() {
2191  _has_bits_[0] |= 0x00000001u;
2192 }
2193 inline void ModifyAclEntriesRequestProto::clear_has_src() {
2194  _has_bits_[0] &= ~0x00000001u;
2195 }
2196 inline void ModifyAclEntriesRequestProto::clear_src() {
2197  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2198  clear_has_src();
2199 }
2200 inline const ::std::string& ModifyAclEntriesRequestProto::src() const {
2201  // @@protoc_insertion_point(field_get:hadoop.hdfs.ModifyAclEntriesRequestProto.src)
2202  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2203 }
2204 inline void ModifyAclEntriesRequestProto::set_src(const ::std::string& value) {
2205  set_has_src();
2206  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2207  // @@protoc_insertion_point(field_set:hadoop.hdfs.ModifyAclEntriesRequestProto.src)
2208 }
2209 inline void ModifyAclEntriesRequestProto::set_src(const char* value) {
2210  set_has_src();
2211  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2212  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.ModifyAclEntriesRequestProto.src)
2213 }
2214 inline void ModifyAclEntriesRequestProto::set_src(const char* value, size_t size) {
2215  set_has_src();
2216  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2217  ::std::string(reinterpret_cast<const char*>(value), size));
2218  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.ModifyAclEntriesRequestProto.src)
2219 }
2220 inline ::std::string* ModifyAclEntriesRequestProto::mutable_src() {
2221  set_has_src();
2222  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ModifyAclEntriesRequestProto.src)
2223  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2224 }
2225 inline ::std::string* ModifyAclEntriesRequestProto::release_src() {
2226  // @@protoc_insertion_point(field_release:hadoop.hdfs.ModifyAclEntriesRequestProto.src)
2227  clear_has_src();
2228  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2229 }
2230 inline void ModifyAclEntriesRequestProto::set_allocated_src(::std::string* src) {
2231  if (src != NULL) {
2232  set_has_src();
2233  } else {
2234  clear_has_src();
2235  }
2236  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
2237  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.ModifyAclEntriesRequestProto.src)
2238 }
2239 
2240 // repeated .hadoop.hdfs.AclEntryProto aclSpec = 2;
2241 inline int ModifyAclEntriesRequestProto::aclspec_size() const {
2242  return aclspec_.size();
2243 }
2244 inline void ModifyAclEntriesRequestProto::clear_aclspec() {
2245  aclspec_.Clear();
2246 }
2247 inline const ::hadoop::hdfs::AclEntryProto& ModifyAclEntriesRequestProto::aclspec(int index) const {
2248  // @@protoc_insertion_point(field_get:hadoop.hdfs.ModifyAclEntriesRequestProto.aclSpec)
2249  return aclspec_.Get(index);
2250 }
2251 inline ::hadoop::hdfs::AclEntryProto* ModifyAclEntriesRequestProto::mutable_aclspec(int index) {
2252  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.ModifyAclEntriesRequestProto.aclSpec)
2253  return aclspec_.Mutable(index);
2254 }
2255 inline ::hadoop::hdfs::AclEntryProto* ModifyAclEntriesRequestProto::add_aclspec() {
2256  // @@protoc_insertion_point(field_add:hadoop.hdfs.ModifyAclEntriesRequestProto.aclSpec)
2257  return aclspec_.Add();
2258 }
2259 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
2260 ModifyAclEntriesRequestProto::mutable_aclspec() {
2261  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.ModifyAclEntriesRequestProto.aclSpec)
2262  return &aclspec_;
2263 }
2264 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
2265 ModifyAclEntriesRequestProto::aclspec() const {
2266  // @@protoc_insertion_point(field_list:hadoop.hdfs.ModifyAclEntriesRequestProto.aclSpec)
2267  return aclspec_;
2268 }
2269 
2270 // -------------------------------------------------------------------
2271 
2272 // ModifyAclEntriesResponseProto
2273 
2274 // -------------------------------------------------------------------
2275 
2276 // RemoveAclRequestProto
2277 
2278 // required string src = 1;
2279 inline bool RemoveAclRequestProto::has_src() const {
2280  return (_has_bits_[0] & 0x00000001u) != 0;
2281 }
2282 inline void RemoveAclRequestProto::set_has_src() {
2283  _has_bits_[0] |= 0x00000001u;
2284 }
2285 inline void RemoveAclRequestProto::clear_has_src() {
2286  _has_bits_[0] &= ~0x00000001u;
2287 }
2288 inline void RemoveAclRequestProto::clear_src() {
2289  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2290  clear_has_src();
2291 }
2292 inline const ::std::string& RemoveAclRequestProto::src() const {
2293  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoveAclRequestProto.src)
2294  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2295 }
2296 inline void RemoveAclRequestProto::set_src(const ::std::string& value) {
2297  set_has_src();
2298  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2299  // @@protoc_insertion_point(field_set:hadoop.hdfs.RemoveAclRequestProto.src)
2300 }
2301 inline void RemoveAclRequestProto::set_src(const char* value) {
2302  set_has_src();
2303  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2304  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.RemoveAclRequestProto.src)
2305 }
2306 inline void RemoveAclRequestProto::set_src(const char* value, size_t size) {
2307  set_has_src();
2308  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2309  ::std::string(reinterpret_cast<const char*>(value), size));
2310  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.RemoveAclRequestProto.src)
2311 }
2312 inline ::std::string* RemoveAclRequestProto::mutable_src() {
2313  set_has_src();
2314  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RemoveAclRequestProto.src)
2315  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2316 }
2317 inline ::std::string* RemoveAclRequestProto::release_src() {
2318  // @@protoc_insertion_point(field_release:hadoop.hdfs.RemoveAclRequestProto.src)
2319  clear_has_src();
2320  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2321 }
2322 inline void RemoveAclRequestProto::set_allocated_src(::std::string* src) {
2323  if (src != NULL) {
2324  set_has_src();
2325  } else {
2326  clear_has_src();
2327  }
2328  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
2329  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.RemoveAclRequestProto.src)
2330 }
2331 
2332 // -------------------------------------------------------------------
2333 
2334 // RemoveAclResponseProto
2335 
2336 // -------------------------------------------------------------------
2337 
2338 // RemoveAclEntriesRequestProto
2339 
2340 // required string src = 1;
2341 inline bool RemoveAclEntriesRequestProto::has_src() const {
2342  return (_has_bits_[0] & 0x00000001u) != 0;
2343 }
2344 inline void RemoveAclEntriesRequestProto::set_has_src() {
2345  _has_bits_[0] |= 0x00000001u;
2346 }
2347 inline void RemoveAclEntriesRequestProto::clear_has_src() {
2348  _has_bits_[0] &= ~0x00000001u;
2349 }
2350 inline void RemoveAclEntriesRequestProto::clear_src() {
2351  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2352  clear_has_src();
2353 }
2354 inline const ::std::string& RemoveAclEntriesRequestProto::src() const {
2355  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoveAclEntriesRequestProto.src)
2356  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2357 }
2358 inline void RemoveAclEntriesRequestProto::set_src(const ::std::string& value) {
2359  set_has_src();
2360  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2361  // @@protoc_insertion_point(field_set:hadoop.hdfs.RemoveAclEntriesRequestProto.src)
2362 }
2363 inline void RemoveAclEntriesRequestProto::set_src(const char* value) {
2364  set_has_src();
2365  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2366  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.RemoveAclEntriesRequestProto.src)
2367 }
2368 inline void RemoveAclEntriesRequestProto::set_src(const char* value, size_t size) {
2369  set_has_src();
2370  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2371  ::std::string(reinterpret_cast<const char*>(value), size));
2372  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.RemoveAclEntriesRequestProto.src)
2373 }
2374 inline ::std::string* RemoveAclEntriesRequestProto::mutable_src() {
2375  set_has_src();
2376  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RemoveAclEntriesRequestProto.src)
2377  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2378 }
2379 inline ::std::string* RemoveAclEntriesRequestProto::release_src() {
2380  // @@protoc_insertion_point(field_release:hadoop.hdfs.RemoveAclEntriesRequestProto.src)
2381  clear_has_src();
2382  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2383 }
2384 inline void RemoveAclEntriesRequestProto::set_allocated_src(::std::string* src) {
2385  if (src != NULL) {
2386  set_has_src();
2387  } else {
2388  clear_has_src();
2389  }
2390  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
2391  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.RemoveAclEntriesRequestProto.src)
2392 }
2393 
2394 // repeated .hadoop.hdfs.AclEntryProto aclSpec = 2;
2395 inline int RemoveAclEntriesRequestProto::aclspec_size() const {
2396  return aclspec_.size();
2397 }
2398 inline void RemoveAclEntriesRequestProto::clear_aclspec() {
2399  aclspec_.Clear();
2400 }
2401 inline const ::hadoop::hdfs::AclEntryProto& RemoveAclEntriesRequestProto::aclspec(int index) const {
2402  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoveAclEntriesRequestProto.aclSpec)
2403  return aclspec_.Get(index);
2404 }
2405 inline ::hadoop::hdfs::AclEntryProto* RemoveAclEntriesRequestProto::mutable_aclspec(int index) {
2406  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RemoveAclEntriesRequestProto.aclSpec)
2407  return aclspec_.Mutable(index);
2408 }
2409 inline ::hadoop::hdfs::AclEntryProto* RemoveAclEntriesRequestProto::add_aclspec() {
2410  // @@protoc_insertion_point(field_add:hadoop.hdfs.RemoveAclEntriesRequestProto.aclSpec)
2411  return aclspec_.Add();
2412 }
2413 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
2414 RemoveAclEntriesRequestProto::mutable_aclspec() {
2415  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.RemoveAclEntriesRequestProto.aclSpec)
2416  return &aclspec_;
2417 }
2418 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
2419 RemoveAclEntriesRequestProto::aclspec() const {
2420  // @@protoc_insertion_point(field_list:hadoop.hdfs.RemoveAclEntriesRequestProto.aclSpec)
2421  return aclspec_;
2422 }
2423 
2424 // -------------------------------------------------------------------
2425 
2426 // RemoveAclEntriesResponseProto
2427 
2428 // -------------------------------------------------------------------
2429 
2430 // RemoveDefaultAclRequestProto
2431 
2432 // required string src = 1;
2433 inline bool RemoveDefaultAclRequestProto::has_src() const {
2434  return (_has_bits_[0] & 0x00000001u) != 0;
2435 }
2436 inline void RemoveDefaultAclRequestProto::set_has_src() {
2437  _has_bits_[0] |= 0x00000001u;
2438 }
2439 inline void RemoveDefaultAclRequestProto::clear_has_src() {
2440  _has_bits_[0] &= ~0x00000001u;
2441 }
2442 inline void RemoveDefaultAclRequestProto::clear_src() {
2443  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2444  clear_has_src();
2445 }
2446 inline const ::std::string& RemoveDefaultAclRequestProto::src() const {
2447  // @@protoc_insertion_point(field_get:hadoop.hdfs.RemoveDefaultAclRequestProto.src)
2448  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2449 }
2450 inline void RemoveDefaultAclRequestProto::set_src(const ::std::string& value) {
2451  set_has_src();
2452  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2453  // @@protoc_insertion_point(field_set:hadoop.hdfs.RemoveDefaultAclRequestProto.src)
2454 }
2455 inline void RemoveDefaultAclRequestProto::set_src(const char* value) {
2456  set_has_src();
2457  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2458  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.RemoveDefaultAclRequestProto.src)
2459 }
2460 inline void RemoveDefaultAclRequestProto::set_src(const char* value, size_t size) {
2461  set_has_src();
2462  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2463  ::std::string(reinterpret_cast<const char*>(value), size));
2464  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.RemoveDefaultAclRequestProto.src)
2465 }
2466 inline ::std::string* RemoveDefaultAclRequestProto::mutable_src() {
2467  set_has_src();
2468  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.RemoveDefaultAclRequestProto.src)
2469  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2470 }
2471 inline ::std::string* RemoveDefaultAclRequestProto::release_src() {
2472  // @@protoc_insertion_point(field_release:hadoop.hdfs.RemoveDefaultAclRequestProto.src)
2473  clear_has_src();
2474  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2475 }
2476 inline void RemoveDefaultAclRequestProto::set_allocated_src(::std::string* src) {
2477  if (src != NULL) {
2478  set_has_src();
2479  } else {
2480  clear_has_src();
2481  }
2482  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
2483  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.RemoveDefaultAclRequestProto.src)
2484 }
2485 
2486 // -------------------------------------------------------------------
2487 
2488 // RemoveDefaultAclResponseProto
2489 
2490 // -------------------------------------------------------------------
2491 
2492 // SetAclRequestProto
2493 
2494 // required string src = 1;
2495 inline bool SetAclRequestProto::has_src() const {
2496  return (_has_bits_[0] & 0x00000001u) != 0;
2497 }
2498 inline void SetAclRequestProto::set_has_src() {
2499  _has_bits_[0] |= 0x00000001u;
2500 }
2501 inline void SetAclRequestProto::clear_has_src() {
2502  _has_bits_[0] &= ~0x00000001u;
2503 }
2504 inline void SetAclRequestProto::clear_src() {
2505  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2506  clear_has_src();
2507 }
2508 inline const ::std::string& SetAclRequestProto::src() const {
2509  // @@protoc_insertion_point(field_get:hadoop.hdfs.SetAclRequestProto.src)
2510  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2511 }
2512 inline void SetAclRequestProto::set_src(const ::std::string& value) {
2513  set_has_src();
2514  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2515  // @@protoc_insertion_point(field_set:hadoop.hdfs.SetAclRequestProto.src)
2516 }
2517 inline void SetAclRequestProto::set_src(const char* value) {
2518  set_has_src();
2519  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2520  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.SetAclRequestProto.src)
2521 }
2522 inline void SetAclRequestProto::set_src(const char* value, size_t size) {
2523  set_has_src();
2524  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2525  ::std::string(reinterpret_cast<const char*>(value), size));
2526  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.SetAclRequestProto.src)
2527 }
2528 inline ::std::string* SetAclRequestProto::mutable_src() {
2529  set_has_src();
2530  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SetAclRequestProto.src)
2531  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2532 }
2533 inline ::std::string* SetAclRequestProto::release_src() {
2534  // @@protoc_insertion_point(field_release:hadoop.hdfs.SetAclRequestProto.src)
2535  clear_has_src();
2536  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2537 }
2538 inline void SetAclRequestProto::set_allocated_src(::std::string* src) {
2539  if (src != NULL) {
2540  set_has_src();
2541  } else {
2542  clear_has_src();
2543  }
2544  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
2545  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.SetAclRequestProto.src)
2546 }
2547 
2548 // repeated .hadoop.hdfs.AclEntryProto aclSpec = 2;
2549 inline int SetAclRequestProto::aclspec_size() const {
2550  return aclspec_.size();
2551 }
2552 inline void SetAclRequestProto::clear_aclspec() {
2553  aclspec_.Clear();
2554 }
2555 inline const ::hadoop::hdfs::AclEntryProto& SetAclRequestProto::aclspec(int index) const {
2556  // @@protoc_insertion_point(field_get:hadoop.hdfs.SetAclRequestProto.aclSpec)
2557  return aclspec_.Get(index);
2558 }
2559 inline ::hadoop::hdfs::AclEntryProto* SetAclRequestProto::mutable_aclspec(int index) {
2560  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.SetAclRequestProto.aclSpec)
2561  return aclspec_.Mutable(index);
2562 }
2563 inline ::hadoop::hdfs::AclEntryProto* SetAclRequestProto::add_aclspec() {
2564  // @@protoc_insertion_point(field_add:hadoop.hdfs.SetAclRequestProto.aclSpec)
2565  return aclspec_.Add();
2566 }
2567 inline ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >*
2568 SetAclRequestProto::mutable_aclspec() {
2569  // @@protoc_insertion_point(field_mutable_list:hadoop.hdfs.SetAclRequestProto.aclSpec)
2570  return &aclspec_;
2571 }
2572 inline const ::google::protobuf::RepeatedPtrField< ::hadoop::hdfs::AclEntryProto >&
2573 SetAclRequestProto::aclspec() const {
2574  // @@protoc_insertion_point(field_list:hadoop.hdfs.SetAclRequestProto.aclSpec)
2575  return aclspec_;
2576 }
2577 
2578 // -------------------------------------------------------------------
2579 
2580 // SetAclResponseProto
2581 
2582 // -------------------------------------------------------------------
2583 
2584 // GetAclStatusRequestProto
2585 
2586 // required string src = 1;
2587 inline bool GetAclStatusRequestProto::has_src() const {
2588  return (_has_bits_[0] & 0x00000001u) != 0;
2589 }
2590 inline void GetAclStatusRequestProto::set_has_src() {
2591  _has_bits_[0] |= 0x00000001u;
2592 }
2593 inline void GetAclStatusRequestProto::clear_has_src() {
2594  _has_bits_[0] &= ~0x00000001u;
2595 }
2596 inline void GetAclStatusRequestProto::clear_src() {
2597  src_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2598  clear_has_src();
2599 }
2600 inline const ::std::string& GetAclStatusRequestProto::src() const {
2601  // @@protoc_insertion_point(field_get:hadoop.hdfs.GetAclStatusRequestProto.src)
2602  return src_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2603 }
2604 inline void GetAclStatusRequestProto::set_src(const ::std::string& value) {
2605  set_has_src();
2606  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2607  // @@protoc_insertion_point(field_set:hadoop.hdfs.GetAclStatusRequestProto.src)
2608 }
2609 inline void GetAclStatusRequestProto::set_src(const char* value) {
2610  set_has_src();
2611  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2612  // @@protoc_insertion_point(field_set_char:hadoop.hdfs.GetAclStatusRequestProto.src)
2613 }
2614 inline void GetAclStatusRequestProto::set_src(const char* value, size_t size) {
2615  set_has_src();
2616  src_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2617  ::std::string(reinterpret_cast<const char*>(value), size));
2618  // @@protoc_insertion_point(field_set_pointer:hadoop.hdfs.GetAclStatusRequestProto.src)
2619 }
2620 inline ::std::string* GetAclStatusRequestProto::mutable_src() {
2621  set_has_src();
2622  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.GetAclStatusRequestProto.src)
2623  return src_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2624 }
2625 inline ::std::string* GetAclStatusRequestProto::release_src() {
2626  // @@protoc_insertion_point(field_release:hadoop.hdfs.GetAclStatusRequestProto.src)
2627  clear_has_src();
2628  return src_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2629 }
2630 inline void GetAclStatusRequestProto::set_allocated_src(::std::string* src) {
2631  if (src != NULL) {
2632  set_has_src();
2633  } else {
2634  clear_has_src();
2635  }
2636  src_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), src);
2637  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.GetAclStatusRequestProto.src)
2638 }
2639 
2640 // -------------------------------------------------------------------
2641 
2642 // GetAclStatusResponseProto
2643 
2644 // required .hadoop.hdfs.AclStatusProto result = 1;
2645 inline bool GetAclStatusResponseProto::has_result() const {
2646  return (_has_bits_[0] & 0x00000001u) != 0;
2647 }
2648 inline void GetAclStatusResponseProto::set_has_result() {
2649  _has_bits_[0] |= 0x00000001u;
2650 }
2651 inline void GetAclStatusResponseProto::clear_has_result() {
2652  _has_bits_[0] &= ~0x00000001u;
2653 }
2654 inline void GetAclStatusResponseProto::clear_result() {
2655  if (result_ != NULL) result_->::hadoop::hdfs::AclStatusProto::Clear();
2656  clear_has_result();
2657 }
2658 inline const ::hadoop::hdfs::AclStatusProto& GetAclStatusResponseProto::result() const {
2659  // @@protoc_insertion_point(field_get:hadoop.hdfs.GetAclStatusResponseProto.result)
2660  return result_ != NULL ? *result_ : *default_instance_->result_;
2661 }
2662 inline ::hadoop::hdfs::AclStatusProto* GetAclStatusResponseProto::mutable_result() {
2663  set_has_result();
2664  if (result_ == NULL) {
2665  result_ = new ::hadoop::hdfs::AclStatusProto;
2666  }
2667  // @@protoc_insertion_point(field_mutable:hadoop.hdfs.GetAclStatusResponseProto.result)
2668  return result_;
2669 }
2670 inline ::hadoop::hdfs::AclStatusProto* GetAclStatusResponseProto::release_result() {
2671  // @@protoc_insertion_point(field_release:hadoop.hdfs.GetAclStatusResponseProto.result)
2672  clear_has_result();
2673  ::hadoop::hdfs::AclStatusProto* temp = result_;
2674  result_ = NULL;
2675  return temp;
2676 }
2677 inline void GetAclStatusResponseProto::set_allocated_result(::hadoop::hdfs::AclStatusProto* result) {
2678  delete result_;
2679  result_ = result;
2680  if (result) {
2681  set_has_result();
2682  } else {
2683  clear_has_result();
2684  }
2685  // @@protoc_insertion_point(field_set_allocated:hadoop.hdfs.GetAclStatusResponseProto.result)
2686 }
2687 
2688 #endif // !PROTOBUF_INLINE_NOT_IN_HEADERS
2689 // -------------------------------------------------------------------
2690 
2691 // -------------------------------------------------------------------
2692 
2693 // -------------------------------------------------------------------
2694 
2695 // -------------------------------------------------------------------
2696 
2697 // -------------------------------------------------------------------
2698 
2699 // -------------------------------------------------------------------
2700 
2701 // -------------------------------------------------------------------
2702 
2703 // -------------------------------------------------------------------
2704 
2705 // -------------------------------------------------------------------
2706 
2707 // -------------------------------------------------------------------
2708 
2709 // -------------------------------------------------------------------
2710 
2711 // -------------------------------------------------------------------
2712 
2713 // -------------------------------------------------------------------
2714 
2715 // -------------------------------------------------------------------
2716 
2717 
2718 // @@protoc_insertion_point(namespace_scope)
2719 
2720 } // namespace hdfs
2721 } // namespace hadoop
2722 
2723 #ifndef SWIG
2724 namespace google {
2725 namespace protobuf {
2726 
2727 template <> struct is_proto_enum< ::hadoop::hdfs::AclEntryProto_AclEntryScopeProto> : ::google::protobuf::internal::true_type {};
2728 template <>
2729 inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::AclEntryProto_AclEntryScopeProto>() {
2730  return ::hadoop::hdfs::AclEntryProto_AclEntryScopeProto_descriptor();
2731 }
2732 template <> struct is_proto_enum< ::hadoop::hdfs::AclEntryProto_AclEntryTypeProto> : ::google::protobuf::internal::true_type {};
2733 template <>
2734 inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::AclEntryProto_AclEntryTypeProto>() {
2735  return ::hadoop::hdfs::AclEntryProto_AclEntryTypeProto_descriptor();
2736 }
2737 template <> struct is_proto_enum< ::hadoop::hdfs::AclEntryProto_FsActionProto> : ::google::protobuf::internal::true_type {};
2738 template <>
2739 inline const EnumDescriptor* GetEnumDescriptor< ::hadoop::hdfs::AclEntryProto_FsActionProto>() {
2740  return ::hadoop::hdfs::AclEntryProto_FsActionProto_descriptor();
2741 }
2742 
2743 } // namespace protobuf
2744 } // namespace google
2745 #endif // SWIG
2746 
2747 // @@protoc_insertion_point(global_scope)
2748 
2749 #endif // PROTOBUF_acl_2eproto__INCLUDED
hadoop::hdfs::SetAclResponseProto
Definition: acl.pb.h:1473
hadoop::hdfs::RemoveAclResponseProto
Definition: acl.pb.h:904
hadoop::hdfs::SetAclRequestProto
Definition: acl.pb.h:1362
hadoop::hdfs::AclEntryProto
Definition: acl.pb.h:125
hadoop::hdfs::AclStatusProto
Definition: acl.pb.h:350
hadoop::hdfs::AclEditLogProto
Definition: acl.pb.h:501
hadoop::hdfs::RemoveAclRequestProto
Definition: acl.pb.h:806
hadoop::hdfs::FsPermissionProto
Definition: hdfs.pb.h:1920
Generated by   doxygen 1.8.6