1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: RpcHeader.proto
3
4#ifndef PROTOBUF_INCLUDED_RpcHeader_2eproto
5#define PROTOBUF_INCLUDED_RpcHeader_2eproto
6
7#include <string>
8
9#include <google/protobuf/stubs/common.h>
10
11#if GOOGLE_PROTOBUF_VERSION < 3006001
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 3006001 < 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/io/coded_stream.h>
23#include <google/protobuf/arena.h>
24#include <google/protobuf/arenastring.h>
25#include <google/protobuf/generated_message_table_driven.h>
26#include <google/protobuf/generated_message_util.h>
27#include <google/protobuf/inlined_string_field.h>
28#include <google/protobuf/metadata.h>
29#include <google/protobuf/message.h>
30#include <google/protobuf/repeated_field.h> // IWYU pragma: export
31#include <google/protobuf/extension_set.h> // IWYU pragma: export
32#include <google/protobuf/generated_enum_reflection.h>
33#include <google/protobuf/unknown_field_set.h>
34// @@protoc_insertion_point(includes)
35#define PROTOBUF_INTERNAL_EXPORT_protobuf_RpcHeader_2eproto
36
37namespace protobuf_RpcHeader_2eproto {
38// Internal implementation detail -- do not use these members.
39struct TableStruct {
40 static const ::google::protobuf::internal::ParseTableField entries[];
41 static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
42 static const ::google::protobuf::internal::ParseTable schema[4];
43 static const ::google::protobuf::internal::FieldMetadata field_metadata[];
44 static const ::google::protobuf::internal::SerializationTable serialization_table[];
45 static const ::google::protobuf::uint32 offsets[];
46};
47void AddDescriptors();
48} // namespace protobuf_RpcHeader_2eproto
49namespace Hdfs {
50namespace Internal {
51class RpcRequestHeaderProto;
52class RpcRequestHeaderProtoDefaultTypeInternal;
53extern RpcRequestHeaderProtoDefaultTypeInternal _RpcRequestHeaderProto_default_instance_;
54class RpcResponseHeaderProto;
55class RpcResponseHeaderProtoDefaultTypeInternal;
56extern RpcResponseHeaderProtoDefaultTypeInternal _RpcResponseHeaderProto_default_instance_;
57class RpcSaslProto;
58class RpcSaslProtoDefaultTypeInternal;
59extern RpcSaslProtoDefaultTypeInternal _RpcSaslProto_default_instance_;
60class RpcSaslProto_SaslAuth;
61class RpcSaslProto_SaslAuthDefaultTypeInternal;
62extern RpcSaslProto_SaslAuthDefaultTypeInternal _RpcSaslProto_SaslAuth_default_instance_;
63} // namespace Internal
64} // namespace Hdfs
65namespace google {
66namespace protobuf {
67template<> ::Hdfs::Internal::RpcRequestHeaderProto* Arena::CreateMaybeMessage<::Hdfs::Internal::RpcRequestHeaderProto>(Arena*);
68template<> ::Hdfs::Internal::RpcResponseHeaderProto* Arena::CreateMaybeMessage<::Hdfs::Internal::RpcResponseHeaderProto>(Arena*);
69template<> ::Hdfs::Internal::RpcSaslProto* Arena::CreateMaybeMessage<::Hdfs::Internal::RpcSaslProto>(Arena*);
70template<> ::Hdfs::Internal::RpcSaslProto_SaslAuth* Arena::CreateMaybeMessage<::Hdfs::Internal::RpcSaslProto_SaslAuth>(Arena*);
71} // namespace protobuf
72} // namespace google
73namespace Hdfs {
74namespace Internal {
75
76enum RpcRequestHeaderProto_OperationProto {
77 RpcRequestHeaderProto_OperationProto_RPC_FINAL_PACKET = 0,
78 RpcRequestHeaderProto_OperationProto_RPC_CONTINUATION_PACKET = 1,
79 RpcRequestHeaderProto_OperationProto_RPC_CLOSE_CONNECTION = 2
80};
81bool RpcRequestHeaderProto_OperationProto_IsValid(int value);
82const RpcRequestHeaderProto_OperationProto RpcRequestHeaderProto_OperationProto_OperationProto_MIN = RpcRequestHeaderProto_OperationProto_RPC_FINAL_PACKET;
83const RpcRequestHeaderProto_OperationProto RpcRequestHeaderProto_OperationProto_OperationProto_MAX = RpcRequestHeaderProto_OperationProto_RPC_CLOSE_CONNECTION;
84const int RpcRequestHeaderProto_OperationProto_OperationProto_ARRAYSIZE = RpcRequestHeaderProto_OperationProto_OperationProto_MAX + 1;
85
86const ::google::protobuf::EnumDescriptor* RpcRequestHeaderProto_OperationProto_descriptor();
87inline const ::std::string& RpcRequestHeaderProto_OperationProto_Name(RpcRequestHeaderProto_OperationProto value) {
88 return ::google::protobuf::internal::NameOfEnum(
89 RpcRequestHeaderProto_OperationProto_descriptor(), value);
90}
91inline bool RpcRequestHeaderProto_OperationProto_Parse(
92 const ::std::string& name, RpcRequestHeaderProto_OperationProto* value) {
93 return ::google::protobuf::internal::ParseNamedEnum<RpcRequestHeaderProto_OperationProto>(
94 RpcRequestHeaderProto_OperationProto_descriptor(), name, value);
95}
96enum RpcResponseHeaderProto_RpcStatusProto {
97 RpcResponseHeaderProto_RpcStatusProto_SUCCESS = 0,
98 RpcResponseHeaderProto_RpcStatusProto_ERROR = 1,
99 RpcResponseHeaderProto_RpcStatusProto_FATAL = 2
100};
101bool RpcResponseHeaderProto_RpcStatusProto_IsValid(int value);
102const RpcResponseHeaderProto_RpcStatusProto RpcResponseHeaderProto_RpcStatusProto_RpcStatusProto_MIN = RpcResponseHeaderProto_RpcStatusProto_SUCCESS;
103const RpcResponseHeaderProto_RpcStatusProto RpcResponseHeaderProto_RpcStatusProto_RpcStatusProto_MAX = RpcResponseHeaderProto_RpcStatusProto_FATAL;
104const int RpcResponseHeaderProto_RpcStatusProto_RpcStatusProto_ARRAYSIZE = RpcResponseHeaderProto_RpcStatusProto_RpcStatusProto_MAX + 1;
105
106const ::google::protobuf::EnumDescriptor* RpcResponseHeaderProto_RpcStatusProto_descriptor();
107inline const ::std::string& RpcResponseHeaderProto_RpcStatusProto_Name(RpcResponseHeaderProto_RpcStatusProto value) {
108 return ::google::protobuf::internal::NameOfEnum(
109 RpcResponseHeaderProto_RpcStatusProto_descriptor(), value);
110}
111inline bool RpcResponseHeaderProto_RpcStatusProto_Parse(
112 const ::std::string& name, RpcResponseHeaderProto_RpcStatusProto* value) {
113 return ::google::protobuf::internal::ParseNamedEnum<RpcResponseHeaderProto_RpcStatusProto>(
114 RpcResponseHeaderProto_RpcStatusProto_descriptor(), name, value);
115}
116enum RpcResponseHeaderProto_RpcErrorCodeProto {
117 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_APPLICATION = 1,
118 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_NO_SUCH_METHOD = 2,
119 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_NO_SUCH_PROTOCOL = 3,
120 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_RPC_SERVER = 4,
121 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_SERIALIZING_RESPONSE = 5,
122 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_RPC_VERSION_MISMATCH = 6,
123 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_UNKNOWN = 10,
124 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_UNSUPPORTED_SERIALIZATION = 11,
125 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_INVALID_RPC_HEADER = 12,
126 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_DESERIALIZING_REQUEST = 13,
127 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_VERSION_MISMATCH = 14,
128 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_UNAUTHORIZED = 15
129};
130bool RpcResponseHeaderProto_RpcErrorCodeProto_IsValid(int value);
131const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto_RpcErrorCodeProto_RpcErrorCodeProto_MIN = RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_APPLICATION;
132const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto_RpcErrorCodeProto_RpcErrorCodeProto_MAX = RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_UNAUTHORIZED;
133const int RpcResponseHeaderProto_RpcErrorCodeProto_RpcErrorCodeProto_ARRAYSIZE = RpcResponseHeaderProto_RpcErrorCodeProto_RpcErrorCodeProto_MAX + 1;
134
135const ::google::protobuf::EnumDescriptor* RpcResponseHeaderProto_RpcErrorCodeProto_descriptor();
136inline const ::std::string& RpcResponseHeaderProto_RpcErrorCodeProto_Name(RpcResponseHeaderProto_RpcErrorCodeProto value) {
137 return ::google::protobuf::internal::NameOfEnum(
138 RpcResponseHeaderProto_RpcErrorCodeProto_descriptor(), value);
139}
140inline bool RpcResponseHeaderProto_RpcErrorCodeProto_Parse(
141 const ::std::string& name, RpcResponseHeaderProto_RpcErrorCodeProto* value) {
142 return ::google::protobuf::internal::ParseNamedEnum<RpcResponseHeaderProto_RpcErrorCodeProto>(
143 RpcResponseHeaderProto_RpcErrorCodeProto_descriptor(), name, value);
144}
145enum RpcSaslProto_SaslState {
146 RpcSaslProto_SaslState_SUCCESS = 0,
147 RpcSaslProto_SaslState_NEGOTIATE = 1,
148 RpcSaslProto_SaslState_INITIATE = 2,
149 RpcSaslProto_SaslState_CHALLENGE = 3,
150 RpcSaslProto_SaslState_RESPONSE = 4,
151 RpcSaslProto_SaslState_WRAP = 5
152};
153bool RpcSaslProto_SaslState_IsValid(int value);
154const RpcSaslProto_SaslState RpcSaslProto_SaslState_SaslState_MIN = RpcSaslProto_SaslState_SUCCESS;
155const RpcSaslProto_SaslState RpcSaslProto_SaslState_SaslState_MAX = RpcSaslProto_SaslState_WRAP;
156const int RpcSaslProto_SaslState_SaslState_ARRAYSIZE = RpcSaslProto_SaslState_SaslState_MAX + 1;
157
158const ::google::protobuf::EnumDescriptor* RpcSaslProto_SaslState_descriptor();
159inline const ::std::string& RpcSaslProto_SaslState_Name(RpcSaslProto_SaslState value) {
160 return ::google::protobuf::internal::NameOfEnum(
161 RpcSaslProto_SaslState_descriptor(), value);
162}
163inline bool RpcSaslProto_SaslState_Parse(
164 const ::std::string& name, RpcSaslProto_SaslState* value) {
165 return ::google::protobuf::internal::ParseNamedEnum<RpcSaslProto_SaslState>(
166 RpcSaslProto_SaslState_descriptor(), name, value);
167}
168enum RpcKindProto {
169 RPC_BUILTIN = 0,
170 RPC_WRITABLE = 1,
171 RPC_PROTOCOL_BUFFER = 2
172};
173bool RpcKindProto_IsValid(int value);
174const RpcKindProto RpcKindProto_MIN = RPC_BUILTIN;
175const RpcKindProto RpcKindProto_MAX = RPC_PROTOCOL_BUFFER;
176const int RpcKindProto_ARRAYSIZE = RpcKindProto_MAX + 1;
177
178const ::google::protobuf::EnumDescriptor* RpcKindProto_descriptor();
179inline const ::std::string& RpcKindProto_Name(RpcKindProto value) {
180 return ::google::protobuf::internal::NameOfEnum(
181 RpcKindProto_descriptor(), value);
182}
183inline bool RpcKindProto_Parse(
184 const ::std::string& name, RpcKindProto* value) {
185 return ::google::protobuf::internal::ParseNamedEnum<RpcKindProto>(
186 RpcKindProto_descriptor(), name, value);
187}
188// ===================================================================
189
190class RpcRequestHeaderProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RpcRequestHeaderProto) */ {
191 public:
192 RpcRequestHeaderProto();
193 virtual ~RpcRequestHeaderProto();
194
195 RpcRequestHeaderProto(const RpcRequestHeaderProto& from);
196
197 inline RpcRequestHeaderProto& operator=(const RpcRequestHeaderProto& from) {
198 CopyFrom(from);
199 return *this;
200 }
201 #if LANG_CXX11
202 RpcRequestHeaderProto(RpcRequestHeaderProto&& from) noexcept
203 : RpcRequestHeaderProto() {
204 *this = ::std::move(from);
205 }
206
207 inline RpcRequestHeaderProto& operator=(RpcRequestHeaderProto&& from) noexcept {
208 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
209 if (this != &from) InternalSwap(&from);
210 } else {
211 CopyFrom(from);
212 }
213 return *this;
214 }
215 #endif
216 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
217 return _internal_metadata_.unknown_fields();
218 }
219 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
220 return _internal_metadata_.mutable_unknown_fields();
221 }
222
223 static const ::google::protobuf::Descriptor* descriptor();
224 static const RpcRequestHeaderProto& default_instance();
225
226 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
227 static inline const RpcRequestHeaderProto* internal_default_instance() {
228 return reinterpret_cast<const RpcRequestHeaderProto*>(
229 &_RpcRequestHeaderProto_default_instance_);
230 }
231 static constexpr int kIndexInFileMessages =
232 0;
233
234 void Swap(RpcRequestHeaderProto* other);
235 friend void swap(RpcRequestHeaderProto& a, RpcRequestHeaderProto& b) {
236 a.Swap(&b);
237 }
238
239 // implements Message ----------------------------------------------
240
241 inline RpcRequestHeaderProto* New() const final {
242 return CreateMaybeMessage<RpcRequestHeaderProto>(NULL);
243 }
244
245 RpcRequestHeaderProto* New(::google::protobuf::Arena* arena) const final {
246 return CreateMaybeMessage<RpcRequestHeaderProto>(arena);
247 }
248 void CopyFrom(const ::google::protobuf::Message& from) final;
249 void MergeFrom(const ::google::protobuf::Message& from) final;
250 void CopyFrom(const RpcRequestHeaderProto& from);
251 void MergeFrom(const RpcRequestHeaderProto& from);
252 void Clear() final;
253 bool IsInitialized() const final;
254
255 size_t ByteSizeLong() const final;
256 bool MergePartialFromCodedStream(
257 ::google::protobuf::io::CodedInputStream* input) final;
258 void SerializeWithCachedSizes(
259 ::google::protobuf::io::CodedOutputStream* output) const final;
260 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
261 bool deterministic, ::google::protobuf::uint8* target) const final;
262 int GetCachedSize() const final { return _cached_size_.Get(); }
263
264 private:
265 void SharedCtor();
266 void SharedDtor();
267 void SetCachedSize(int size) const final;
268 void InternalSwap(RpcRequestHeaderProto* other);
269 private:
270 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
271 return NULL;
272 }
273 inline void* MaybeArenaPtr() const {
274 return NULL;
275 }
276 public:
277
278 ::google::protobuf::Metadata GetMetadata() const final;
279
280 // nested types ----------------------------------------------------
281
282 typedef RpcRequestHeaderProto_OperationProto OperationProto;
283 static const OperationProto RPC_FINAL_PACKET =
284 RpcRequestHeaderProto_OperationProto_RPC_FINAL_PACKET;
285 static const OperationProto RPC_CONTINUATION_PACKET =
286 RpcRequestHeaderProto_OperationProto_RPC_CONTINUATION_PACKET;
287 static const OperationProto RPC_CLOSE_CONNECTION =
288 RpcRequestHeaderProto_OperationProto_RPC_CLOSE_CONNECTION;
289 static inline bool OperationProto_IsValid(int value) {
290 return RpcRequestHeaderProto_OperationProto_IsValid(value);
291 }
292 static const OperationProto OperationProto_MIN =
293 RpcRequestHeaderProto_OperationProto_OperationProto_MIN;
294 static const OperationProto OperationProto_MAX =
295 RpcRequestHeaderProto_OperationProto_OperationProto_MAX;
296 static const int OperationProto_ARRAYSIZE =
297 RpcRequestHeaderProto_OperationProto_OperationProto_ARRAYSIZE;
298 static inline const ::google::protobuf::EnumDescriptor*
299 OperationProto_descriptor() {
300 return RpcRequestHeaderProto_OperationProto_descriptor();
301 }
302 static inline const ::std::string& OperationProto_Name(OperationProto value) {
303 return RpcRequestHeaderProto_OperationProto_Name(value);
304 }
305 static inline bool OperationProto_Parse(const ::std::string& name,
306 OperationProto* value) {
307 return RpcRequestHeaderProto_OperationProto_Parse(name, value);
308 }
309
310 // accessors -------------------------------------------------------
311
312 // required bytes clientId = 4;
313 bool has_clientid() const;
314 void clear_clientid();
315 static const int kClientIdFieldNumber = 4;
316 const ::std::string& clientid() const;
317 void set_clientid(const ::std::string& value);
318 #if LANG_CXX11
319 void set_clientid(::std::string&& value);
320 #endif
321 void set_clientid(const char* value);
322 void set_clientid(const void* value, size_t size);
323 ::std::string* mutable_clientid();
324 ::std::string* release_clientid();
325 void set_allocated_clientid(::std::string* clientid);
326
327 // optional .Hdfs.Internal.RpcKindProto rpcKind = 1;
328 bool has_rpckind() const;
329 void clear_rpckind();
330 static const int kRpcKindFieldNumber = 1;
331 ::Hdfs::Internal::RpcKindProto rpckind() const;
332 void set_rpckind(::Hdfs::Internal::RpcKindProto value);
333
334 // optional .Hdfs.Internal.RpcRequestHeaderProto.OperationProto rpcOp = 2;
335 bool has_rpcop() const;
336 void clear_rpcop();
337 static const int kRpcOpFieldNumber = 2;
338 ::Hdfs::Internal::RpcRequestHeaderProto_OperationProto rpcop() const;
339 void set_rpcop(::Hdfs::Internal::RpcRequestHeaderProto_OperationProto value);
340
341 // required sint32 callId = 3;
342 bool has_callid() const;
343 void clear_callid();
344 static const int kCallIdFieldNumber = 3;
345 ::google::protobuf::int32 callid() const;
346 void set_callid(::google::protobuf::int32 value);
347
348 // optional sint32 retryCount = 5 [default = -1];
349 bool has_retrycount() const;
350 void clear_retrycount();
351 static const int kRetryCountFieldNumber = 5;
352 ::google::protobuf::int32 retrycount() const;
353 void set_retrycount(::google::protobuf::int32 value);
354
355 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RpcRequestHeaderProto)
356 private:
357 void set_has_rpckind();
358 void clear_has_rpckind();
359 void set_has_rpcop();
360 void clear_has_rpcop();
361 void set_has_callid();
362 void clear_has_callid();
363 void set_has_clientid();
364 void clear_has_clientid();
365 void set_has_retrycount();
366 void clear_has_retrycount();
367
368 // helper for ByteSizeLong()
369 size_t RequiredFieldsByteSizeFallback() const;
370
371 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
372 ::google::protobuf::internal::HasBits<1> _has_bits_;
373 mutable ::google::protobuf::internal::CachedSize _cached_size_;
374 ::google::protobuf::internal::ArenaStringPtr clientid_;
375 int rpckind_;
376 int rpcop_;
377 ::google::protobuf::int32 callid_;
378 ::google::protobuf::int32 retrycount_;
379 friend struct ::protobuf_RpcHeader_2eproto::TableStruct;
380};
381// -------------------------------------------------------------------
382
383class RpcResponseHeaderProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RpcResponseHeaderProto) */ {
384 public:
385 RpcResponseHeaderProto();
386 virtual ~RpcResponseHeaderProto();
387
388 RpcResponseHeaderProto(const RpcResponseHeaderProto& from);
389
390 inline RpcResponseHeaderProto& operator=(const RpcResponseHeaderProto& from) {
391 CopyFrom(from);
392 return *this;
393 }
394 #if LANG_CXX11
395 RpcResponseHeaderProto(RpcResponseHeaderProto&& from) noexcept
396 : RpcResponseHeaderProto() {
397 *this = ::std::move(from);
398 }
399
400 inline RpcResponseHeaderProto& operator=(RpcResponseHeaderProto&& from) noexcept {
401 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
402 if (this != &from) InternalSwap(&from);
403 } else {
404 CopyFrom(from);
405 }
406 return *this;
407 }
408 #endif
409 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
410 return _internal_metadata_.unknown_fields();
411 }
412 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
413 return _internal_metadata_.mutable_unknown_fields();
414 }
415
416 static const ::google::protobuf::Descriptor* descriptor();
417 static const RpcResponseHeaderProto& default_instance();
418
419 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
420 static inline const RpcResponseHeaderProto* internal_default_instance() {
421 return reinterpret_cast<const RpcResponseHeaderProto*>(
422 &_RpcResponseHeaderProto_default_instance_);
423 }
424 static constexpr int kIndexInFileMessages =
425 1;
426
427 void Swap(RpcResponseHeaderProto* other);
428 friend void swap(RpcResponseHeaderProto& a, RpcResponseHeaderProto& b) {
429 a.Swap(&b);
430 }
431
432 // implements Message ----------------------------------------------
433
434 inline RpcResponseHeaderProto* New() const final {
435 return CreateMaybeMessage<RpcResponseHeaderProto>(NULL);
436 }
437
438 RpcResponseHeaderProto* New(::google::protobuf::Arena* arena) const final {
439 return CreateMaybeMessage<RpcResponseHeaderProto>(arena);
440 }
441 void CopyFrom(const ::google::protobuf::Message& from) final;
442 void MergeFrom(const ::google::protobuf::Message& from) final;
443 void CopyFrom(const RpcResponseHeaderProto& from);
444 void MergeFrom(const RpcResponseHeaderProto& from);
445 void Clear() final;
446 bool IsInitialized() const final;
447
448 size_t ByteSizeLong() const final;
449 bool MergePartialFromCodedStream(
450 ::google::protobuf::io::CodedInputStream* input) final;
451 void SerializeWithCachedSizes(
452 ::google::protobuf::io::CodedOutputStream* output) const final;
453 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
454 bool deterministic, ::google::protobuf::uint8* target) const final;
455 int GetCachedSize() const final { return _cached_size_.Get(); }
456
457 private:
458 void SharedCtor();
459 void SharedDtor();
460 void SetCachedSize(int size) const final;
461 void InternalSwap(RpcResponseHeaderProto* other);
462 private:
463 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
464 return NULL;
465 }
466 inline void* MaybeArenaPtr() const {
467 return NULL;
468 }
469 public:
470
471 ::google::protobuf::Metadata GetMetadata() const final;
472
473 // nested types ----------------------------------------------------
474
475 typedef RpcResponseHeaderProto_RpcStatusProto RpcStatusProto;
476 static const RpcStatusProto SUCCESS =
477 RpcResponseHeaderProto_RpcStatusProto_SUCCESS;
478 static const RpcStatusProto ERROR =
479 RpcResponseHeaderProto_RpcStatusProto_ERROR;
480 static const RpcStatusProto FATAL =
481 RpcResponseHeaderProto_RpcStatusProto_FATAL;
482 static inline bool RpcStatusProto_IsValid(int value) {
483 return RpcResponseHeaderProto_RpcStatusProto_IsValid(value);
484 }
485 static const RpcStatusProto RpcStatusProto_MIN =
486 RpcResponseHeaderProto_RpcStatusProto_RpcStatusProto_MIN;
487 static const RpcStatusProto RpcStatusProto_MAX =
488 RpcResponseHeaderProto_RpcStatusProto_RpcStatusProto_MAX;
489 static const int RpcStatusProto_ARRAYSIZE =
490 RpcResponseHeaderProto_RpcStatusProto_RpcStatusProto_ARRAYSIZE;
491 static inline const ::google::protobuf::EnumDescriptor*
492 RpcStatusProto_descriptor() {
493 return RpcResponseHeaderProto_RpcStatusProto_descriptor();
494 }
495 static inline const ::std::string& RpcStatusProto_Name(RpcStatusProto value) {
496 return RpcResponseHeaderProto_RpcStatusProto_Name(value);
497 }
498 static inline bool RpcStatusProto_Parse(const ::std::string& name,
499 RpcStatusProto* value) {
500 return RpcResponseHeaderProto_RpcStatusProto_Parse(name, value);
501 }
502
503 typedef RpcResponseHeaderProto_RpcErrorCodeProto RpcErrorCodeProto;
504 static const RpcErrorCodeProto ERROR_APPLICATION =
505 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_APPLICATION;
506 static const RpcErrorCodeProto ERROR_NO_SUCH_METHOD =
507 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_NO_SUCH_METHOD;
508 static const RpcErrorCodeProto ERROR_NO_SUCH_PROTOCOL =
509 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_NO_SUCH_PROTOCOL;
510 static const RpcErrorCodeProto ERROR_RPC_SERVER =
511 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_RPC_SERVER;
512 static const RpcErrorCodeProto ERROR_SERIALIZING_RESPONSE =
513 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_SERIALIZING_RESPONSE;
514 static const RpcErrorCodeProto ERROR_RPC_VERSION_MISMATCH =
515 RpcResponseHeaderProto_RpcErrorCodeProto_ERROR_RPC_VERSION_MISMATCH;
516 static const RpcErrorCodeProto FATAL_UNKNOWN =
517 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_UNKNOWN;
518 static const RpcErrorCodeProto FATAL_UNSUPPORTED_SERIALIZATION =
519 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_UNSUPPORTED_SERIALIZATION;
520 static const RpcErrorCodeProto FATAL_INVALID_RPC_HEADER =
521 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_INVALID_RPC_HEADER;
522 static const RpcErrorCodeProto FATAL_DESERIALIZING_REQUEST =
523 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_DESERIALIZING_REQUEST;
524 static const RpcErrorCodeProto FATAL_VERSION_MISMATCH =
525 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_VERSION_MISMATCH;
526 static const RpcErrorCodeProto FATAL_UNAUTHORIZED =
527 RpcResponseHeaderProto_RpcErrorCodeProto_FATAL_UNAUTHORIZED;
528 static inline bool RpcErrorCodeProto_IsValid(int value) {
529 return RpcResponseHeaderProto_RpcErrorCodeProto_IsValid(value);
530 }
531 static const RpcErrorCodeProto RpcErrorCodeProto_MIN =
532 RpcResponseHeaderProto_RpcErrorCodeProto_RpcErrorCodeProto_MIN;
533 static const RpcErrorCodeProto RpcErrorCodeProto_MAX =
534 RpcResponseHeaderProto_RpcErrorCodeProto_RpcErrorCodeProto_MAX;
535 static const int RpcErrorCodeProto_ARRAYSIZE =
536 RpcResponseHeaderProto_RpcErrorCodeProto_RpcErrorCodeProto_ARRAYSIZE;
537 static inline const ::google::protobuf::EnumDescriptor*
538 RpcErrorCodeProto_descriptor() {
539 return RpcResponseHeaderProto_RpcErrorCodeProto_descriptor();
540 }
541 static inline const ::std::string& RpcErrorCodeProto_Name(RpcErrorCodeProto value) {
542 return RpcResponseHeaderProto_RpcErrorCodeProto_Name(value);
543 }
544 static inline bool RpcErrorCodeProto_Parse(const ::std::string& name,
545 RpcErrorCodeProto* value) {
546 return RpcResponseHeaderProto_RpcErrorCodeProto_Parse(name, value);
547 }
548
549 // accessors -------------------------------------------------------
550
551 // optional string exceptionClassName = 4;
552 bool has_exceptionclassname() const;
553 void clear_exceptionclassname();
554 static const int kExceptionClassNameFieldNumber = 4;
555 const ::std::string& exceptionclassname() const;
556 void set_exceptionclassname(const ::std::string& value);
557 #if LANG_CXX11
558 void set_exceptionclassname(::std::string&& value);
559 #endif
560 void set_exceptionclassname(const char* value);
561 void set_exceptionclassname(const char* value, size_t size);
562 ::std::string* mutable_exceptionclassname();
563 ::std::string* release_exceptionclassname();
564 void set_allocated_exceptionclassname(::std::string* exceptionclassname);
565
566 // optional string errorMsg = 5;
567 bool has_errormsg() const;
568 void clear_errormsg();
569 static const int kErrorMsgFieldNumber = 5;
570 const ::std::string& errormsg() const;
571 void set_errormsg(const ::std::string& value);
572 #if LANG_CXX11
573 void set_errormsg(::std::string&& value);
574 #endif
575 void set_errormsg(const char* value);
576 void set_errormsg(const char* value, size_t size);
577 ::std::string* mutable_errormsg();
578 ::std::string* release_errormsg();
579 void set_allocated_errormsg(::std::string* errormsg);
580
581 // optional bytes clientId = 7;
582 bool has_clientid() const;
583 void clear_clientid();
584 static const int kClientIdFieldNumber = 7;
585 const ::std::string& clientid() const;
586 void set_clientid(const ::std::string& value);
587 #if LANG_CXX11
588 void set_clientid(::std::string&& value);
589 #endif
590 void set_clientid(const char* value);
591 void set_clientid(const void* value, size_t size);
592 ::std::string* mutable_clientid();
593 ::std::string* release_clientid();
594 void set_allocated_clientid(::std::string* clientid);
595
596 // required uint32 callId = 1;
597 bool has_callid() const;
598 void clear_callid();
599 static const int kCallIdFieldNumber = 1;
600 ::google::protobuf::uint32 callid() const;
601 void set_callid(::google::protobuf::uint32 value);
602
603 // required .Hdfs.Internal.RpcResponseHeaderProto.RpcStatusProto status = 2;
604 bool has_status() const;
605 void clear_status();
606 static const int kStatusFieldNumber = 2;
607 ::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto status() const;
608 void set_status(::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto value);
609
610 // optional uint32 serverIpcVersionNum = 3;
611 bool has_serveripcversionnum() const;
612 void clear_serveripcversionnum();
613 static const int kServerIpcVersionNumFieldNumber = 3;
614 ::google::protobuf::uint32 serveripcversionnum() const;
615 void set_serveripcversionnum(::google::protobuf::uint32 value);
616
617 // optional .Hdfs.Internal.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
618 bool has_errordetail() const;
619 void clear_errordetail();
620 static const int kErrorDetailFieldNumber = 6;
621 ::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto errordetail() const;
622 void set_errordetail(::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto value);
623
624 // optional sint32 retryCount = 8 [default = -1];
625 bool has_retrycount() const;
626 void clear_retrycount();
627 static const int kRetryCountFieldNumber = 8;
628 ::google::protobuf::int32 retrycount() const;
629 void set_retrycount(::google::protobuf::int32 value);
630
631 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RpcResponseHeaderProto)
632 private:
633 void set_has_callid();
634 void clear_has_callid();
635 void set_has_status();
636 void clear_has_status();
637 void set_has_serveripcversionnum();
638 void clear_has_serveripcversionnum();
639 void set_has_exceptionclassname();
640 void clear_has_exceptionclassname();
641 void set_has_errormsg();
642 void clear_has_errormsg();
643 void set_has_errordetail();
644 void clear_has_errordetail();
645 void set_has_clientid();
646 void clear_has_clientid();
647 void set_has_retrycount();
648 void clear_has_retrycount();
649
650 // helper for ByteSizeLong()
651 size_t RequiredFieldsByteSizeFallback() const;
652
653 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
654 ::google::protobuf::internal::HasBits<1> _has_bits_;
655 mutable ::google::protobuf::internal::CachedSize _cached_size_;
656 ::google::protobuf::internal::ArenaStringPtr exceptionclassname_;
657 ::google::protobuf::internal::ArenaStringPtr errormsg_;
658 ::google::protobuf::internal::ArenaStringPtr clientid_;
659 ::google::protobuf::uint32 callid_;
660 int status_;
661 ::google::protobuf::uint32 serveripcversionnum_;
662 int errordetail_;
663 ::google::protobuf::int32 retrycount_;
664 friend struct ::protobuf_RpcHeader_2eproto::TableStruct;
665};
666// -------------------------------------------------------------------
667
668class RpcSaslProto_SaslAuth : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RpcSaslProto.SaslAuth) */ {
669 public:
670 RpcSaslProto_SaslAuth();
671 virtual ~RpcSaslProto_SaslAuth();
672
673 RpcSaslProto_SaslAuth(const RpcSaslProto_SaslAuth& from);
674
675 inline RpcSaslProto_SaslAuth& operator=(const RpcSaslProto_SaslAuth& from) {
676 CopyFrom(from);
677 return *this;
678 }
679 #if LANG_CXX11
680 RpcSaslProto_SaslAuth(RpcSaslProto_SaslAuth&& from) noexcept
681 : RpcSaslProto_SaslAuth() {
682 *this = ::std::move(from);
683 }
684
685 inline RpcSaslProto_SaslAuth& operator=(RpcSaslProto_SaslAuth&& from) noexcept {
686 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
687 if (this != &from) InternalSwap(&from);
688 } else {
689 CopyFrom(from);
690 }
691 return *this;
692 }
693 #endif
694 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
695 return _internal_metadata_.unknown_fields();
696 }
697 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
698 return _internal_metadata_.mutable_unknown_fields();
699 }
700
701 static const ::google::protobuf::Descriptor* descriptor();
702 static const RpcSaslProto_SaslAuth& default_instance();
703
704 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
705 static inline const RpcSaslProto_SaslAuth* internal_default_instance() {
706 return reinterpret_cast<const RpcSaslProto_SaslAuth*>(
707 &_RpcSaslProto_SaslAuth_default_instance_);
708 }
709 static constexpr int kIndexInFileMessages =
710 2;
711
712 void Swap(RpcSaslProto_SaslAuth* other);
713 friend void swap(RpcSaslProto_SaslAuth& a, RpcSaslProto_SaslAuth& b) {
714 a.Swap(&b);
715 }
716
717 // implements Message ----------------------------------------------
718
719 inline RpcSaslProto_SaslAuth* New() const final {
720 return CreateMaybeMessage<RpcSaslProto_SaslAuth>(NULL);
721 }
722
723 RpcSaslProto_SaslAuth* New(::google::protobuf::Arena* arena) const final {
724 return CreateMaybeMessage<RpcSaslProto_SaslAuth>(arena);
725 }
726 void CopyFrom(const ::google::protobuf::Message& from) final;
727 void MergeFrom(const ::google::protobuf::Message& from) final;
728 void CopyFrom(const RpcSaslProto_SaslAuth& from);
729 void MergeFrom(const RpcSaslProto_SaslAuth& from);
730 void Clear() final;
731 bool IsInitialized() const final;
732
733 size_t ByteSizeLong() const final;
734 bool MergePartialFromCodedStream(
735 ::google::protobuf::io::CodedInputStream* input) final;
736 void SerializeWithCachedSizes(
737 ::google::protobuf::io::CodedOutputStream* output) const final;
738 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
739 bool deterministic, ::google::protobuf::uint8* target) const final;
740 int GetCachedSize() const final { return _cached_size_.Get(); }
741
742 private:
743 void SharedCtor();
744 void SharedDtor();
745 void SetCachedSize(int size) const final;
746 void InternalSwap(RpcSaslProto_SaslAuth* other);
747 private:
748 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
749 return NULL;
750 }
751 inline void* MaybeArenaPtr() const {
752 return NULL;
753 }
754 public:
755
756 ::google::protobuf::Metadata GetMetadata() const final;
757
758 // nested types ----------------------------------------------------
759
760 // accessors -------------------------------------------------------
761
762 // required string method = 1;
763 bool has_method() const;
764 void clear_method();
765 static const int kMethodFieldNumber = 1;
766 const ::std::string& method() const;
767 void set_method(const ::std::string& value);
768 #if LANG_CXX11
769 void set_method(::std::string&& value);
770 #endif
771 void set_method(const char* value);
772 void set_method(const char* value, size_t size);
773 ::std::string* mutable_method();
774 ::std::string* release_method();
775 void set_allocated_method(::std::string* method);
776
777 // required string mechanism = 2;
778 bool has_mechanism() const;
779 void clear_mechanism();
780 static const int kMechanismFieldNumber = 2;
781 const ::std::string& mechanism() const;
782 void set_mechanism(const ::std::string& value);
783 #if LANG_CXX11
784 void set_mechanism(::std::string&& value);
785 #endif
786 void set_mechanism(const char* value);
787 void set_mechanism(const char* value, size_t size);
788 ::std::string* mutable_mechanism();
789 ::std::string* release_mechanism();
790 void set_allocated_mechanism(::std::string* mechanism);
791
792 // optional string protocol = 3;
793 bool has_protocol() const;
794 void clear_protocol();
795 static const int kProtocolFieldNumber = 3;
796 const ::std::string& protocol() const;
797 void set_protocol(const ::std::string& value);
798 #if LANG_CXX11
799 void set_protocol(::std::string&& value);
800 #endif
801 void set_protocol(const char* value);
802 void set_protocol(const char* value, size_t size);
803 ::std::string* mutable_protocol();
804 ::std::string* release_protocol();
805 void set_allocated_protocol(::std::string* protocol);
806
807 // optional string serverId = 4;
808 bool has_serverid() const;
809 void clear_serverid();
810 static const int kServerIdFieldNumber = 4;
811 const ::std::string& serverid() const;
812 void set_serverid(const ::std::string& value);
813 #if LANG_CXX11
814 void set_serverid(::std::string&& value);
815 #endif
816 void set_serverid(const char* value);
817 void set_serverid(const char* value, size_t size);
818 ::std::string* mutable_serverid();
819 ::std::string* release_serverid();
820 void set_allocated_serverid(::std::string* serverid);
821
822 // optional bytes challenge = 5;
823 bool has_challenge() const;
824 void clear_challenge();
825 static const int kChallengeFieldNumber = 5;
826 const ::std::string& challenge() const;
827 void set_challenge(const ::std::string& value);
828 #if LANG_CXX11
829 void set_challenge(::std::string&& value);
830 #endif
831 void set_challenge(const char* value);
832 void set_challenge(const void* value, size_t size);
833 ::std::string* mutable_challenge();
834 ::std::string* release_challenge();
835 void set_allocated_challenge(::std::string* challenge);
836
837 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RpcSaslProto.SaslAuth)
838 private:
839 void set_has_method();
840 void clear_has_method();
841 void set_has_mechanism();
842 void clear_has_mechanism();
843 void set_has_protocol();
844 void clear_has_protocol();
845 void set_has_serverid();
846 void clear_has_serverid();
847 void set_has_challenge();
848 void clear_has_challenge();
849
850 // helper for ByteSizeLong()
851 size_t RequiredFieldsByteSizeFallback() const;
852
853 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
854 ::google::protobuf::internal::HasBits<1> _has_bits_;
855 mutable ::google::protobuf::internal::CachedSize _cached_size_;
856 ::google::protobuf::internal::ArenaStringPtr method_;
857 ::google::protobuf::internal::ArenaStringPtr mechanism_;
858 ::google::protobuf::internal::ArenaStringPtr protocol_;
859 ::google::protobuf::internal::ArenaStringPtr serverid_;
860 ::google::protobuf::internal::ArenaStringPtr challenge_;
861 friend struct ::protobuf_RpcHeader_2eproto::TableStruct;
862};
863// -------------------------------------------------------------------
864
865class RpcSaslProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Hdfs.Internal.RpcSaslProto) */ {
866 public:
867 RpcSaslProto();
868 virtual ~RpcSaslProto();
869
870 RpcSaslProto(const RpcSaslProto& from);
871
872 inline RpcSaslProto& operator=(const RpcSaslProto& from) {
873 CopyFrom(from);
874 return *this;
875 }
876 #if LANG_CXX11
877 RpcSaslProto(RpcSaslProto&& from) noexcept
878 : RpcSaslProto() {
879 *this = ::std::move(from);
880 }
881
882 inline RpcSaslProto& operator=(RpcSaslProto&& from) noexcept {
883 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
884 if (this != &from) InternalSwap(&from);
885 } else {
886 CopyFrom(from);
887 }
888 return *this;
889 }
890 #endif
891 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
892 return _internal_metadata_.unknown_fields();
893 }
894 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
895 return _internal_metadata_.mutable_unknown_fields();
896 }
897
898 static const ::google::protobuf::Descriptor* descriptor();
899 static const RpcSaslProto& default_instance();
900
901 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
902 static inline const RpcSaslProto* internal_default_instance() {
903 return reinterpret_cast<const RpcSaslProto*>(
904 &_RpcSaslProto_default_instance_);
905 }
906 static constexpr int kIndexInFileMessages =
907 3;
908
909 void Swap(RpcSaslProto* other);
910 friend void swap(RpcSaslProto& a, RpcSaslProto& b) {
911 a.Swap(&b);
912 }
913
914 // implements Message ----------------------------------------------
915
916 inline RpcSaslProto* New() const final {
917 return CreateMaybeMessage<RpcSaslProto>(NULL);
918 }
919
920 RpcSaslProto* New(::google::protobuf::Arena* arena) const final {
921 return CreateMaybeMessage<RpcSaslProto>(arena);
922 }
923 void CopyFrom(const ::google::protobuf::Message& from) final;
924 void MergeFrom(const ::google::protobuf::Message& from) final;
925 void CopyFrom(const RpcSaslProto& from);
926 void MergeFrom(const RpcSaslProto& from);
927 void Clear() final;
928 bool IsInitialized() const final;
929
930 size_t ByteSizeLong() const final;
931 bool MergePartialFromCodedStream(
932 ::google::protobuf::io::CodedInputStream* input) final;
933 void SerializeWithCachedSizes(
934 ::google::protobuf::io::CodedOutputStream* output) const final;
935 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
936 bool deterministic, ::google::protobuf::uint8* target) const final;
937 int GetCachedSize() const final { return _cached_size_.Get(); }
938
939 private:
940 void SharedCtor();
941 void SharedDtor();
942 void SetCachedSize(int size) const final;
943 void InternalSwap(RpcSaslProto* other);
944 private:
945 inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
946 return NULL;
947 }
948 inline void* MaybeArenaPtr() const {
949 return NULL;
950 }
951 public:
952
953 ::google::protobuf::Metadata GetMetadata() const final;
954
955 // nested types ----------------------------------------------------
956
957 typedef RpcSaslProto_SaslAuth SaslAuth;
958
959 typedef RpcSaslProto_SaslState SaslState;
960 static const SaslState SUCCESS =
961 RpcSaslProto_SaslState_SUCCESS;
962 static const SaslState NEGOTIATE =
963 RpcSaslProto_SaslState_NEGOTIATE;
964 static const SaslState INITIATE =
965 RpcSaslProto_SaslState_INITIATE;
966 static const SaslState CHALLENGE =
967 RpcSaslProto_SaslState_CHALLENGE;
968 static const SaslState RESPONSE =
969 RpcSaslProto_SaslState_RESPONSE;
970 static const SaslState WRAP =
971 RpcSaslProto_SaslState_WRAP;
972 static inline bool SaslState_IsValid(int value) {
973 return RpcSaslProto_SaslState_IsValid(value);
974 }
975 static const SaslState SaslState_MIN =
976 RpcSaslProto_SaslState_SaslState_MIN;
977 static const SaslState SaslState_MAX =
978 RpcSaslProto_SaslState_SaslState_MAX;
979 static const int SaslState_ARRAYSIZE =
980 RpcSaslProto_SaslState_SaslState_ARRAYSIZE;
981 static inline const ::google::protobuf::EnumDescriptor*
982 SaslState_descriptor() {
983 return RpcSaslProto_SaslState_descriptor();
984 }
985 static inline const ::std::string& SaslState_Name(SaslState value) {
986 return RpcSaslProto_SaslState_Name(value);
987 }
988 static inline bool SaslState_Parse(const ::std::string& name,
989 SaslState* value) {
990 return RpcSaslProto_SaslState_Parse(name, value);
991 }
992
993 // accessors -------------------------------------------------------
994
995 // repeated .Hdfs.Internal.RpcSaslProto.SaslAuth auths = 4;
996 int auths_size() const;
997 void clear_auths();
998 static const int kAuthsFieldNumber = 4;
999 ::Hdfs::Internal::RpcSaslProto_SaslAuth* mutable_auths(int index);
1000 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RpcSaslProto_SaslAuth >*
1001 mutable_auths();
1002 const ::Hdfs::Internal::RpcSaslProto_SaslAuth& auths(int index) const;
1003 ::Hdfs::Internal::RpcSaslProto_SaslAuth* add_auths();
1004 const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RpcSaslProto_SaslAuth >&
1005 auths() const;
1006
1007 // optional bytes token = 3;
1008 bool has_token() const;
1009 void clear_token();
1010 static const int kTokenFieldNumber = 3;
1011 const ::std::string& token() const;
1012 void set_token(const ::std::string& value);
1013 #if LANG_CXX11
1014 void set_token(::std::string&& value);
1015 #endif
1016 void set_token(const char* value);
1017 void set_token(const void* value, size_t size);
1018 ::std::string* mutable_token();
1019 ::std::string* release_token();
1020 void set_allocated_token(::std::string* token);
1021
1022 // optional uint32 version = 1;
1023 bool has_version() const;
1024 void clear_version();
1025 static const int kVersionFieldNumber = 1;
1026 ::google::protobuf::uint32 version() const;
1027 void set_version(::google::protobuf::uint32 value);
1028
1029 // required .Hdfs.Internal.RpcSaslProto.SaslState state = 2;
1030 bool has_state() const;
1031 void clear_state();
1032 static const int kStateFieldNumber = 2;
1033 ::Hdfs::Internal::RpcSaslProto_SaslState state() const;
1034 void set_state(::Hdfs::Internal::RpcSaslProto_SaslState value);
1035
1036 // @@protoc_insertion_point(class_scope:Hdfs.Internal.RpcSaslProto)
1037 private:
1038 void set_has_version();
1039 void clear_has_version();
1040 void set_has_state();
1041 void clear_has_state();
1042 void set_has_token();
1043 void clear_has_token();
1044
1045 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1046 ::google::protobuf::internal::HasBits<1> _has_bits_;
1047 mutable ::google::protobuf::internal::CachedSize _cached_size_;
1048 ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RpcSaslProto_SaslAuth > auths_;
1049 ::google::protobuf::internal::ArenaStringPtr token_;
1050 ::google::protobuf::uint32 version_;
1051 int state_;
1052 friend struct ::protobuf_RpcHeader_2eproto::TableStruct;
1053};
1054// ===================================================================
1055
1056
1057// ===================================================================
1058
1059#ifdef __GNUC__
1060 #pragma GCC diagnostic push
1061 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1062#endif // __GNUC__
1063// RpcRequestHeaderProto
1064
1065// optional .Hdfs.Internal.RpcKindProto rpcKind = 1;
1066inline bool RpcRequestHeaderProto::has_rpckind() const {
1067 return (_has_bits_[0] & 0x00000002u) != 0;
1068}
1069inline void RpcRequestHeaderProto::set_has_rpckind() {
1070 _has_bits_[0] |= 0x00000002u;
1071}
1072inline void RpcRequestHeaderProto::clear_has_rpckind() {
1073 _has_bits_[0] &= ~0x00000002u;
1074}
1075inline void RpcRequestHeaderProto::clear_rpckind() {
1076 rpckind_ = 0;
1077 clear_has_rpckind();
1078}
1079inline ::Hdfs::Internal::RpcKindProto RpcRequestHeaderProto::rpckind() const {
1080 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcRequestHeaderProto.rpcKind)
1081 return static_cast< ::Hdfs::Internal::RpcKindProto >(rpckind_);
1082}
1083inline void RpcRequestHeaderProto::set_rpckind(::Hdfs::Internal::RpcKindProto value) {
1084 assert(::Hdfs::Internal::RpcKindProto_IsValid(value));
1085 set_has_rpckind();
1086 rpckind_ = value;
1087 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcRequestHeaderProto.rpcKind)
1088}
1089
1090// optional .Hdfs.Internal.RpcRequestHeaderProto.OperationProto rpcOp = 2;
1091inline bool RpcRequestHeaderProto::has_rpcop() const {
1092 return (_has_bits_[0] & 0x00000004u) != 0;
1093}
1094inline void RpcRequestHeaderProto::set_has_rpcop() {
1095 _has_bits_[0] |= 0x00000004u;
1096}
1097inline void RpcRequestHeaderProto::clear_has_rpcop() {
1098 _has_bits_[0] &= ~0x00000004u;
1099}
1100inline void RpcRequestHeaderProto::clear_rpcop() {
1101 rpcop_ = 0;
1102 clear_has_rpcop();
1103}
1104inline ::Hdfs::Internal::RpcRequestHeaderProto_OperationProto RpcRequestHeaderProto::rpcop() const {
1105 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcRequestHeaderProto.rpcOp)
1106 return static_cast< ::Hdfs::Internal::RpcRequestHeaderProto_OperationProto >(rpcop_);
1107}
1108inline void RpcRequestHeaderProto::set_rpcop(::Hdfs::Internal::RpcRequestHeaderProto_OperationProto value) {
1109 assert(::Hdfs::Internal::RpcRequestHeaderProto_OperationProto_IsValid(value));
1110 set_has_rpcop();
1111 rpcop_ = value;
1112 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcRequestHeaderProto.rpcOp)
1113}
1114
1115// required sint32 callId = 3;
1116inline bool RpcRequestHeaderProto::has_callid() const {
1117 return (_has_bits_[0] & 0x00000008u) != 0;
1118}
1119inline void RpcRequestHeaderProto::set_has_callid() {
1120 _has_bits_[0] |= 0x00000008u;
1121}
1122inline void RpcRequestHeaderProto::clear_has_callid() {
1123 _has_bits_[0] &= ~0x00000008u;
1124}
1125inline void RpcRequestHeaderProto::clear_callid() {
1126 callid_ = 0;
1127 clear_has_callid();
1128}
1129inline ::google::protobuf::int32 RpcRequestHeaderProto::callid() const {
1130 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcRequestHeaderProto.callId)
1131 return callid_;
1132}
1133inline void RpcRequestHeaderProto::set_callid(::google::protobuf::int32 value) {
1134 set_has_callid();
1135 callid_ = value;
1136 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcRequestHeaderProto.callId)
1137}
1138
1139// required bytes clientId = 4;
1140inline bool RpcRequestHeaderProto::has_clientid() const {
1141 return (_has_bits_[0] & 0x00000001u) != 0;
1142}
1143inline void RpcRequestHeaderProto::set_has_clientid() {
1144 _has_bits_[0] |= 0x00000001u;
1145}
1146inline void RpcRequestHeaderProto::clear_has_clientid() {
1147 _has_bits_[0] &= ~0x00000001u;
1148}
1149inline void RpcRequestHeaderProto::clear_clientid() {
1150 clientid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1151 clear_has_clientid();
1152}
1153inline const ::std::string& RpcRequestHeaderProto::clientid() const {
1154 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcRequestHeaderProto.clientId)
1155 return clientid_.GetNoArena();
1156}
1157inline void RpcRequestHeaderProto::set_clientid(const ::std::string& value) {
1158 set_has_clientid();
1159 clientid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1160 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcRequestHeaderProto.clientId)
1161}
1162#if LANG_CXX11
1163inline void RpcRequestHeaderProto::set_clientid(::std::string&& value) {
1164 set_has_clientid();
1165 clientid_.SetNoArena(
1166 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1167 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcRequestHeaderProto.clientId)
1168}
1169#endif
1170inline void RpcRequestHeaderProto::set_clientid(const char* value) {
1171 GOOGLE_DCHECK(value != NULL);
1172 set_has_clientid();
1173 clientid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1174 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcRequestHeaderProto.clientId)
1175}
1176inline void RpcRequestHeaderProto::set_clientid(const void* value, size_t size) {
1177 set_has_clientid();
1178 clientid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1179 ::std::string(reinterpret_cast<const char*>(value), size));
1180 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcRequestHeaderProto.clientId)
1181}
1182inline ::std::string* RpcRequestHeaderProto::mutable_clientid() {
1183 set_has_clientid();
1184 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcRequestHeaderProto.clientId)
1185 return clientid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1186}
1187inline ::std::string* RpcRequestHeaderProto::release_clientid() {
1188 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcRequestHeaderProto.clientId)
1189 if (!has_clientid()) {
1190 return NULL;
1191 }
1192 clear_has_clientid();
1193 return clientid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1194}
1195inline void RpcRequestHeaderProto::set_allocated_clientid(::std::string* clientid) {
1196 if (clientid != NULL) {
1197 set_has_clientid();
1198 } else {
1199 clear_has_clientid();
1200 }
1201 clientid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), clientid);
1202 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcRequestHeaderProto.clientId)
1203}
1204
1205// optional sint32 retryCount = 5 [default = -1];
1206inline bool RpcRequestHeaderProto::has_retrycount() const {
1207 return (_has_bits_[0] & 0x00000010u) != 0;
1208}
1209inline void RpcRequestHeaderProto::set_has_retrycount() {
1210 _has_bits_[0] |= 0x00000010u;
1211}
1212inline void RpcRequestHeaderProto::clear_has_retrycount() {
1213 _has_bits_[0] &= ~0x00000010u;
1214}
1215inline void RpcRequestHeaderProto::clear_retrycount() {
1216 retrycount_ = -1;
1217 clear_has_retrycount();
1218}
1219inline ::google::protobuf::int32 RpcRequestHeaderProto::retrycount() const {
1220 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcRequestHeaderProto.retryCount)
1221 return retrycount_;
1222}
1223inline void RpcRequestHeaderProto::set_retrycount(::google::protobuf::int32 value) {
1224 set_has_retrycount();
1225 retrycount_ = value;
1226 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcRequestHeaderProto.retryCount)
1227}
1228
1229// -------------------------------------------------------------------
1230
1231// RpcResponseHeaderProto
1232
1233// required uint32 callId = 1;
1234inline bool RpcResponseHeaderProto::has_callid() const {
1235 return (_has_bits_[0] & 0x00000008u) != 0;
1236}
1237inline void RpcResponseHeaderProto::set_has_callid() {
1238 _has_bits_[0] |= 0x00000008u;
1239}
1240inline void RpcResponseHeaderProto::clear_has_callid() {
1241 _has_bits_[0] &= ~0x00000008u;
1242}
1243inline void RpcResponseHeaderProto::clear_callid() {
1244 callid_ = 0u;
1245 clear_has_callid();
1246}
1247inline ::google::protobuf::uint32 RpcResponseHeaderProto::callid() const {
1248 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcResponseHeaderProto.callId)
1249 return callid_;
1250}
1251inline void RpcResponseHeaderProto::set_callid(::google::protobuf::uint32 value) {
1252 set_has_callid();
1253 callid_ = value;
1254 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcResponseHeaderProto.callId)
1255}
1256
1257// required .Hdfs.Internal.RpcResponseHeaderProto.RpcStatusProto status = 2;
1258inline bool RpcResponseHeaderProto::has_status() const {
1259 return (_has_bits_[0] & 0x00000010u) != 0;
1260}
1261inline void RpcResponseHeaderProto::set_has_status() {
1262 _has_bits_[0] |= 0x00000010u;
1263}
1264inline void RpcResponseHeaderProto::clear_has_status() {
1265 _has_bits_[0] &= ~0x00000010u;
1266}
1267inline void RpcResponseHeaderProto::clear_status() {
1268 status_ = 0;
1269 clear_has_status();
1270}
1271inline ::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto RpcResponseHeaderProto::status() const {
1272 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcResponseHeaderProto.status)
1273 return static_cast< ::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto >(status_);
1274}
1275inline void RpcResponseHeaderProto::set_status(::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto value) {
1276 assert(::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto_IsValid(value));
1277 set_has_status();
1278 status_ = value;
1279 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcResponseHeaderProto.status)
1280}
1281
1282// optional uint32 serverIpcVersionNum = 3;
1283inline bool RpcResponseHeaderProto::has_serveripcversionnum() const {
1284 return (_has_bits_[0] & 0x00000020u) != 0;
1285}
1286inline void RpcResponseHeaderProto::set_has_serveripcversionnum() {
1287 _has_bits_[0] |= 0x00000020u;
1288}
1289inline void RpcResponseHeaderProto::clear_has_serveripcversionnum() {
1290 _has_bits_[0] &= ~0x00000020u;
1291}
1292inline void RpcResponseHeaderProto::clear_serveripcversionnum() {
1293 serveripcversionnum_ = 0u;
1294 clear_has_serveripcversionnum();
1295}
1296inline ::google::protobuf::uint32 RpcResponseHeaderProto::serveripcversionnum() const {
1297 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcResponseHeaderProto.serverIpcVersionNum)
1298 return serveripcversionnum_;
1299}
1300inline void RpcResponseHeaderProto::set_serveripcversionnum(::google::protobuf::uint32 value) {
1301 set_has_serveripcversionnum();
1302 serveripcversionnum_ = value;
1303 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcResponseHeaderProto.serverIpcVersionNum)
1304}
1305
1306// optional string exceptionClassName = 4;
1307inline bool RpcResponseHeaderProto::has_exceptionclassname() const {
1308 return (_has_bits_[0] & 0x00000001u) != 0;
1309}
1310inline void RpcResponseHeaderProto::set_has_exceptionclassname() {
1311 _has_bits_[0] |= 0x00000001u;
1312}
1313inline void RpcResponseHeaderProto::clear_has_exceptionclassname() {
1314 _has_bits_[0] &= ~0x00000001u;
1315}
1316inline void RpcResponseHeaderProto::clear_exceptionclassname() {
1317 exceptionclassname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1318 clear_has_exceptionclassname();
1319}
1320inline const ::std::string& RpcResponseHeaderProto::exceptionclassname() const {
1321 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName)
1322 return exceptionclassname_.GetNoArena();
1323}
1324inline void RpcResponseHeaderProto::set_exceptionclassname(const ::std::string& value) {
1325 set_has_exceptionclassname();
1326 exceptionclassname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1327 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName)
1328}
1329#if LANG_CXX11
1330inline void RpcResponseHeaderProto::set_exceptionclassname(::std::string&& value) {
1331 set_has_exceptionclassname();
1332 exceptionclassname_.SetNoArena(
1333 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1334 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName)
1335}
1336#endif
1337inline void RpcResponseHeaderProto::set_exceptionclassname(const char* value) {
1338 GOOGLE_DCHECK(value != NULL);
1339 set_has_exceptionclassname();
1340 exceptionclassname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1341 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName)
1342}
1343inline void RpcResponseHeaderProto::set_exceptionclassname(const char* value, size_t size) {
1344 set_has_exceptionclassname();
1345 exceptionclassname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1346 ::std::string(reinterpret_cast<const char*>(value), size));
1347 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName)
1348}
1349inline ::std::string* RpcResponseHeaderProto::mutable_exceptionclassname() {
1350 set_has_exceptionclassname();
1351 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName)
1352 return exceptionclassname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1353}
1354inline ::std::string* RpcResponseHeaderProto::release_exceptionclassname() {
1355 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName)
1356 if (!has_exceptionclassname()) {
1357 return NULL;
1358 }
1359 clear_has_exceptionclassname();
1360 return exceptionclassname_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1361}
1362inline void RpcResponseHeaderProto::set_allocated_exceptionclassname(::std::string* exceptionclassname) {
1363 if (exceptionclassname != NULL) {
1364 set_has_exceptionclassname();
1365 } else {
1366 clear_has_exceptionclassname();
1367 }
1368 exceptionclassname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), exceptionclassname);
1369 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName)
1370}
1371
1372// optional string errorMsg = 5;
1373inline bool RpcResponseHeaderProto::has_errormsg() const {
1374 return (_has_bits_[0] & 0x00000002u) != 0;
1375}
1376inline void RpcResponseHeaderProto::set_has_errormsg() {
1377 _has_bits_[0] |= 0x00000002u;
1378}
1379inline void RpcResponseHeaderProto::clear_has_errormsg() {
1380 _has_bits_[0] &= ~0x00000002u;
1381}
1382inline void RpcResponseHeaderProto::clear_errormsg() {
1383 errormsg_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1384 clear_has_errormsg();
1385}
1386inline const ::std::string& RpcResponseHeaderProto::errormsg() const {
1387 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcResponseHeaderProto.errorMsg)
1388 return errormsg_.GetNoArena();
1389}
1390inline void RpcResponseHeaderProto::set_errormsg(const ::std::string& value) {
1391 set_has_errormsg();
1392 errormsg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1393 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcResponseHeaderProto.errorMsg)
1394}
1395#if LANG_CXX11
1396inline void RpcResponseHeaderProto::set_errormsg(::std::string&& value) {
1397 set_has_errormsg();
1398 errormsg_.SetNoArena(
1399 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1400 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcResponseHeaderProto.errorMsg)
1401}
1402#endif
1403inline void RpcResponseHeaderProto::set_errormsg(const char* value) {
1404 GOOGLE_DCHECK(value != NULL);
1405 set_has_errormsg();
1406 errormsg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1407 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcResponseHeaderProto.errorMsg)
1408}
1409inline void RpcResponseHeaderProto::set_errormsg(const char* value, size_t size) {
1410 set_has_errormsg();
1411 errormsg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1412 ::std::string(reinterpret_cast<const char*>(value), size));
1413 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcResponseHeaderProto.errorMsg)
1414}
1415inline ::std::string* RpcResponseHeaderProto::mutable_errormsg() {
1416 set_has_errormsg();
1417 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcResponseHeaderProto.errorMsg)
1418 return errormsg_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1419}
1420inline ::std::string* RpcResponseHeaderProto::release_errormsg() {
1421 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcResponseHeaderProto.errorMsg)
1422 if (!has_errormsg()) {
1423 return NULL;
1424 }
1425 clear_has_errormsg();
1426 return errormsg_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1427}
1428inline void RpcResponseHeaderProto::set_allocated_errormsg(::std::string* errormsg) {
1429 if (errormsg != NULL) {
1430 set_has_errormsg();
1431 } else {
1432 clear_has_errormsg();
1433 }
1434 errormsg_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), errormsg);
1435 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcResponseHeaderProto.errorMsg)
1436}
1437
1438// optional .Hdfs.Internal.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
1439inline bool RpcResponseHeaderProto::has_errordetail() const {
1440 return (_has_bits_[0] & 0x00000040u) != 0;
1441}
1442inline void RpcResponseHeaderProto::set_has_errordetail() {
1443 _has_bits_[0] |= 0x00000040u;
1444}
1445inline void RpcResponseHeaderProto::clear_has_errordetail() {
1446 _has_bits_[0] &= ~0x00000040u;
1447}
1448inline void RpcResponseHeaderProto::clear_errordetail() {
1449 errordetail_ = 1;
1450 clear_has_errordetail();
1451}
1452inline ::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::errordetail() const {
1453 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcResponseHeaderProto.errorDetail)
1454 return static_cast< ::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto >(errordetail_);
1455}
1456inline void RpcResponseHeaderProto::set_errordetail(::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto value) {
1457 assert(::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto_IsValid(value));
1458 set_has_errordetail();
1459 errordetail_ = value;
1460 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcResponseHeaderProto.errorDetail)
1461}
1462
1463// optional bytes clientId = 7;
1464inline bool RpcResponseHeaderProto::has_clientid() const {
1465 return (_has_bits_[0] & 0x00000004u) != 0;
1466}
1467inline void RpcResponseHeaderProto::set_has_clientid() {
1468 _has_bits_[0] |= 0x00000004u;
1469}
1470inline void RpcResponseHeaderProto::clear_has_clientid() {
1471 _has_bits_[0] &= ~0x00000004u;
1472}
1473inline void RpcResponseHeaderProto::clear_clientid() {
1474 clientid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1475 clear_has_clientid();
1476}
1477inline const ::std::string& RpcResponseHeaderProto::clientid() const {
1478 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcResponseHeaderProto.clientId)
1479 return clientid_.GetNoArena();
1480}
1481inline void RpcResponseHeaderProto::set_clientid(const ::std::string& value) {
1482 set_has_clientid();
1483 clientid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1484 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcResponseHeaderProto.clientId)
1485}
1486#if LANG_CXX11
1487inline void RpcResponseHeaderProto::set_clientid(::std::string&& value) {
1488 set_has_clientid();
1489 clientid_.SetNoArena(
1490 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1491 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcResponseHeaderProto.clientId)
1492}
1493#endif
1494inline void RpcResponseHeaderProto::set_clientid(const char* value) {
1495 GOOGLE_DCHECK(value != NULL);
1496 set_has_clientid();
1497 clientid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1498 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcResponseHeaderProto.clientId)
1499}
1500inline void RpcResponseHeaderProto::set_clientid(const void* value, size_t size) {
1501 set_has_clientid();
1502 clientid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1503 ::std::string(reinterpret_cast<const char*>(value), size));
1504 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcResponseHeaderProto.clientId)
1505}
1506inline ::std::string* RpcResponseHeaderProto::mutable_clientid() {
1507 set_has_clientid();
1508 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcResponseHeaderProto.clientId)
1509 return clientid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1510}
1511inline ::std::string* RpcResponseHeaderProto::release_clientid() {
1512 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcResponseHeaderProto.clientId)
1513 if (!has_clientid()) {
1514 return NULL;
1515 }
1516 clear_has_clientid();
1517 return clientid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1518}
1519inline void RpcResponseHeaderProto::set_allocated_clientid(::std::string* clientid) {
1520 if (clientid != NULL) {
1521 set_has_clientid();
1522 } else {
1523 clear_has_clientid();
1524 }
1525 clientid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), clientid);
1526 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcResponseHeaderProto.clientId)
1527}
1528
1529// optional sint32 retryCount = 8 [default = -1];
1530inline bool RpcResponseHeaderProto::has_retrycount() const {
1531 return (_has_bits_[0] & 0x00000080u) != 0;
1532}
1533inline void RpcResponseHeaderProto::set_has_retrycount() {
1534 _has_bits_[0] |= 0x00000080u;
1535}
1536inline void RpcResponseHeaderProto::clear_has_retrycount() {
1537 _has_bits_[0] &= ~0x00000080u;
1538}
1539inline void RpcResponseHeaderProto::clear_retrycount() {
1540 retrycount_ = -1;
1541 clear_has_retrycount();
1542}
1543inline ::google::protobuf::int32 RpcResponseHeaderProto::retrycount() const {
1544 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcResponseHeaderProto.retryCount)
1545 return retrycount_;
1546}
1547inline void RpcResponseHeaderProto::set_retrycount(::google::protobuf::int32 value) {
1548 set_has_retrycount();
1549 retrycount_ = value;
1550 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcResponseHeaderProto.retryCount)
1551}
1552
1553// -------------------------------------------------------------------
1554
1555// RpcSaslProto_SaslAuth
1556
1557// required string method = 1;
1558inline bool RpcSaslProto_SaslAuth::has_method() const {
1559 return (_has_bits_[0] & 0x00000001u) != 0;
1560}
1561inline void RpcSaslProto_SaslAuth::set_has_method() {
1562 _has_bits_[0] |= 0x00000001u;
1563}
1564inline void RpcSaslProto_SaslAuth::clear_has_method() {
1565 _has_bits_[0] &= ~0x00000001u;
1566}
1567inline void RpcSaslProto_SaslAuth::clear_method() {
1568 method_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1569 clear_has_method();
1570}
1571inline const ::std::string& RpcSaslProto_SaslAuth::method() const {
1572 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.SaslAuth.method)
1573 return method_.GetNoArena();
1574}
1575inline void RpcSaslProto_SaslAuth::set_method(const ::std::string& value) {
1576 set_has_method();
1577 method_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1578 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcSaslProto.SaslAuth.method)
1579}
1580#if LANG_CXX11
1581inline void RpcSaslProto_SaslAuth::set_method(::std::string&& value) {
1582 set_has_method();
1583 method_.SetNoArena(
1584 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1585 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcSaslProto.SaslAuth.method)
1586}
1587#endif
1588inline void RpcSaslProto_SaslAuth::set_method(const char* value) {
1589 GOOGLE_DCHECK(value != NULL);
1590 set_has_method();
1591 method_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1592 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcSaslProto.SaslAuth.method)
1593}
1594inline void RpcSaslProto_SaslAuth::set_method(const char* value, size_t size) {
1595 set_has_method();
1596 method_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1597 ::std::string(reinterpret_cast<const char*>(value), size));
1598 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcSaslProto.SaslAuth.method)
1599}
1600inline ::std::string* RpcSaslProto_SaslAuth::mutable_method() {
1601 set_has_method();
1602 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcSaslProto.SaslAuth.method)
1603 return method_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1604}
1605inline ::std::string* RpcSaslProto_SaslAuth::release_method() {
1606 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcSaslProto.SaslAuth.method)
1607 if (!has_method()) {
1608 return NULL;
1609 }
1610 clear_has_method();
1611 return method_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1612}
1613inline void RpcSaslProto_SaslAuth::set_allocated_method(::std::string* method) {
1614 if (method != NULL) {
1615 set_has_method();
1616 } else {
1617 clear_has_method();
1618 }
1619 method_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), method);
1620 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcSaslProto.SaslAuth.method)
1621}
1622
1623// required string mechanism = 2;
1624inline bool RpcSaslProto_SaslAuth::has_mechanism() const {
1625 return (_has_bits_[0] & 0x00000002u) != 0;
1626}
1627inline void RpcSaslProto_SaslAuth::set_has_mechanism() {
1628 _has_bits_[0] |= 0x00000002u;
1629}
1630inline void RpcSaslProto_SaslAuth::clear_has_mechanism() {
1631 _has_bits_[0] &= ~0x00000002u;
1632}
1633inline void RpcSaslProto_SaslAuth::clear_mechanism() {
1634 mechanism_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1635 clear_has_mechanism();
1636}
1637inline const ::std::string& RpcSaslProto_SaslAuth::mechanism() const {
1638 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism)
1639 return mechanism_.GetNoArena();
1640}
1641inline void RpcSaslProto_SaslAuth::set_mechanism(const ::std::string& value) {
1642 set_has_mechanism();
1643 mechanism_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1644 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism)
1645}
1646#if LANG_CXX11
1647inline void RpcSaslProto_SaslAuth::set_mechanism(::std::string&& value) {
1648 set_has_mechanism();
1649 mechanism_.SetNoArena(
1650 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1651 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism)
1652}
1653#endif
1654inline void RpcSaslProto_SaslAuth::set_mechanism(const char* value) {
1655 GOOGLE_DCHECK(value != NULL);
1656 set_has_mechanism();
1657 mechanism_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1658 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism)
1659}
1660inline void RpcSaslProto_SaslAuth::set_mechanism(const char* value, size_t size) {
1661 set_has_mechanism();
1662 mechanism_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1663 ::std::string(reinterpret_cast<const char*>(value), size));
1664 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism)
1665}
1666inline ::std::string* RpcSaslProto_SaslAuth::mutable_mechanism() {
1667 set_has_mechanism();
1668 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism)
1669 return mechanism_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1670}
1671inline ::std::string* RpcSaslProto_SaslAuth::release_mechanism() {
1672 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism)
1673 if (!has_mechanism()) {
1674 return NULL;
1675 }
1676 clear_has_mechanism();
1677 return mechanism_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1678}
1679inline void RpcSaslProto_SaslAuth::set_allocated_mechanism(::std::string* mechanism) {
1680 if (mechanism != NULL) {
1681 set_has_mechanism();
1682 } else {
1683 clear_has_mechanism();
1684 }
1685 mechanism_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mechanism);
1686 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism)
1687}
1688
1689// optional string protocol = 3;
1690inline bool RpcSaslProto_SaslAuth::has_protocol() const {
1691 return (_has_bits_[0] & 0x00000004u) != 0;
1692}
1693inline void RpcSaslProto_SaslAuth::set_has_protocol() {
1694 _has_bits_[0] |= 0x00000004u;
1695}
1696inline void RpcSaslProto_SaslAuth::clear_has_protocol() {
1697 _has_bits_[0] &= ~0x00000004u;
1698}
1699inline void RpcSaslProto_SaslAuth::clear_protocol() {
1700 protocol_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1701 clear_has_protocol();
1702}
1703inline const ::std::string& RpcSaslProto_SaslAuth::protocol() const {
1704 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.SaslAuth.protocol)
1705 return protocol_.GetNoArena();
1706}
1707inline void RpcSaslProto_SaslAuth::set_protocol(const ::std::string& value) {
1708 set_has_protocol();
1709 protocol_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1710 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcSaslProto.SaslAuth.protocol)
1711}
1712#if LANG_CXX11
1713inline void RpcSaslProto_SaslAuth::set_protocol(::std::string&& value) {
1714 set_has_protocol();
1715 protocol_.SetNoArena(
1716 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1717 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcSaslProto.SaslAuth.protocol)
1718}
1719#endif
1720inline void RpcSaslProto_SaslAuth::set_protocol(const char* value) {
1721 GOOGLE_DCHECK(value != NULL);
1722 set_has_protocol();
1723 protocol_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1724 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcSaslProto.SaslAuth.protocol)
1725}
1726inline void RpcSaslProto_SaslAuth::set_protocol(const char* value, size_t size) {
1727 set_has_protocol();
1728 protocol_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1729 ::std::string(reinterpret_cast<const char*>(value), size));
1730 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcSaslProto.SaslAuth.protocol)
1731}
1732inline ::std::string* RpcSaslProto_SaslAuth::mutable_protocol() {
1733 set_has_protocol();
1734 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcSaslProto.SaslAuth.protocol)
1735 return protocol_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1736}
1737inline ::std::string* RpcSaslProto_SaslAuth::release_protocol() {
1738 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcSaslProto.SaslAuth.protocol)
1739 if (!has_protocol()) {
1740 return NULL;
1741 }
1742 clear_has_protocol();
1743 return protocol_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1744}
1745inline void RpcSaslProto_SaslAuth::set_allocated_protocol(::std::string* protocol) {
1746 if (protocol != NULL) {
1747 set_has_protocol();
1748 } else {
1749 clear_has_protocol();
1750 }
1751 protocol_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), protocol);
1752 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcSaslProto.SaslAuth.protocol)
1753}
1754
1755// optional string serverId = 4;
1756inline bool RpcSaslProto_SaslAuth::has_serverid() const {
1757 return (_has_bits_[0] & 0x00000008u) != 0;
1758}
1759inline void RpcSaslProto_SaslAuth::set_has_serverid() {
1760 _has_bits_[0] |= 0x00000008u;
1761}
1762inline void RpcSaslProto_SaslAuth::clear_has_serverid() {
1763 _has_bits_[0] &= ~0x00000008u;
1764}
1765inline void RpcSaslProto_SaslAuth::clear_serverid() {
1766 serverid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1767 clear_has_serverid();
1768}
1769inline const ::std::string& RpcSaslProto_SaslAuth::serverid() const {
1770 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.SaslAuth.serverId)
1771 return serverid_.GetNoArena();
1772}
1773inline void RpcSaslProto_SaslAuth::set_serverid(const ::std::string& value) {
1774 set_has_serverid();
1775 serverid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1776 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcSaslProto.SaslAuth.serverId)
1777}
1778#if LANG_CXX11
1779inline void RpcSaslProto_SaslAuth::set_serverid(::std::string&& value) {
1780 set_has_serverid();
1781 serverid_.SetNoArena(
1782 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1783 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcSaslProto.SaslAuth.serverId)
1784}
1785#endif
1786inline void RpcSaslProto_SaslAuth::set_serverid(const char* value) {
1787 GOOGLE_DCHECK(value != NULL);
1788 set_has_serverid();
1789 serverid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1790 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcSaslProto.SaslAuth.serverId)
1791}
1792inline void RpcSaslProto_SaslAuth::set_serverid(const char* value, size_t size) {
1793 set_has_serverid();
1794 serverid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1795 ::std::string(reinterpret_cast<const char*>(value), size));
1796 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcSaslProto.SaslAuth.serverId)
1797}
1798inline ::std::string* RpcSaslProto_SaslAuth::mutable_serverid() {
1799 set_has_serverid();
1800 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcSaslProto.SaslAuth.serverId)
1801 return serverid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1802}
1803inline ::std::string* RpcSaslProto_SaslAuth::release_serverid() {
1804 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcSaslProto.SaslAuth.serverId)
1805 if (!has_serverid()) {
1806 return NULL;
1807 }
1808 clear_has_serverid();
1809 return serverid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1810}
1811inline void RpcSaslProto_SaslAuth::set_allocated_serverid(::std::string* serverid) {
1812 if (serverid != NULL) {
1813 set_has_serverid();
1814 } else {
1815 clear_has_serverid();
1816 }
1817 serverid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), serverid);
1818 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcSaslProto.SaslAuth.serverId)
1819}
1820
1821// optional bytes challenge = 5;
1822inline bool RpcSaslProto_SaslAuth::has_challenge() const {
1823 return (_has_bits_[0] & 0x00000010u) != 0;
1824}
1825inline void RpcSaslProto_SaslAuth::set_has_challenge() {
1826 _has_bits_[0] |= 0x00000010u;
1827}
1828inline void RpcSaslProto_SaslAuth::clear_has_challenge() {
1829 _has_bits_[0] &= ~0x00000010u;
1830}
1831inline void RpcSaslProto_SaslAuth::clear_challenge() {
1832 challenge_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1833 clear_has_challenge();
1834}
1835inline const ::std::string& RpcSaslProto_SaslAuth::challenge() const {
1836 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.SaslAuth.challenge)
1837 return challenge_.GetNoArena();
1838}
1839inline void RpcSaslProto_SaslAuth::set_challenge(const ::std::string& value) {
1840 set_has_challenge();
1841 challenge_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1842 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcSaslProto.SaslAuth.challenge)
1843}
1844#if LANG_CXX11
1845inline void RpcSaslProto_SaslAuth::set_challenge(::std::string&& value) {
1846 set_has_challenge();
1847 challenge_.SetNoArena(
1848 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1849 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcSaslProto.SaslAuth.challenge)
1850}
1851#endif
1852inline void RpcSaslProto_SaslAuth::set_challenge(const char* value) {
1853 GOOGLE_DCHECK(value != NULL);
1854 set_has_challenge();
1855 challenge_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1856 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcSaslProto.SaslAuth.challenge)
1857}
1858inline void RpcSaslProto_SaslAuth::set_challenge(const void* value, size_t size) {
1859 set_has_challenge();
1860 challenge_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1861 ::std::string(reinterpret_cast<const char*>(value), size));
1862 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcSaslProto.SaslAuth.challenge)
1863}
1864inline ::std::string* RpcSaslProto_SaslAuth::mutable_challenge() {
1865 set_has_challenge();
1866 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcSaslProto.SaslAuth.challenge)
1867 return challenge_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1868}
1869inline ::std::string* RpcSaslProto_SaslAuth::release_challenge() {
1870 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcSaslProto.SaslAuth.challenge)
1871 if (!has_challenge()) {
1872 return NULL;
1873 }
1874 clear_has_challenge();
1875 return challenge_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1876}
1877inline void RpcSaslProto_SaslAuth::set_allocated_challenge(::std::string* challenge) {
1878 if (challenge != NULL) {
1879 set_has_challenge();
1880 } else {
1881 clear_has_challenge();
1882 }
1883 challenge_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), challenge);
1884 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcSaslProto.SaslAuth.challenge)
1885}
1886
1887// -------------------------------------------------------------------
1888
1889// RpcSaslProto
1890
1891// optional uint32 version = 1;
1892inline bool RpcSaslProto::has_version() const {
1893 return (_has_bits_[0] & 0x00000002u) != 0;
1894}
1895inline void RpcSaslProto::set_has_version() {
1896 _has_bits_[0] |= 0x00000002u;
1897}
1898inline void RpcSaslProto::clear_has_version() {
1899 _has_bits_[0] &= ~0x00000002u;
1900}
1901inline void RpcSaslProto::clear_version() {
1902 version_ = 0u;
1903 clear_has_version();
1904}
1905inline ::google::protobuf::uint32 RpcSaslProto::version() const {
1906 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.version)
1907 return version_;
1908}
1909inline void RpcSaslProto::set_version(::google::protobuf::uint32 value) {
1910 set_has_version();
1911 version_ = value;
1912 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcSaslProto.version)
1913}
1914
1915// required .Hdfs.Internal.RpcSaslProto.SaslState state = 2;
1916inline bool RpcSaslProto::has_state() const {
1917 return (_has_bits_[0] & 0x00000004u) != 0;
1918}
1919inline void RpcSaslProto::set_has_state() {
1920 _has_bits_[0] |= 0x00000004u;
1921}
1922inline void RpcSaslProto::clear_has_state() {
1923 _has_bits_[0] &= ~0x00000004u;
1924}
1925inline void RpcSaslProto::clear_state() {
1926 state_ = 0;
1927 clear_has_state();
1928}
1929inline ::Hdfs::Internal::RpcSaslProto_SaslState RpcSaslProto::state() const {
1930 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.state)
1931 return static_cast< ::Hdfs::Internal::RpcSaslProto_SaslState >(state_);
1932}
1933inline void RpcSaslProto::set_state(::Hdfs::Internal::RpcSaslProto_SaslState value) {
1934 assert(::Hdfs::Internal::RpcSaslProto_SaslState_IsValid(value));
1935 set_has_state();
1936 state_ = value;
1937 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcSaslProto.state)
1938}
1939
1940// optional bytes token = 3;
1941inline bool RpcSaslProto::has_token() const {
1942 return (_has_bits_[0] & 0x00000001u) != 0;
1943}
1944inline void RpcSaslProto::set_has_token() {
1945 _has_bits_[0] |= 0x00000001u;
1946}
1947inline void RpcSaslProto::clear_has_token() {
1948 _has_bits_[0] &= ~0x00000001u;
1949}
1950inline void RpcSaslProto::clear_token() {
1951 token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1952 clear_has_token();
1953}
1954inline const ::std::string& RpcSaslProto::token() const {
1955 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.token)
1956 return token_.GetNoArena();
1957}
1958inline void RpcSaslProto::set_token(const ::std::string& value) {
1959 set_has_token();
1960 token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1961 // @@protoc_insertion_point(field_set:Hdfs.Internal.RpcSaslProto.token)
1962}
1963#if LANG_CXX11
1964inline void RpcSaslProto::set_token(::std::string&& value) {
1965 set_has_token();
1966 token_.SetNoArena(
1967 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1968 // @@protoc_insertion_point(field_set_rvalue:Hdfs.Internal.RpcSaslProto.token)
1969}
1970#endif
1971inline void RpcSaslProto::set_token(const char* value) {
1972 GOOGLE_DCHECK(value != NULL);
1973 set_has_token();
1974 token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1975 // @@protoc_insertion_point(field_set_char:Hdfs.Internal.RpcSaslProto.token)
1976}
1977inline void RpcSaslProto::set_token(const void* value, size_t size) {
1978 set_has_token();
1979 token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1980 ::std::string(reinterpret_cast<const char*>(value), size));
1981 // @@protoc_insertion_point(field_set_pointer:Hdfs.Internal.RpcSaslProto.token)
1982}
1983inline ::std::string* RpcSaslProto::mutable_token() {
1984 set_has_token();
1985 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcSaslProto.token)
1986 return token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1987}
1988inline ::std::string* RpcSaslProto::release_token() {
1989 // @@protoc_insertion_point(field_release:Hdfs.Internal.RpcSaslProto.token)
1990 if (!has_token()) {
1991 return NULL;
1992 }
1993 clear_has_token();
1994 return token_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1995}
1996inline void RpcSaslProto::set_allocated_token(::std::string* token) {
1997 if (token != NULL) {
1998 set_has_token();
1999 } else {
2000 clear_has_token();
2001 }
2002 token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), token);
2003 // @@protoc_insertion_point(field_set_allocated:Hdfs.Internal.RpcSaslProto.token)
2004}
2005
2006// repeated .Hdfs.Internal.RpcSaslProto.SaslAuth auths = 4;
2007inline int RpcSaslProto::auths_size() const {
2008 return auths_.size();
2009}
2010inline void RpcSaslProto::clear_auths() {
2011 auths_.Clear();
2012}
2013inline ::Hdfs::Internal::RpcSaslProto_SaslAuth* RpcSaslProto::mutable_auths(int index) {
2014 // @@protoc_insertion_point(field_mutable:Hdfs.Internal.RpcSaslProto.auths)
2015 return auths_.Mutable(index);
2016}
2017inline ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RpcSaslProto_SaslAuth >*
2018RpcSaslProto::mutable_auths() {
2019 // @@protoc_insertion_point(field_mutable_list:Hdfs.Internal.RpcSaslProto.auths)
2020 return &auths_;
2021}
2022inline const ::Hdfs::Internal::RpcSaslProto_SaslAuth& RpcSaslProto::auths(int index) const {
2023 // @@protoc_insertion_point(field_get:Hdfs.Internal.RpcSaslProto.auths)
2024 return auths_.Get(index);
2025}
2026inline ::Hdfs::Internal::RpcSaslProto_SaslAuth* RpcSaslProto::add_auths() {
2027 // @@protoc_insertion_point(field_add:Hdfs.Internal.RpcSaslProto.auths)
2028 return auths_.Add();
2029}
2030inline const ::google::protobuf::RepeatedPtrField< ::Hdfs::Internal::RpcSaslProto_SaslAuth >&
2031RpcSaslProto::auths() const {
2032 // @@protoc_insertion_point(field_list:Hdfs.Internal.RpcSaslProto.auths)
2033 return auths_;
2034}
2035
2036#ifdef __GNUC__
2037 #pragma GCC diagnostic pop
2038#endif // __GNUC__
2039// -------------------------------------------------------------------
2040
2041// -------------------------------------------------------------------
2042
2043// -------------------------------------------------------------------
2044
2045
2046// @@protoc_insertion_point(namespace_scope)
2047
2048} // namespace Internal
2049} // namespace Hdfs
2050
2051namespace google {
2052namespace protobuf {
2053
2054template <> struct is_proto_enum< ::Hdfs::Internal::RpcRequestHeaderProto_OperationProto> : ::std::true_type {};
2055template <>
2056inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::RpcRequestHeaderProto_OperationProto>() {
2057 return ::Hdfs::Internal::RpcRequestHeaderProto_OperationProto_descriptor();
2058}
2059template <> struct is_proto_enum< ::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto> : ::std::true_type {};
2060template <>
2061inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto>() {
2062 return ::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto_descriptor();
2063}
2064template <> struct is_proto_enum< ::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto> : ::std::true_type {};
2065template <>
2066inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto>() {
2067 return ::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto_descriptor();
2068}
2069template <> struct is_proto_enum< ::Hdfs::Internal::RpcSaslProto_SaslState> : ::std::true_type {};
2070template <>
2071inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::RpcSaslProto_SaslState>() {
2072 return ::Hdfs::Internal::RpcSaslProto_SaslState_descriptor();
2073}
2074template <> struct is_proto_enum< ::Hdfs::Internal::RpcKindProto> : ::std::true_type {};
2075template <>
2076inline const EnumDescriptor* GetEnumDescriptor< ::Hdfs::Internal::RpcKindProto>() {
2077 return ::Hdfs::Internal::RpcKindProto_descriptor();
2078}
2079
2080} // namespace protobuf
2081} // namespace google
2082
2083// @@protoc_insertion_point(global_scope)
2084
2085#endif // PROTOBUF_INCLUDED_RpcHeader_2eproto
2086