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