1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: RpcHeader.proto
3
4#include "RpcHeader.pb.h"
5
6#include <algorithm>
7
8#include <google/protobuf/stubs/common.h>
9#include <google/protobuf/stubs/port.h>
10#include <google/protobuf/io/coded_stream.h>
11#include <google/protobuf/wire_format_lite_inl.h>
12#include <google/protobuf/descriptor.h>
13#include <google/protobuf/generated_message_reflection.h>
14#include <google/protobuf/reflection_ops.h>
15#include <google/protobuf/wire_format.h>
16// This is a temporary google only hack
17#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
18#include "third_party/protobuf/version.h"
19#endif
20// @@protoc_insertion_point(includes)
21
22namespace protobuf_RpcHeader_2eproto {
23extern PROTOBUF_INTERNAL_EXPORT_protobuf_RpcHeader_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_RpcSaslProto_SaslAuth;
24} // namespace protobuf_RpcHeader_2eproto
25namespace Hdfs {
26namespace Internal {
27class RpcRequestHeaderProtoDefaultTypeInternal {
28 public:
29 ::google::protobuf::internal::ExplicitlyConstructed<RpcRequestHeaderProto>
30 _instance;
31} _RpcRequestHeaderProto_default_instance_;
32class RpcResponseHeaderProtoDefaultTypeInternal {
33 public:
34 ::google::protobuf::internal::ExplicitlyConstructed<RpcResponseHeaderProto>
35 _instance;
36} _RpcResponseHeaderProto_default_instance_;
37class RpcSaslProto_SaslAuthDefaultTypeInternal {
38 public:
39 ::google::protobuf::internal::ExplicitlyConstructed<RpcSaslProto_SaslAuth>
40 _instance;
41} _RpcSaslProto_SaslAuth_default_instance_;
42class RpcSaslProtoDefaultTypeInternal {
43 public:
44 ::google::protobuf::internal::ExplicitlyConstructed<RpcSaslProto>
45 _instance;
46} _RpcSaslProto_default_instance_;
47} // namespace Internal
48} // namespace Hdfs
49namespace protobuf_RpcHeader_2eproto {
50static void InitDefaultsRpcRequestHeaderProto() {
51 GOOGLE_PROTOBUF_VERIFY_VERSION;
52
53 {
54 void* ptr = &::Hdfs::Internal::_RpcRequestHeaderProto_default_instance_;
55 new (ptr) ::Hdfs::Internal::RpcRequestHeaderProto();
56 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
57 }
58 ::Hdfs::Internal::RpcRequestHeaderProto::InitAsDefaultInstance();
59}
60
61::google::protobuf::internal::SCCInfo<0> scc_info_RpcRequestHeaderProto =
62 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRpcRequestHeaderProto}, {}};
63
64static void InitDefaultsRpcResponseHeaderProto() {
65 GOOGLE_PROTOBUF_VERIFY_VERSION;
66
67 {
68 void* ptr = &::Hdfs::Internal::_RpcResponseHeaderProto_default_instance_;
69 new (ptr) ::Hdfs::Internal::RpcResponseHeaderProto();
70 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
71 }
72 ::Hdfs::Internal::RpcResponseHeaderProto::InitAsDefaultInstance();
73}
74
75::google::protobuf::internal::SCCInfo<0> scc_info_RpcResponseHeaderProto =
76 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRpcResponseHeaderProto}, {}};
77
78static void InitDefaultsRpcSaslProto_SaslAuth() {
79 GOOGLE_PROTOBUF_VERIFY_VERSION;
80
81 {
82 void* ptr = &::Hdfs::Internal::_RpcSaslProto_SaslAuth_default_instance_;
83 new (ptr) ::Hdfs::Internal::RpcSaslProto_SaslAuth();
84 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
85 }
86 ::Hdfs::Internal::RpcSaslProto_SaslAuth::InitAsDefaultInstance();
87}
88
89::google::protobuf::internal::SCCInfo<0> scc_info_RpcSaslProto_SaslAuth =
90 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRpcSaslProto_SaslAuth}, {}};
91
92static void InitDefaultsRpcSaslProto() {
93 GOOGLE_PROTOBUF_VERIFY_VERSION;
94
95 {
96 void* ptr = &::Hdfs::Internal::_RpcSaslProto_default_instance_;
97 new (ptr) ::Hdfs::Internal::RpcSaslProto();
98 ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
99 }
100 ::Hdfs::Internal::RpcSaslProto::InitAsDefaultInstance();
101}
102
103::google::protobuf::internal::SCCInfo<1> scc_info_RpcSaslProto =
104 {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsRpcSaslProto}, {
105 &protobuf_RpcHeader_2eproto::scc_info_RpcSaslProto_SaslAuth.base,}};
106
107void InitDefaults() {
108 ::google::protobuf::internal::InitSCC(&scc_info_RpcRequestHeaderProto.base);
109 ::google::protobuf::internal::InitSCC(&scc_info_RpcResponseHeaderProto.base);
110 ::google::protobuf::internal::InitSCC(&scc_info_RpcSaslProto_SaslAuth.base);
111 ::google::protobuf::internal::InitSCC(&scc_info_RpcSaslProto.base);
112}
113
114::google::protobuf::Metadata file_level_metadata[4];
115const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[5];
116
117const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
118 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcRequestHeaderProto, _has_bits_),
119 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcRequestHeaderProto, _internal_metadata_),
120 ~0u, // no _extensions_
121 ~0u, // no _oneof_case_
122 ~0u, // no _weak_field_map_
123 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcRequestHeaderProto, rpckind_),
124 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcRequestHeaderProto, rpcop_),
125 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcRequestHeaderProto, callid_),
126 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcRequestHeaderProto, clientid_),
127 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcRequestHeaderProto, retrycount_),
128 1,
129 2,
130 3,
131 0,
132 4,
133 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, _has_bits_),
134 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, _internal_metadata_),
135 ~0u, // no _extensions_
136 ~0u, // no _oneof_case_
137 ~0u, // no _weak_field_map_
138 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, callid_),
139 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, status_),
140 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, serveripcversionnum_),
141 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, exceptionclassname_),
142 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, errormsg_),
143 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, errordetail_),
144 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, clientid_),
145 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcResponseHeaderProto, retrycount_),
146 3,
147 4,
148 5,
149 0,
150 1,
151 6,
152 2,
153 7,
154 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto_SaslAuth, _has_bits_),
155 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto_SaslAuth, _internal_metadata_),
156 ~0u, // no _extensions_
157 ~0u, // no _oneof_case_
158 ~0u, // no _weak_field_map_
159 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto_SaslAuth, method_),
160 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto_SaslAuth, mechanism_),
161 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto_SaslAuth, protocol_),
162 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto_SaslAuth, serverid_),
163 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto_SaslAuth, challenge_),
164 0,
165 1,
166 2,
167 3,
168 4,
169 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto, _has_bits_),
170 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto, _internal_metadata_),
171 ~0u, // no _extensions_
172 ~0u, // no _oneof_case_
173 ~0u, // no _weak_field_map_
174 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto, version_),
175 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto, state_),
176 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto, token_),
177 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Hdfs::Internal::RpcSaslProto, auths_),
178 1,
179 2,
180 0,
181 ~0u,
182};
183static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
184 { 0, 10, sizeof(::Hdfs::Internal::RpcRequestHeaderProto)},
185 { 15, 28, sizeof(::Hdfs::Internal::RpcResponseHeaderProto)},
186 { 36, 46, sizeof(::Hdfs::Internal::RpcSaslProto_SaslAuth)},
187 { 51, 60, sizeof(::Hdfs::Internal::RpcSaslProto)},
188};
189
190static ::google::protobuf::Message const * const file_default_instances[] = {
191 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_RpcRequestHeaderProto_default_instance_),
192 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_RpcResponseHeaderProto_default_instance_),
193 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_RpcSaslProto_SaslAuth_default_instance_),
194 reinterpret_cast<const ::google::protobuf::Message*>(&::Hdfs::Internal::_RpcSaslProto_default_instance_),
195};
196
197void protobuf_AssignDescriptors() {
198 AddDescriptors();
199 AssignDescriptors(
200 "RpcHeader.proto", schemas, file_default_instances, TableStruct::offsets,
201 file_level_metadata, file_level_enum_descriptors, NULL);
202}
203
204void protobuf_AssignDescriptorsOnce() {
205 static ::google::protobuf::internal::once_flag once;
206 ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors);
207}
208
209void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
210void protobuf_RegisterTypes(const ::std::string&) {
211 protobuf_AssignDescriptorsOnce();
212 ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 4);
213}
214
215void AddDescriptorsImpl() {
216 InitDefaults();
217 static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
218 "\n\017RpcHeader.proto\022\rHdfs.Internal\"\242\002\n\025Rpc"
219 "RequestHeaderProto\022,\n\007rpcKind\030\001 \001(\0162\033.Hd"
220 "fs.Internal.RpcKindProto\022B\n\005rpcOp\030\002 \001(\0162"
221 "3.Hdfs.Internal.RpcRequestHeaderProto.Op"
222 "erationProto\022\016\n\006callId\030\003 \002(\021\022\020\n\010clientId"
223 "\030\004 \002(\014\022\026\n\nretryCount\030\005 \001(\021:\002-1\"]\n\016Operat"
224 "ionProto\022\024\n\020RPC_FINAL_PACKET\020\000\022\033\n\027RPC_CO"
225 "NTINUATION_PACKET\020\001\022\030\n\024RPC_CLOSE_CONNECT"
226 "ION\020\002\"\312\005\n\026RpcResponseHeaderProto\022\016\n\006call"
227 "Id\030\001 \002(\r\022D\n\006status\030\002 \002(\01624.Hdfs.Internal"
228 ".RpcResponseHeaderProto.RpcStatusProto\022\033"
229 "\n\023serverIpcVersionNum\030\003 \001(\r\022\032\n\022exception"
230 "ClassName\030\004 \001(\t\022\020\n\010errorMsg\030\005 \001(\t\022L\n\013err"
231 "orDetail\030\006 \001(\01627.Hdfs.Internal.RpcRespon"
232 "seHeaderProto.RpcErrorCodeProto\022\020\n\010clien"
233 "tId\030\007 \001(\014\022\026\n\nretryCount\030\010 \001(\021:\002-1\"3\n\016Rpc"
234 "StatusProto\022\013\n\007SUCCESS\020\000\022\t\n\005ERROR\020\001\022\t\n\005F"
235 "ATAL\020\002\"\341\002\n\021RpcErrorCodeProto\022\025\n\021ERROR_AP"
236 "PLICATION\020\001\022\030\n\024ERROR_NO_SUCH_METHOD\020\002\022\032\n"
237 "\026ERROR_NO_SUCH_PROTOCOL\020\003\022\024\n\020ERROR_RPC_S"
238 "ERVER\020\004\022\036\n\032ERROR_SERIALIZING_RESPONSE\020\005\022"
239 "\036\n\032ERROR_RPC_VERSION_MISMATCH\020\006\022\021\n\rFATAL"
240 "_UNKNOWN\020\n\022#\n\037FATAL_UNSUPPORTED_SERIALIZ"
241 "ATION\020\013\022\034\n\030FATAL_INVALID_RPC_HEADER\020\014\022\037\n"
242 "\033FATAL_DESERIALIZING_REQUEST\020\r\022\032\n\026FATAL_"
243 "VERSION_MISMATCH\020\016\022\026\n\022FATAL_UNAUTHORIZED"
244 "\020\017\"\335\002\n\014RpcSaslProto\022\017\n\007version\030\001 \001(\r\0224\n\005"
245 "state\030\002 \002(\0162%.Hdfs.Internal.RpcSaslProto"
246 ".SaslState\022\r\n\005token\030\003 \001(\014\0223\n\005auths\030\004 \003(\013"
247 "2$.Hdfs.Internal.RpcSaslProto.SaslAuth\032d"
248 "\n\010SaslAuth\022\016\n\006method\030\001 \002(\t\022\021\n\tmechanism\030"
249 "\002 \002(\t\022\020\n\010protocol\030\003 \001(\t\022\020\n\010serverId\030\004 \001("
250 "\t\022\021\n\tchallenge\030\005 \001(\014\"\\\n\tSaslState\022\013\n\007SUC"
251 "CESS\020\000\022\r\n\tNEGOTIATE\020\001\022\014\n\010INITIATE\020\002\022\r\n\tC"
252 "HALLENGE\020\003\022\014\n\010RESPONSE\020\004\022\010\n\004WRAP\020\005*J\n\014Rp"
253 "cKindProto\022\017\n\013RPC_BUILTIN\020\000\022\020\n\014RPC_WRITA"
254 "BLE\020\001\022\027\n\023RPC_PROTOCOL_BUFFER\020\002B4\n\036org.ap"
255 "ache.hadoop.ipc.protobufB\017RpcHeaderProto"
256 "s\240\001\001"
257 };
258 ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
259 descriptor, 1524);
260 ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
261 "RpcHeader.proto", &protobuf_RegisterTypes);
262}
263
264void AddDescriptors() {
265 static ::google::protobuf::internal::once_flag once;
266 ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
267}
268// Force AddDescriptors() to be called at dynamic initialization time.
269struct StaticDescriptorInitializer {
270 StaticDescriptorInitializer() {
271 AddDescriptors();
272 }
273} static_descriptor_initializer;
274} // namespace protobuf_RpcHeader_2eproto
275namespace Hdfs {
276namespace Internal {
277const ::google::protobuf::EnumDescriptor* RpcRequestHeaderProto_OperationProto_descriptor() {
278 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
279 return protobuf_RpcHeader_2eproto::file_level_enum_descriptors[0];
280}
281bool RpcRequestHeaderProto_OperationProto_IsValid(int value) {
282 switch (value) {
283 case 0:
284 case 1:
285 case 2:
286 return true;
287 default:
288 return false;
289 }
290}
291
292#if !defined(_MSC_VER) || _MSC_VER >= 1900
293const RpcRequestHeaderProto_OperationProto RpcRequestHeaderProto::RPC_FINAL_PACKET;
294const RpcRequestHeaderProto_OperationProto RpcRequestHeaderProto::RPC_CONTINUATION_PACKET;
295const RpcRequestHeaderProto_OperationProto RpcRequestHeaderProto::RPC_CLOSE_CONNECTION;
296const RpcRequestHeaderProto_OperationProto RpcRequestHeaderProto::OperationProto_MIN;
297const RpcRequestHeaderProto_OperationProto RpcRequestHeaderProto::OperationProto_MAX;
298const int RpcRequestHeaderProto::OperationProto_ARRAYSIZE;
299#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
300const ::google::protobuf::EnumDescriptor* RpcResponseHeaderProto_RpcStatusProto_descriptor() {
301 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
302 return protobuf_RpcHeader_2eproto::file_level_enum_descriptors[1];
303}
304bool RpcResponseHeaderProto_RpcStatusProto_IsValid(int value) {
305 switch (value) {
306 case 0:
307 case 1:
308 case 2:
309 return true;
310 default:
311 return false;
312 }
313}
314
315#if !defined(_MSC_VER) || _MSC_VER >= 1900
316const RpcResponseHeaderProto_RpcStatusProto RpcResponseHeaderProto::SUCCESS;
317const RpcResponseHeaderProto_RpcStatusProto RpcResponseHeaderProto::ERROR;
318const RpcResponseHeaderProto_RpcStatusProto RpcResponseHeaderProto::FATAL;
319const RpcResponseHeaderProto_RpcStatusProto RpcResponseHeaderProto::RpcStatusProto_MIN;
320const RpcResponseHeaderProto_RpcStatusProto RpcResponseHeaderProto::RpcStatusProto_MAX;
321const int RpcResponseHeaderProto::RpcStatusProto_ARRAYSIZE;
322#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
323const ::google::protobuf::EnumDescriptor* RpcResponseHeaderProto_RpcErrorCodeProto_descriptor() {
324 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
325 return protobuf_RpcHeader_2eproto::file_level_enum_descriptors[2];
326}
327bool RpcResponseHeaderProto_RpcErrorCodeProto_IsValid(int value) {
328 switch (value) {
329 case 1:
330 case 2:
331 case 3:
332 case 4:
333 case 5:
334 case 6:
335 case 10:
336 case 11:
337 case 12:
338 case 13:
339 case 14:
340 case 15:
341 return true;
342 default:
343 return false;
344 }
345}
346
347#if !defined(_MSC_VER) || _MSC_VER >= 1900
348const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::ERROR_APPLICATION;
349const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::ERROR_NO_SUCH_METHOD;
350const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::ERROR_NO_SUCH_PROTOCOL;
351const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::ERROR_RPC_SERVER;
352const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::ERROR_SERIALIZING_RESPONSE;
353const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::ERROR_RPC_VERSION_MISMATCH;
354const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::FATAL_UNKNOWN;
355const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::FATAL_UNSUPPORTED_SERIALIZATION;
356const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::FATAL_INVALID_RPC_HEADER;
357const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::FATAL_DESERIALIZING_REQUEST;
358const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::FATAL_VERSION_MISMATCH;
359const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::FATAL_UNAUTHORIZED;
360const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::RpcErrorCodeProto_MIN;
361const RpcResponseHeaderProto_RpcErrorCodeProto RpcResponseHeaderProto::RpcErrorCodeProto_MAX;
362const int RpcResponseHeaderProto::RpcErrorCodeProto_ARRAYSIZE;
363#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
364const ::google::protobuf::EnumDescriptor* RpcSaslProto_SaslState_descriptor() {
365 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
366 return protobuf_RpcHeader_2eproto::file_level_enum_descriptors[3];
367}
368bool RpcSaslProto_SaslState_IsValid(int value) {
369 switch (value) {
370 case 0:
371 case 1:
372 case 2:
373 case 3:
374 case 4:
375 case 5:
376 return true;
377 default:
378 return false;
379 }
380}
381
382#if !defined(_MSC_VER) || _MSC_VER >= 1900
383const RpcSaslProto_SaslState RpcSaslProto::SUCCESS;
384const RpcSaslProto_SaslState RpcSaslProto::NEGOTIATE;
385const RpcSaslProto_SaslState RpcSaslProto::INITIATE;
386const RpcSaslProto_SaslState RpcSaslProto::CHALLENGE;
387const RpcSaslProto_SaslState RpcSaslProto::RESPONSE;
388const RpcSaslProto_SaslState RpcSaslProto::WRAP;
389const RpcSaslProto_SaslState RpcSaslProto::SaslState_MIN;
390const RpcSaslProto_SaslState RpcSaslProto::SaslState_MAX;
391const int RpcSaslProto::SaslState_ARRAYSIZE;
392#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
393const ::google::protobuf::EnumDescriptor* RpcKindProto_descriptor() {
394 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
395 return protobuf_RpcHeader_2eproto::file_level_enum_descriptors[4];
396}
397bool RpcKindProto_IsValid(int value) {
398 switch (value) {
399 case 0:
400 case 1:
401 case 2:
402 return true;
403 default:
404 return false;
405 }
406}
407
408
409// ===================================================================
410
411void RpcRequestHeaderProto::InitAsDefaultInstance() {
412}
413#if !defined(_MSC_VER) || _MSC_VER >= 1900
414const int RpcRequestHeaderProto::kRpcKindFieldNumber;
415const int RpcRequestHeaderProto::kRpcOpFieldNumber;
416const int RpcRequestHeaderProto::kCallIdFieldNumber;
417const int RpcRequestHeaderProto::kClientIdFieldNumber;
418const int RpcRequestHeaderProto::kRetryCountFieldNumber;
419#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
420
421RpcRequestHeaderProto::RpcRequestHeaderProto()
422 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
423 ::google::protobuf::internal::InitSCC(
424 &protobuf_RpcHeader_2eproto::scc_info_RpcRequestHeaderProto.base);
425 SharedCtor();
426 // @@protoc_insertion_point(constructor:Hdfs.Internal.RpcRequestHeaderProto)
427}
428RpcRequestHeaderProto::RpcRequestHeaderProto(const RpcRequestHeaderProto& from)
429 : ::google::protobuf::Message(),
430 _internal_metadata_(NULL),
431 _has_bits_(from._has_bits_) {
432 _internal_metadata_.MergeFrom(from._internal_metadata_);
433 clientid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
434 if (from.has_clientid()) {
435 clientid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.clientid_);
436 }
437 ::memcpy(&rpckind_, &from.rpckind_,
438 static_cast<size_t>(reinterpret_cast<char*>(&retrycount_) -
439 reinterpret_cast<char*>(&rpckind_)) + sizeof(retrycount_));
440 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.RpcRequestHeaderProto)
441}
442
443void RpcRequestHeaderProto::SharedCtor() {
444 clientid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
445 ::memset(&rpckind_, 0, static_cast<size_t>(
446 reinterpret_cast<char*>(&callid_) -
447 reinterpret_cast<char*>(&rpckind_)) + sizeof(callid_));
448 retrycount_ = -1;
449}
450
451RpcRequestHeaderProto::~RpcRequestHeaderProto() {
452 // @@protoc_insertion_point(destructor:Hdfs.Internal.RpcRequestHeaderProto)
453 SharedDtor();
454}
455
456void RpcRequestHeaderProto::SharedDtor() {
457 clientid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
458}
459
460void RpcRequestHeaderProto::SetCachedSize(int size) const {
461 _cached_size_.Set(size);
462}
463const ::google::protobuf::Descriptor* RpcRequestHeaderProto::descriptor() {
464 ::protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
465 return ::protobuf_RpcHeader_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
466}
467
468const RpcRequestHeaderProto& RpcRequestHeaderProto::default_instance() {
469 ::google::protobuf::internal::InitSCC(&protobuf_RpcHeader_2eproto::scc_info_RpcRequestHeaderProto.base);
470 return *internal_default_instance();
471}
472
473
474void RpcRequestHeaderProto::Clear() {
475// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.RpcRequestHeaderProto)
476 ::google::protobuf::uint32 cached_has_bits = 0;
477 // Prevent compiler warnings about cached_has_bits being unused
478 (void) cached_has_bits;
479
480 cached_has_bits = _has_bits_[0];
481 if (cached_has_bits & 0x00000001u) {
482 clientid_.ClearNonDefaultToEmptyNoArena();
483 }
484 if (cached_has_bits & 30u) {
485 ::memset(&rpckind_, 0, static_cast<size_t>(
486 reinterpret_cast<char*>(&callid_) -
487 reinterpret_cast<char*>(&rpckind_)) + sizeof(callid_));
488 retrycount_ = -1;
489 }
490 _has_bits_.Clear();
491 _internal_metadata_.Clear();
492}
493
494bool RpcRequestHeaderProto::MergePartialFromCodedStream(
495 ::google::protobuf::io::CodedInputStream* input) {
496#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
497 ::google::protobuf::uint32 tag;
498 // @@protoc_insertion_point(parse_start:Hdfs.Internal.RpcRequestHeaderProto)
499 for (;;) {
500 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
501 tag = p.first;
502 if (!p.second) goto handle_unusual;
503 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
504 // optional .Hdfs.Internal.RpcKindProto rpcKind = 1;
505 case 1: {
506 if (static_cast< ::google::protobuf::uint8>(tag) ==
507 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
508 int value;
509 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
510 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
511 input, &value)));
512 if (::Hdfs::Internal::RpcKindProto_IsValid(value)) {
513 set_rpckind(static_cast< ::Hdfs::Internal::RpcKindProto >(value));
514 } else {
515 mutable_unknown_fields()->AddVarint(
516 1, static_cast< ::google::protobuf::uint64>(value));
517 }
518 } else {
519 goto handle_unusual;
520 }
521 break;
522 }
523
524 // optional .Hdfs.Internal.RpcRequestHeaderProto.OperationProto rpcOp = 2;
525 case 2: {
526 if (static_cast< ::google::protobuf::uint8>(tag) ==
527 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
528 int value;
529 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
530 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
531 input, &value)));
532 if (::Hdfs::Internal::RpcRequestHeaderProto_OperationProto_IsValid(value)) {
533 set_rpcop(static_cast< ::Hdfs::Internal::RpcRequestHeaderProto_OperationProto >(value));
534 } else {
535 mutable_unknown_fields()->AddVarint(
536 2, static_cast< ::google::protobuf::uint64>(value));
537 }
538 } else {
539 goto handle_unusual;
540 }
541 break;
542 }
543
544 // required sint32 callId = 3;
545 case 3: {
546 if (static_cast< ::google::protobuf::uint8>(tag) ==
547 static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
548 set_has_callid();
549 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
550 ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
551 input, &callid_)));
552 } else {
553 goto handle_unusual;
554 }
555 break;
556 }
557
558 // required bytes clientId = 4;
559 case 4: {
560 if (static_cast< ::google::protobuf::uint8>(tag) ==
561 static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
562 DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
563 input, this->mutable_clientid()));
564 } else {
565 goto handle_unusual;
566 }
567 break;
568 }
569
570 // optional sint32 retryCount = 5 [default = -1];
571 case 5: {
572 if (static_cast< ::google::protobuf::uint8>(tag) ==
573 static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
574 set_has_retrycount();
575 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
576 ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
577 input, &retrycount_)));
578 } else {
579 goto handle_unusual;
580 }
581 break;
582 }
583
584 default: {
585 handle_unusual:
586 if (tag == 0) {
587 goto success;
588 }
589 DO_(::google::protobuf::internal::WireFormat::SkipField(
590 input, tag, _internal_metadata_.mutable_unknown_fields()));
591 break;
592 }
593 }
594 }
595success:
596 // @@protoc_insertion_point(parse_success:Hdfs.Internal.RpcRequestHeaderProto)
597 return true;
598failure:
599 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.RpcRequestHeaderProto)
600 return false;
601#undef DO_
602}
603
604void RpcRequestHeaderProto::SerializeWithCachedSizes(
605 ::google::protobuf::io::CodedOutputStream* output) const {
606 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.RpcRequestHeaderProto)
607 ::google::protobuf::uint32 cached_has_bits = 0;
608 (void) cached_has_bits;
609
610 cached_has_bits = _has_bits_[0];
611 // optional .Hdfs.Internal.RpcKindProto rpcKind = 1;
612 if (cached_has_bits & 0x00000002u) {
613 ::google::protobuf::internal::WireFormatLite::WriteEnum(
614 1, this->rpckind(), output);
615 }
616
617 // optional .Hdfs.Internal.RpcRequestHeaderProto.OperationProto rpcOp = 2;
618 if (cached_has_bits & 0x00000004u) {
619 ::google::protobuf::internal::WireFormatLite::WriteEnum(
620 2, this->rpcop(), output);
621 }
622
623 // required sint32 callId = 3;
624 if (cached_has_bits & 0x00000008u) {
625 ::google::protobuf::internal::WireFormatLite::WriteSInt32(3, this->callid(), output);
626 }
627
628 // required bytes clientId = 4;
629 if (cached_has_bits & 0x00000001u) {
630 ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
631 4, this->clientid(), output);
632 }
633
634 // optional sint32 retryCount = 5 [default = -1];
635 if (cached_has_bits & 0x00000010u) {
636 ::google::protobuf::internal::WireFormatLite::WriteSInt32(5, this->retrycount(), output);
637 }
638
639 if (_internal_metadata_.have_unknown_fields()) {
640 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
641 _internal_metadata_.unknown_fields(), output);
642 }
643 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.RpcRequestHeaderProto)
644}
645
646::google::protobuf::uint8* RpcRequestHeaderProto::InternalSerializeWithCachedSizesToArray(
647 bool deterministic, ::google::protobuf::uint8* target) const {
648 (void)deterministic; // Unused
649 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.RpcRequestHeaderProto)
650 ::google::protobuf::uint32 cached_has_bits = 0;
651 (void) cached_has_bits;
652
653 cached_has_bits = _has_bits_[0];
654 // optional .Hdfs.Internal.RpcKindProto rpcKind = 1;
655 if (cached_has_bits & 0x00000002u) {
656 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
657 1, this->rpckind(), target);
658 }
659
660 // optional .Hdfs.Internal.RpcRequestHeaderProto.OperationProto rpcOp = 2;
661 if (cached_has_bits & 0x00000004u) {
662 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
663 2, this->rpcop(), target);
664 }
665
666 // required sint32 callId = 3;
667 if (cached_has_bits & 0x00000008u) {
668 target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(3, this->callid(), target);
669 }
670
671 // required bytes clientId = 4;
672 if (cached_has_bits & 0x00000001u) {
673 target =
674 ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
675 4, this->clientid(), target);
676 }
677
678 // optional sint32 retryCount = 5 [default = -1];
679 if (cached_has_bits & 0x00000010u) {
680 target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(5, this->retrycount(), target);
681 }
682
683 if (_internal_metadata_.have_unknown_fields()) {
684 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
685 _internal_metadata_.unknown_fields(), target);
686 }
687 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.RpcRequestHeaderProto)
688 return target;
689}
690
691size_t RpcRequestHeaderProto::RequiredFieldsByteSizeFallback() const {
692// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.RpcRequestHeaderProto)
693 size_t total_size = 0;
694
695 if (has_clientid()) {
696 // required bytes clientId = 4;
697 total_size += 1 +
698 ::google::protobuf::internal::WireFormatLite::BytesSize(
699 this->clientid());
700 }
701
702 if (has_callid()) {
703 // required sint32 callId = 3;
704 total_size += 1 +
705 ::google::protobuf::internal::WireFormatLite::SInt32Size(
706 this->callid());
707 }
708
709 return total_size;
710}
711size_t RpcRequestHeaderProto::ByteSizeLong() const {
712// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.RpcRequestHeaderProto)
713 size_t total_size = 0;
714
715 if (_internal_metadata_.have_unknown_fields()) {
716 total_size +=
717 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
718 _internal_metadata_.unknown_fields());
719 }
720 if (((_has_bits_[0] & 0x00000009) ^ 0x00000009) == 0) { // All required fields are present.
721 // required bytes clientId = 4;
722 total_size += 1 +
723 ::google::protobuf::internal::WireFormatLite::BytesSize(
724 this->clientid());
725
726 // required sint32 callId = 3;
727 total_size += 1 +
728 ::google::protobuf::internal::WireFormatLite::SInt32Size(
729 this->callid());
730
731 } else {
732 total_size += RequiredFieldsByteSizeFallback();
733 }
734 if (_has_bits_[0 / 32] & 6u) {
735 // optional .Hdfs.Internal.RpcKindProto rpcKind = 1;
736 if (has_rpckind()) {
737 total_size += 1 +
738 ::google::protobuf::internal::WireFormatLite::EnumSize(this->rpckind());
739 }
740
741 // optional .Hdfs.Internal.RpcRequestHeaderProto.OperationProto rpcOp = 2;
742 if (has_rpcop()) {
743 total_size += 1 +
744 ::google::protobuf::internal::WireFormatLite::EnumSize(this->rpcop());
745 }
746
747 }
748 // optional sint32 retryCount = 5 [default = -1];
749 if (has_retrycount()) {
750 total_size += 1 +
751 ::google::protobuf::internal::WireFormatLite::SInt32Size(
752 this->retrycount());
753 }
754
755 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
756 SetCachedSize(cached_size);
757 return total_size;
758}
759
760void RpcRequestHeaderProto::MergeFrom(const ::google::protobuf::Message& from) {
761// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.RpcRequestHeaderProto)
762 GOOGLE_DCHECK_NE(&from, this);
763 const RpcRequestHeaderProto* source =
764 ::google::protobuf::internal::DynamicCastToGenerated<const RpcRequestHeaderProto>(
765 &from);
766 if (source == NULL) {
767 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.RpcRequestHeaderProto)
768 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
769 } else {
770 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.RpcRequestHeaderProto)
771 MergeFrom(*source);
772 }
773}
774
775void RpcRequestHeaderProto::MergeFrom(const RpcRequestHeaderProto& from) {
776// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.RpcRequestHeaderProto)
777 GOOGLE_DCHECK_NE(&from, this);
778 _internal_metadata_.MergeFrom(from._internal_metadata_);
779 ::google::protobuf::uint32 cached_has_bits = 0;
780 (void) cached_has_bits;
781
782 cached_has_bits = from._has_bits_[0];
783 if (cached_has_bits & 31u) {
784 if (cached_has_bits & 0x00000001u) {
785 set_has_clientid();
786 clientid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.clientid_);
787 }
788 if (cached_has_bits & 0x00000002u) {
789 rpckind_ = from.rpckind_;
790 }
791 if (cached_has_bits & 0x00000004u) {
792 rpcop_ = from.rpcop_;
793 }
794 if (cached_has_bits & 0x00000008u) {
795 callid_ = from.callid_;
796 }
797 if (cached_has_bits & 0x00000010u) {
798 retrycount_ = from.retrycount_;
799 }
800 _has_bits_[0] |= cached_has_bits;
801 }
802}
803
804void RpcRequestHeaderProto::CopyFrom(const ::google::protobuf::Message& from) {
805// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.RpcRequestHeaderProto)
806 if (&from == this) return;
807 Clear();
808 MergeFrom(from);
809}
810
811void RpcRequestHeaderProto::CopyFrom(const RpcRequestHeaderProto& from) {
812// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.RpcRequestHeaderProto)
813 if (&from == this) return;
814 Clear();
815 MergeFrom(from);
816}
817
818bool RpcRequestHeaderProto::IsInitialized() const {
819 if ((_has_bits_[0] & 0x00000009) != 0x00000009) return false;
820 return true;
821}
822
823void RpcRequestHeaderProto::Swap(RpcRequestHeaderProto* other) {
824 if (other == this) return;
825 InternalSwap(other);
826}
827void RpcRequestHeaderProto::InternalSwap(RpcRequestHeaderProto* other) {
828 using std::swap;
829 clientid_.Swap(&other->clientid_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
830 GetArenaNoVirtual());
831 swap(rpckind_, other->rpckind_);
832 swap(rpcop_, other->rpcop_);
833 swap(callid_, other->callid_);
834 swap(retrycount_, other->retrycount_);
835 swap(_has_bits_[0], other->_has_bits_[0]);
836 _internal_metadata_.Swap(&other->_internal_metadata_);
837}
838
839::google::protobuf::Metadata RpcRequestHeaderProto::GetMetadata() const {
840 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
841 return ::protobuf_RpcHeader_2eproto::file_level_metadata[kIndexInFileMessages];
842}
843
844
845// ===================================================================
846
847void RpcResponseHeaderProto::InitAsDefaultInstance() {
848}
849#if !defined(_MSC_VER) || _MSC_VER >= 1900
850const int RpcResponseHeaderProto::kCallIdFieldNumber;
851const int RpcResponseHeaderProto::kStatusFieldNumber;
852const int RpcResponseHeaderProto::kServerIpcVersionNumFieldNumber;
853const int RpcResponseHeaderProto::kExceptionClassNameFieldNumber;
854const int RpcResponseHeaderProto::kErrorMsgFieldNumber;
855const int RpcResponseHeaderProto::kErrorDetailFieldNumber;
856const int RpcResponseHeaderProto::kClientIdFieldNumber;
857const int RpcResponseHeaderProto::kRetryCountFieldNumber;
858#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
859
860RpcResponseHeaderProto::RpcResponseHeaderProto()
861 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
862 ::google::protobuf::internal::InitSCC(
863 &protobuf_RpcHeader_2eproto::scc_info_RpcResponseHeaderProto.base);
864 SharedCtor();
865 // @@protoc_insertion_point(constructor:Hdfs.Internal.RpcResponseHeaderProto)
866}
867RpcResponseHeaderProto::RpcResponseHeaderProto(const RpcResponseHeaderProto& from)
868 : ::google::protobuf::Message(),
869 _internal_metadata_(NULL),
870 _has_bits_(from._has_bits_) {
871 _internal_metadata_.MergeFrom(from._internal_metadata_);
872 exceptionclassname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
873 if (from.has_exceptionclassname()) {
874 exceptionclassname_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.exceptionclassname_);
875 }
876 errormsg_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
877 if (from.has_errormsg()) {
878 errormsg_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.errormsg_);
879 }
880 clientid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
881 if (from.has_clientid()) {
882 clientid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.clientid_);
883 }
884 ::memcpy(&callid_, &from.callid_,
885 static_cast<size_t>(reinterpret_cast<char*>(&retrycount_) -
886 reinterpret_cast<char*>(&callid_)) + sizeof(retrycount_));
887 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.RpcResponseHeaderProto)
888}
889
890void RpcResponseHeaderProto::SharedCtor() {
891 exceptionclassname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
892 errormsg_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
893 clientid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
894 ::memset(&callid_, 0, static_cast<size_t>(
895 reinterpret_cast<char*>(&serveripcversionnum_) -
896 reinterpret_cast<char*>(&callid_)) + sizeof(serveripcversionnum_));
897 errordetail_ = 1;
898 retrycount_ = -1;
899}
900
901RpcResponseHeaderProto::~RpcResponseHeaderProto() {
902 // @@protoc_insertion_point(destructor:Hdfs.Internal.RpcResponseHeaderProto)
903 SharedDtor();
904}
905
906void RpcResponseHeaderProto::SharedDtor() {
907 exceptionclassname_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
908 errormsg_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
909 clientid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
910}
911
912void RpcResponseHeaderProto::SetCachedSize(int size) const {
913 _cached_size_.Set(size);
914}
915const ::google::protobuf::Descriptor* RpcResponseHeaderProto::descriptor() {
916 ::protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
917 return ::protobuf_RpcHeader_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
918}
919
920const RpcResponseHeaderProto& RpcResponseHeaderProto::default_instance() {
921 ::google::protobuf::internal::InitSCC(&protobuf_RpcHeader_2eproto::scc_info_RpcResponseHeaderProto.base);
922 return *internal_default_instance();
923}
924
925
926void RpcResponseHeaderProto::Clear() {
927// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.RpcResponseHeaderProto)
928 ::google::protobuf::uint32 cached_has_bits = 0;
929 // Prevent compiler warnings about cached_has_bits being unused
930 (void) cached_has_bits;
931
932 cached_has_bits = _has_bits_[0];
933 if (cached_has_bits & 7u) {
934 if (cached_has_bits & 0x00000001u) {
935 exceptionclassname_.ClearNonDefaultToEmptyNoArena();
936 }
937 if (cached_has_bits & 0x00000002u) {
938 errormsg_.ClearNonDefaultToEmptyNoArena();
939 }
940 if (cached_has_bits & 0x00000004u) {
941 clientid_.ClearNonDefaultToEmptyNoArena();
942 }
943 }
944 if (cached_has_bits & 248u) {
945 ::memset(&callid_, 0, static_cast<size_t>(
946 reinterpret_cast<char*>(&serveripcversionnum_) -
947 reinterpret_cast<char*>(&callid_)) + sizeof(serveripcversionnum_));
948 errordetail_ = 1;
949 retrycount_ = -1;
950 }
951 _has_bits_.Clear();
952 _internal_metadata_.Clear();
953}
954
955bool RpcResponseHeaderProto::MergePartialFromCodedStream(
956 ::google::protobuf::io::CodedInputStream* input) {
957#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
958 ::google::protobuf::uint32 tag;
959 // @@protoc_insertion_point(parse_start:Hdfs.Internal.RpcResponseHeaderProto)
960 for (;;) {
961 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
962 tag = p.first;
963 if (!p.second) goto handle_unusual;
964 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
965 // required uint32 callId = 1;
966 case 1: {
967 if (static_cast< ::google::protobuf::uint8>(tag) ==
968 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
969 set_has_callid();
970 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
971 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
972 input, &callid_)));
973 } else {
974 goto handle_unusual;
975 }
976 break;
977 }
978
979 // required .Hdfs.Internal.RpcResponseHeaderProto.RpcStatusProto status = 2;
980 case 2: {
981 if (static_cast< ::google::protobuf::uint8>(tag) ==
982 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
983 int value;
984 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
985 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
986 input, &value)));
987 if (::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto_IsValid(value)) {
988 set_status(static_cast< ::Hdfs::Internal::RpcResponseHeaderProto_RpcStatusProto >(value));
989 } else {
990 mutable_unknown_fields()->AddVarint(
991 2, static_cast< ::google::protobuf::uint64>(value));
992 }
993 } else {
994 goto handle_unusual;
995 }
996 break;
997 }
998
999 // optional uint32 serverIpcVersionNum = 3;
1000 case 3: {
1001 if (static_cast< ::google::protobuf::uint8>(tag) ==
1002 static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
1003 set_has_serveripcversionnum();
1004 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1005 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
1006 input, &serveripcversionnum_)));
1007 } else {
1008 goto handle_unusual;
1009 }
1010 break;
1011 }
1012
1013 // optional string exceptionClassName = 4;
1014 case 4: {
1015 if (static_cast< ::google::protobuf::uint8>(tag) ==
1016 static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
1017 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1018 input, this->mutable_exceptionclassname()));
1019 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1020 this->exceptionclassname().data(), static_cast<int>(this->exceptionclassname().length()),
1021 ::google::protobuf::internal::WireFormat::PARSE,
1022 "Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName");
1023 } else {
1024 goto handle_unusual;
1025 }
1026 break;
1027 }
1028
1029 // optional string errorMsg = 5;
1030 case 5: {
1031 if (static_cast< ::google::protobuf::uint8>(tag) ==
1032 static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
1033 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1034 input, this->mutable_errormsg()));
1035 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1036 this->errormsg().data(), static_cast<int>(this->errormsg().length()),
1037 ::google::protobuf::internal::WireFormat::PARSE,
1038 "Hdfs.Internal.RpcResponseHeaderProto.errorMsg");
1039 } else {
1040 goto handle_unusual;
1041 }
1042 break;
1043 }
1044
1045 // optional .Hdfs.Internal.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
1046 case 6: {
1047 if (static_cast< ::google::protobuf::uint8>(tag) ==
1048 static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
1049 int value;
1050 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1051 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1052 input, &value)));
1053 if (::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto_IsValid(value)) {
1054 set_errordetail(static_cast< ::Hdfs::Internal::RpcResponseHeaderProto_RpcErrorCodeProto >(value));
1055 } else {
1056 mutable_unknown_fields()->AddVarint(
1057 6, static_cast< ::google::protobuf::uint64>(value));
1058 }
1059 } else {
1060 goto handle_unusual;
1061 }
1062 break;
1063 }
1064
1065 // optional bytes clientId = 7;
1066 case 7: {
1067 if (static_cast< ::google::protobuf::uint8>(tag) ==
1068 static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
1069 DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
1070 input, this->mutable_clientid()));
1071 } else {
1072 goto handle_unusual;
1073 }
1074 break;
1075 }
1076
1077 // optional sint32 retryCount = 8 [default = -1];
1078 case 8: {
1079 if (static_cast< ::google::protobuf::uint8>(tag) ==
1080 static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
1081 set_has_retrycount();
1082 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1083 ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
1084 input, &retrycount_)));
1085 } else {
1086 goto handle_unusual;
1087 }
1088 break;
1089 }
1090
1091 default: {
1092 handle_unusual:
1093 if (tag == 0) {
1094 goto success;
1095 }
1096 DO_(::google::protobuf::internal::WireFormat::SkipField(
1097 input, tag, _internal_metadata_.mutable_unknown_fields()));
1098 break;
1099 }
1100 }
1101 }
1102success:
1103 // @@protoc_insertion_point(parse_success:Hdfs.Internal.RpcResponseHeaderProto)
1104 return true;
1105failure:
1106 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.RpcResponseHeaderProto)
1107 return false;
1108#undef DO_
1109}
1110
1111void RpcResponseHeaderProto::SerializeWithCachedSizes(
1112 ::google::protobuf::io::CodedOutputStream* output) const {
1113 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.RpcResponseHeaderProto)
1114 ::google::protobuf::uint32 cached_has_bits = 0;
1115 (void) cached_has_bits;
1116
1117 cached_has_bits = _has_bits_[0];
1118 // required uint32 callId = 1;
1119 if (cached_has_bits & 0x00000008u) {
1120 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->callid(), output);
1121 }
1122
1123 // required .Hdfs.Internal.RpcResponseHeaderProto.RpcStatusProto status = 2;
1124 if (cached_has_bits & 0x00000010u) {
1125 ::google::protobuf::internal::WireFormatLite::WriteEnum(
1126 2, this->status(), output);
1127 }
1128
1129 // optional uint32 serverIpcVersionNum = 3;
1130 if (cached_has_bits & 0x00000020u) {
1131 ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->serveripcversionnum(), output);
1132 }
1133
1134 // optional string exceptionClassName = 4;
1135 if (cached_has_bits & 0x00000001u) {
1136 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1137 this->exceptionclassname().data(), static_cast<int>(this->exceptionclassname().length()),
1138 ::google::protobuf::internal::WireFormat::SERIALIZE,
1139 "Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName");
1140 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1141 4, this->exceptionclassname(), output);
1142 }
1143
1144 // optional string errorMsg = 5;
1145 if (cached_has_bits & 0x00000002u) {
1146 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1147 this->errormsg().data(), static_cast<int>(this->errormsg().length()),
1148 ::google::protobuf::internal::WireFormat::SERIALIZE,
1149 "Hdfs.Internal.RpcResponseHeaderProto.errorMsg");
1150 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1151 5, this->errormsg(), output);
1152 }
1153
1154 // optional .Hdfs.Internal.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
1155 if (cached_has_bits & 0x00000040u) {
1156 ::google::protobuf::internal::WireFormatLite::WriteEnum(
1157 6, this->errordetail(), output);
1158 }
1159
1160 // optional bytes clientId = 7;
1161 if (cached_has_bits & 0x00000004u) {
1162 ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
1163 7, this->clientid(), output);
1164 }
1165
1166 // optional sint32 retryCount = 8 [default = -1];
1167 if (cached_has_bits & 0x00000080u) {
1168 ::google::protobuf::internal::WireFormatLite::WriteSInt32(8, this->retrycount(), output);
1169 }
1170
1171 if (_internal_metadata_.have_unknown_fields()) {
1172 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1173 _internal_metadata_.unknown_fields(), output);
1174 }
1175 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.RpcResponseHeaderProto)
1176}
1177
1178::google::protobuf::uint8* RpcResponseHeaderProto::InternalSerializeWithCachedSizesToArray(
1179 bool deterministic, ::google::protobuf::uint8* target) const {
1180 (void)deterministic; // Unused
1181 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.RpcResponseHeaderProto)
1182 ::google::protobuf::uint32 cached_has_bits = 0;
1183 (void) cached_has_bits;
1184
1185 cached_has_bits = _has_bits_[0];
1186 // required uint32 callId = 1;
1187 if (cached_has_bits & 0x00000008u) {
1188 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->callid(), target);
1189 }
1190
1191 // required .Hdfs.Internal.RpcResponseHeaderProto.RpcStatusProto status = 2;
1192 if (cached_has_bits & 0x00000010u) {
1193 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1194 2, this->status(), target);
1195 }
1196
1197 // optional uint32 serverIpcVersionNum = 3;
1198 if (cached_has_bits & 0x00000020u) {
1199 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->serveripcversionnum(), target);
1200 }
1201
1202 // optional string exceptionClassName = 4;
1203 if (cached_has_bits & 0x00000001u) {
1204 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1205 this->exceptionclassname().data(), static_cast<int>(this->exceptionclassname().length()),
1206 ::google::protobuf::internal::WireFormat::SERIALIZE,
1207 "Hdfs.Internal.RpcResponseHeaderProto.exceptionClassName");
1208 target =
1209 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1210 4, this->exceptionclassname(), target);
1211 }
1212
1213 // optional string errorMsg = 5;
1214 if (cached_has_bits & 0x00000002u) {
1215 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1216 this->errormsg().data(), static_cast<int>(this->errormsg().length()),
1217 ::google::protobuf::internal::WireFormat::SERIALIZE,
1218 "Hdfs.Internal.RpcResponseHeaderProto.errorMsg");
1219 target =
1220 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1221 5, this->errormsg(), target);
1222 }
1223
1224 // optional .Hdfs.Internal.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
1225 if (cached_has_bits & 0x00000040u) {
1226 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1227 6, this->errordetail(), target);
1228 }
1229
1230 // optional bytes clientId = 7;
1231 if (cached_has_bits & 0x00000004u) {
1232 target =
1233 ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
1234 7, this->clientid(), target);
1235 }
1236
1237 // optional sint32 retryCount = 8 [default = -1];
1238 if (cached_has_bits & 0x00000080u) {
1239 target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(8, this->retrycount(), target);
1240 }
1241
1242 if (_internal_metadata_.have_unknown_fields()) {
1243 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1244 _internal_metadata_.unknown_fields(), target);
1245 }
1246 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.RpcResponseHeaderProto)
1247 return target;
1248}
1249
1250size_t RpcResponseHeaderProto::RequiredFieldsByteSizeFallback() const {
1251// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.RpcResponseHeaderProto)
1252 size_t total_size = 0;
1253
1254 if (has_callid()) {
1255 // required uint32 callId = 1;
1256 total_size += 1 +
1257 ::google::protobuf::internal::WireFormatLite::UInt32Size(
1258 this->callid());
1259 }
1260
1261 if (has_status()) {
1262 // required .Hdfs.Internal.RpcResponseHeaderProto.RpcStatusProto status = 2;
1263 total_size += 1 +
1264 ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
1265 }
1266
1267 return total_size;
1268}
1269size_t RpcResponseHeaderProto::ByteSizeLong() const {
1270// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.RpcResponseHeaderProto)
1271 size_t total_size = 0;
1272
1273 if (_internal_metadata_.have_unknown_fields()) {
1274 total_size +=
1275 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1276 _internal_metadata_.unknown_fields());
1277 }
1278 if (((_has_bits_[0] & 0x00000018) ^ 0x00000018) == 0) { // All required fields are present.
1279 // required uint32 callId = 1;
1280 total_size += 1 +
1281 ::google::protobuf::internal::WireFormatLite::UInt32Size(
1282 this->callid());
1283
1284 // required .Hdfs.Internal.RpcResponseHeaderProto.RpcStatusProto status = 2;
1285 total_size += 1 +
1286 ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
1287
1288 } else {
1289 total_size += RequiredFieldsByteSizeFallback();
1290 }
1291 if (_has_bits_[0 / 32] & 7u) {
1292 // optional string exceptionClassName = 4;
1293 if (has_exceptionclassname()) {
1294 total_size += 1 +
1295 ::google::protobuf::internal::WireFormatLite::StringSize(
1296 this->exceptionclassname());
1297 }
1298
1299 // optional string errorMsg = 5;
1300 if (has_errormsg()) {
1301 total_size += 1 +
1302 ::google::protobuf::internal::WireFormatLite::StringSize(
1303 this->errormsg());
1304 }
1305
1306 // optional bytes clientId = 7;
1307 if (has_clientid()) {
1308 total_size += 1 +
1309 ::google::protobuf::internal::WireFormatLite::BytesSize(
1310 this->clientid());
1311 }
1312
1313 }
1314 if (_has_bits_[0 / 32] & 224u) {
1315 // optional uint32 serverIpcVersionNum = 3;
1316 if (has_serveripcversionnum()) {
1317 total_size += 1 +
1318 ::google::protobuf::internal::WireFormatLite::UInt32Size(
1319 this->serveripcversionnum());
1320 }
1321
1322 // optional .Hdfs.Internal.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
1323 if (has_errordetail()) {
1324 total_size += 1 +
1325 ::google::protobuf::internal::WireFormatLite::EnumSize(this->errordetail());
1326 }
1327
1328 // optional sint32 retryCount = 8 [default = -1];
1329 if (has_retrycount()) {
1330 total_size += 1 +
1331 ::google::protobuf::internal::WireFormatLite::SInt32Size(
1332 this->retrycount());
1333 }
1334
1335 }
1336 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
1337 SetCachedSize(cached_size);
1338 return total_size;
1339}
1340
1341void RpcResponseHeaderProto::MergeFrom(const ::google::protobuf::Message& from) {
1342// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.RpcResponseHeaderProto)
1343 GOOGLE_DCHECK_NE(&from, this);
1344 const RpcResponseHeaderProto* source =
1345 ::google::protobuf::internal::DynamicCastToGenerated<const RpcResponseHeaderProto>(
1346 &from);
1347 if (source == NULL) {
1348 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.RpcResponseHeaderProto)
1349 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1350 } else {
1351 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.RpcResponseHeaderProto)
1352 MergeFrom(*source);
1353 }
1354}
1355
1356void RpcResponseHeaderProto::MergeFrom(const RpcResponseHeaderProto& from) {
1357// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.RpcResponseHeaderProto)
1358 GOOGLE_DCHECK_NE(&from, this);
1359 _internal_metadata_.MergeFrom(from._internal_metadata_);
1360 ::google::protobuf::uint32 cached_has_bits = 0;
1361 (void) cached_has_bits;
1362
1363 cached_has_bits = from._has_bits_[0];
1364 if (cached_has_bits & 255u) {
1365 if (cached_has_bits & 0x00000001u) {
1366 set_has_exceptionclassname();
1367 exceptionclassname_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.exceptionclassname_);
1368 }
1369 if (cached_has_bits & 0x00000002u) {
1370 set_has_errormsg();
1371 errormsg_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.errormsg_);
1372 }
1373 if (cached_has_bits & 0x00000004u) {
1374 set_has_clientid();
1375 clientid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.clientid_);
1376 }
1377 if (cached_has_bits & 0x00000008u) {
1378 callid_ = from.callid_;
1379 }
1380 if (cached_has_bits & 0x00000010u) {
1381 status_ = from.status_;
1382 }
1383 if (cached_has_bits & 0x00000020u) {
1384 serveripcversionnum_ = from.serveripcversionnum_;
1385 }
1386 if (cached_has_bits & 0x00000040u) {
1387 errordetail_ = from.errordetail_;
1388 }
1389 if (cached_has_bits & 0x00000080u) {
1390 retrycount_ = from.retrycount_;
1391 }
1392 _has_bits_[0] |= cached_has_bits;
1393 }
1394}
1395
1396void RpcResponseHeaderProto::CopyFrom(const ::google::protobuf::Message& from) {
1397// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.RpcResponseHeaderProto)
1398 if (&from == this) return;
1399 Clear();
1400 MergeFrom(from);
1401}
1402
1403void RpcResponseHeaderProto::CopyFrom(const RpcResponseHeaderProto& from) {
1404// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.RpcResponseHeaderProto)
1405 if (&from == this) return;
1406 Clear();
1407 MergeFrom(from);
1408}
1409
1410bool RpcResponseHeaderProto::IsInitialized() const {
1411 if ((_has_bits_[0] & 0x00000018) != 0x00000018) return false;
1412 return true;
1413}
1414
1415void RpcResponseHeaderProto::Swap(RpcResponseHeaderProto* other) {
1416 if (other == this) return;
1417 InternalSwap(other);
1418}
1419void RpcResponseHeaderProto::InternalSwap(RpcResponseHeaderProto* other) {
1420 using std::swap;
1421 exceptionclassname_.Swap(&other->exceptionclassname_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1422 GetArenaNoVirtual());
1423 errormsg_.Swap(&other->errormsg_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1424 GetArenaNoVirtual());
1425 clientid_.Swap(&other->clientid_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1426 GetArenaNoVirtual());
1427 swap(callid_, other->callid_);
1428 swap(status_, other->status_);
1429 swap(serveripcversionnum_, other->serveripcversionnum_);
1430 swap(errordetail_, other->errordetail_);
1431 swap(retrycount_, other->retrycount_);
1432 swap(_has_bits_[0], other->_has_bits_[0]);
1433 _internal_metadata_.Swap(&other->_internal_metadata_);
1434}
1435
1436::google::protobuf::Metadata RpcResponseHeaderProto::GetMetadata() const {
1437 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
1438 return ::protobuf_RpcHeader_2eproto::file_level_metadata[kIndexInFileMessages];
1439}
1440
1441
1442// ===================================================================
1443
1444void RpcSaslProto_SaslAuth::InitAsDefaultInstance() {
1445}
1446#if !defined(_MSC_VER) || _MSC_VER >= 1900
1447const int RpcSaslProto_SaslAuth::kMethodFieldNumber;
1448const int RpcSaslProto_SaslAuth::kMechanismFieldNumber;
1449const int RpcSaslProto_SaslAuth::kProtocolFieldNumber;
1450const int RpcSaslProto_SaslAuth::kServerIdFieldNumber;
1451const int RpcSaslProto_SaslAuth::kChallengeFieldNumber;
1452#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
1453
1454RpcSaslProto_SaslAuth::RpcSaslProto_SaslAuth()
1455 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
1456 ::google::protobuf::internal::InitSCC(
1457 &protobuf_RpcHeader_2eproto::scc_info_RpcSaslProto_SaslAuth.base);
1458 SharedCtor();
1459 // @@protoc_insertion_point(constructor:Hdfs.Internal.RpcSaslProto.SaslAuth)
1460}
1461RpcSaslProto_SaslAuth::RpcSaslProto_SaslAuth(const RpcSaslProto_SaslAuth& from)
1462 : ::google::protobuf::Message(),
1463 _internal_metadata_(NULL),
1464 _has_bits_(from._has_bits_) {
1465 _internal_metadata_.MergeFrom(from._internal_metadata_);
1466 method_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1467 if (from.has_method()) {
1468 method_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.method_);
1469 }
1470 mechanism_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1471 if (from.has_mechanism()) {
1472 mechanism_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mechanism_);
1473 }
1474 protocol_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1475 if (from.has_protocol()) {
1476 protocol_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.protocol_);
1477 }
1478 serverid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1479 if (from.has_serverid()) {
1480 serverid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.serverid_);
1481 }
1482 challenge_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1483 if (from.has_challenge()) {
1484 challenge_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.challenge_);
1485 }
1486 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.RpcSaslProto.SaslAuth)
1487}
1488
1489void RpcSaslProto_SaslAuth::SharedCtor() {
1490 method_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1491 mechanism_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1492 protocol_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1493 serverid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1494 challenge_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1495}
1496
1497RpcSaslProto_SaslAuth::~RpcSaslProto_SaslAuth() {
1498 // @@protoc_insertion_point(destructor:Hdfs.Internal.RpcSaslProto.SaslAuth)
1499 SharedDtor();
1500}
1501
1502void RpcSaslProto_SaslAuth::SharedDtor() {
1503 method_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1504 mechanism_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1505 protocol_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1506 serverid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1507 challenge_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1508}
1509
1510void RpcSaslProto_SaslAuth::SetCachedSize(int size) const {
1511 _cached_size_.Set(size);
1512}
1513const ::google::protobuf::Descriptor* RpcSaslProto_SaslAuth::descriptor() {
1514 ::protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
1515 return ::protobuf_RpcHeader_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
1516}
1517
1518const RpcSaslProto_SaslAuth& RpcSaslProto_SaslAuth::default_instance() {
1519 ::google::protobuf::internal::InitSCC(&protobuf_RpcHeader_2eproto::scc_info_RpcSaslProto_SaslAuth.base);
1520 return *internal_default_instance();
1521}
1522
1523
1524void RpcSaslProto_SaslAuth::Clear() {
1525// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1526 ::google::protobuf::uint32 cached_has_bits = 0;
1527 // Prevent compiler warnings about cached_has_bits being unused
1528 (void) cached_has_bits;
1529
1530 cached_has_bits = _has_bits_[0];
1531 if (cached_has_bits & 31u) {
1532 if (cached_has_bits & 0x00000001u) {
1533 method_.ClearNonDefaultToEmptyNoArena();
1534 }
1535 if (cached_has_bits & 0x00000002u) {
1536 mechanism_.ClearNonDefaultToEmptyNoArena();
1537 }
1538 if (cached_has_bits & 0x00000004u) {
1539 protocol_.ClearNonDefaultToEmptyNoArena();
1540 }
1541 if (cached_has_bits & 0x00000008u) {
1542 serverid_.ClearNonDefaultToEmptyNoArena();
1543 }
1544 if (cached_has_bits & 0x00000010u) {
1545 challenge_.ClearNonDefaultToEmptyNoArena();
1546 }
1547 }
1548 _has_bits_.Clear();
1549 _internal_metadata_.Clear();
1550}
1551
1552bool RpcSaslProto_SaslAuth::MergePartialFromCodedStream(
1553 ::google::protobuf::io::CodedInputStream* input) {
1554#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
1555 ::google::protobuf::uint32 tag;
1556 // @@protoc_insertion_point(parse_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1557 for (;;) {
1558 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
1559 tag = p.first;
1560 if (!p.second) goto handle_unusual;
1561 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1562 // required string method = 1;
1563 case 1: {
1564 if (static_cast< ::google::protobuf::uint8>(tag) ==
1565 static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
1566 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1567 input, this->mutable_method()));
1568 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1569 this->method().data(), static_cast<int>(this->method().length()),
1570 ::google::protobuf::internal::WireFormat::PARSE,
1571 "Hdfs.Internal.RpcSaslProto.SaslAuth.method");
1572 } else {
1573 goto handle_unusual;
1574 }
1575 break;
1576 }
1577
1578 // required string mechanism = 2;
1579 case 2: {
1580 if (static_cast< ::google::protobuf::uint8>(tag) ==
1581 static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
1582 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1583 input, this->mutable_mechanism()));
1584 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1585 this->mechanism().data(), static_cast<int>(this->mechanism().length()),
1586 ::google::protobuf::internal::WireFormat::PARSE,
1587 "Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism");
1588 } else {
1589 goto handle_unusual;
1590 }
1591 break;
1592 }
1593
1594 // optional string protocol = 3;
1595 case 3: {
1596 if (static_cast< ::google::protobuf::uint8>(tag) ==
1597 static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
1598 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1599 input, this->mutable_protocol()));
1600 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1601 this->protocol().data(), static_cast<int>(this->protocol().length()),
1602 ::google::protobuf::internal::WireFormat::PARSE,
1603 "Hdfs.Internal.RpcSaslProto.SaslAuth.protocol");
1604 } else {
1605 goto handle_unusual;
1606 }
1607 break;
1608 }
1609
1610 // optional string serverId = 4;
1611 case 4: {
1612 if (static_cast< ::google::protobuf::uint8>(tag) ==
1613 static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
1614 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1615 input, this->mutable_serverid()));
1616 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1617 this->serverid().data(), static_cast<int>(this->serverid().length()),
1618 ::google::protobuf::internal::WireFormat::PARSE,
1619 "Hdfs.Internal.RpcSaslProto.SaslAuth.serverId");
1620 } else {
1621 goto handle_unusual;
1622 }
1623 break;
1624 }
1625
1626 // optional bytes challenge = 5;
1627 case 5: {
1628 if (static_cast< ::google::protobuf::uint8>(tag) ==
1629 static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
1630 DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
1631 input, this->mutable_challenge()));
1632 } else {
1633 goto handle_unusual;
1634 }
1635 break;
1636 }
1637
1638 default: {
1639 handle_unusual:
1640 if (tag == 0) {
1641 goto success;
1642 }
1643 DO_(::google::protobuf::internal::WireFormat::SkipField(
1644 input, tag, _internal_metadata_.mutable_unknown_fields()));
1645 break;
1646 }
1647 }
1648 }
1649success:
1650 // @@protoc_insertion_point(parse_success:Hdfs.Internal.RpcSaslProto.SaslAuth)
1651 return true;
1652failure:
1653 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.RpcSaslProto.SaslAuth)
1654 return false;
1655#undef DO_
1656}
1657
1658void RpcSaslProto_SaslAuth::SerializeWithCachedSizes(
1659 ::google::protobuf::io::CodedOutputStream* output) const {
1660 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1661 ::google::protobuf::uint32 cached_has_bits = 0;
1662 (void) cached_has_bits;
1663
1664 cached_has_bits = _has_bits_[0];
1665 // required string method = 1;
1666 if (cached_has_bits & 0x00000001u) {
1667 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1668 this->method().data(), static_cast<int>(this->method().length()),
1669 ::google::protobuf::internal::WireFormat::SERIALIZE,
1670 "Hdfs.Internal.RpcSaslProto.SaslAuth.method");
1671 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1672 1, this->method(), output);
1673 }
1674
1675 // required string mechanism = 2;
1676 if (cached_has_bits & 0x00000002u) {
1677 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1678 this->mechanism().data(), static_cast<int>(this->mechanism().length()),
1679 ::google::protobuf::internal::WireFormat::SERIALIZE,
1680 "Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism");
1681 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1682 2, this->mechanism(), output);
1683 }
1684
1685 // optional string protocol = 3;
1686 if (cached_has_bits & 0x00000004u) {
1687 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1688 this->protocol().data(), static_cast<int>(this->protocol().length()),
1689 ::google::protobuf::internal::WireFormat::SERIALIZE,
1690 "Hdfs.Internal.RpcSaslProto.SaslAuth.protocol");
1691 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1692 3, this->protocol(), output);
1693 }
1694
1695 // optional string serverId = 4;
1696 if (cached_has_bits & 0x00000008u) {
1697 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1698 this->serverid().data(), static_cast<int>(this->serverid().length()),
1699 ::google::protobuf::internal::WireFormat::SERIALIZE,
1700 "Hdfs.Internal.RpcSaslProto.SaslAuth.serverId");
1701 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1702 4, this->serverid(), output);
1703 }
1704
1705 // optional bytes challenge = 5;
1706 if (cached_has_bits & 0x00000010u) {
1707 ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
1708 5, this->challenge(), output);
1709 }
1710
1711 if (_internal_metadata_.have_unknown_fields()) {
1712 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1713 _internal_metadata_.unknown_fields(), output);
1714 }
1715 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.RpcSaslProto.SaslAuth)
1716}
1717
1718::google::protobuf::uint8* RpcSaslProto_SaslAuth::InternalSerializeWithCachedSizesToArray(
1719 bool deterministic, ::google::protobuf::uint8* target) const {
1720 (void)deterministic; // Unused
1721 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1722 ::google::protobuf::uint32 cached_has_bits = 0;
1723 (void) cached_has_bits;
1724
1725 cached_has_bits = _has_bits_[0];
1726 // required string method = 1;
1727 if (cached_has_bits & 0x00000001u) {
1728 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1729 this->method().data(), static_cast<int>(this->method().length()),
1730 ::google::protobuf::internal::WireFormat::SERIALIZE,
1731 "Hdfs.Internal.RpcSaslProto.SaslAuth.method");
1732 target =
1733 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1734 1, this->method(), target);
1735 }
1736
1737 // required string mechanism = 2;
1738 if (cached_has_bits & 0x00000002u) {
1739 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1740 this->mechanism().data(), static_cast<int>(this->mechanism().length()),
1741 ::google::protobuf::internal::WireFormat::SERIALIZE,
1742 "Hdfs.Internal.RpcSaslProto.SaslAuth.mechanism");
1743 target =
1744 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1745 2, this->mechanism(), target);
1746 }
1747
1748 // optional string protocol = 3;
1749 if (cached_has_bits & 0x00000004u) {
1750 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1751 this->protocol().data(), static_cast<int>(this->protocol().length()),
1752 ::google::protobuf::internal::WireFormat::SERIALIZE,
1753 "Hdfs.Internal.RpcSaslProto.SaslAuth.protocol");
1754 target =
1755 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1756 3, this->protocol(), target);
1757 }
1758
1759 // optional string serverId = 4;
1760 if (cached_has_bits & 0x00000008u) {
1761 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
1762 this->serverid().data(), static_cast<int>(this->serverid().length()),
1763 ::google::protobuf::internal::WireFormat::SERIALIZE,
1764 "Hdfs.Internal.RpcSaslProto.SaslAuth.serverId");
1765 target =
1766 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1767 4, this->serverid(), target);
1768 }
1769
1770 // optional bytes challenge = 5;
1771 if (cached_has_bits & 0x00000010u) {
1772 target =
1773 ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
1774 5, this->challenge(), target);
1775 }
1776
1777 if (_internal_metadata_.have_unknown_fields()) {
1778 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1779 _internal_metadata_.unknown_fields(), target);
1780 }
1781 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.RpcSaslProto.SaslAuth)
1782 return target;
1783}
1784
1785size_t RpcSaslProto_SaslAuth::RequiredFieldsByteSizeFallback() const {
1786// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1787 size_t total_size = 0;
1788
1789 if (has_method()) {
1790 // required string method = 1;
1791 total_size += 1 +
1792 ::google::protobuf::internal::WireFormatLite::StringSize(
1793 this->method());
1794 }
1795
1796 if (has_mechanism()) {
1797 // required string mechanism = 2;
1798 total_size += 1 +
1799 ::google::protobuf::internal::WireFormatLite::StringSize(
1800 this->mechanism());
1801 }
1802
1803 return total_size;
1804}
1805size_t RpcSaslProto_SaslAuth::ByteSizeLong() const {
1806// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1807 size_t total_size = 0;
1808
1809 if (_internal_metadata_.have_unknown_fields()) {
1810 total_size +=
1811 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1812 _internal_metadata_.unknown_fields());
1813 }
1814 if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present.
1815 // required string method = 1;
1816 total_size += 1 +
1817 ::google::protobuf::internal::WireFormatLite::StringSize(
1818 this->method());
1819
1820 // required string mechanism = 2;
1821 total_size += 1 +
1822 ::google::protobuf::internal::WireFormatLite::StringSize(
1823 this->mechanism());
1824
1825 } else {
1826 total_size += RequiredFieldsByteSizeFallback();
1827 }
1828 if (_has_bits_[0 / 32] & 28u) {
1829 // optional string protocol = 3;
1830 if (has_protocol()) {
1831 total_size += 1 +
1832 ::google::protobuf::internal::WireFormatLite::StringSize(
1833 this->protocol());
1834 }
1835
1836 // optional string serverId = 4;
1837 if (has_serverid()) {
1838 total_size += 1 +
1839 ::google::protobuf::internal::WireFormatLite::StringSize(
1840 this->serverid());
1841 }
1842
1843 // optional bytes challenge = 5;
1844 if (has_challenge()) {
1845 total_size += 1 +
1846 ::google::protobuf::internal::WireFormatLite::BytesSize(
1847 this->challenge());
1848 }
1849
1850 }
1851 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
1852 SetCachedSize(cached_size);
1853 return total_size;
1854}
1855
1856void RpcSaslProto_SaslAuth::MergeFrom(const ::google::protobuf::Message& from) {
1857// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1858 GOOGLE_DCHECK_NE(&from, this);
1859 const RpcSaslProto_SaslAuth* source =
1860 ::google::protobuf::internal::DynamicCastToGenerated<const RpcSaslProto_SaslAuth>(
1861 &from);
1862 if (source == NULL) {
1863 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.RpcSaslProto.SaslAuth)
1864 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1865 } else {
1866 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.RpcSaslProto.SaslAuth)
1867 MergeFrom(*source);
1868 }
1869}
1870
1871void RpcSaslProto_SaslAuth::MergeFrom(const RpcSaslProto_SaslAuth& from) {
1872// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1873 GOOGLE_DCHECK_NE(&from, this);
1874 _internal_metadata_.MergeFrom(from._internal_metadata_);
1875 ::google::protobuf::uint32 cached_has_bits = 0;
1876 (void) cached_has_bits;
1877
1878 cached_has_bits = from._has_bits_[0];
1879 if (cached_has_bits & 31u) {
1880 if (cached_has_bits & 0x00000001u) {
1881 set_has_method();
1882 method_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.method_);
1883 }
1884 if (cached_has_bits & 0x00000002u) {
1885 set_has_mechanism();
1886 mechanism_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mechanism_);
1887 }
1888 if (cached_has_bits & 0x00000004u) {
1889 set_has_protocol();
1890 protocol_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.protocol_);
1891 }
1892 if (cached_has_bits & 0x00000008u) {
1893 set_has_serverid();
1894 serverid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.serverid_);
1895 }
1896 if (cached_has_bits & 0x00000010u) {
1897 set_has_challenge();
1898 challenge_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.challenge_);
1899 }
1900 }
1901}
1902
1903void RpcSaslProto_SaslAuth::CopyFrom(const ::google::protobuf::Message& from) {
1904// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1905 if (&from == this) return;
1906 Clear();
1907 MergeFrom(from);
1908}
1909
1910void RpcSaslProto_SaslAuth::CopyFrom(const RpcSaslProto_SaslAuth& from) {
1911// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.RpcSaslProto.SaslAuth)
1912 if (&from == this) return;
1913 Clear();
1914 MergeFrom(from);
1915}
1916
1917bool RpcSaslProto_SaslAuth::IsInitialized() const {
1918 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
1919 return true;
1920}
1921
1922void RpcSaslProto_SaslAuth::Swap(RpcSaslProto_SaslAuth* other) {
1923 if (other == this) return;
1924 InternalSwap(other);
1925}
1926void RpcSaslProto_SaslAuth::InternalSwap(RpcSaslProto_SaslAuth* other) {
1927 using std::swap;
1928 method_.Swap(&other->method_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1929 GetArenaNoVirtual());
1930 mechanism_.Swap(&other->mechanism_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1931 GetArenaNoVirtual());
1932 protocol_.Swap(&other->protocol_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1933 GetArenaNoVirtual());
1934 serverid_.Swap(&other->serverid_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1935 GetArenaNoVirtual());
1936 challenge_.Swap(&other->challenge_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1937 GetArenaNoVirtual());
1938 swap(_has_bits_[0], other->_has_bits_[0]);
1939 _internal_metadata_.Swap(&other->_internal_metadata_);
1940}
1941
1942::google::protobuf::Metadata RpcSaslProto_SaslAuth::GetMetadata() const {
1943 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
1944 return ::protobuf_RpcHeader_2eproto::file_level_metadata[kIndexInFileMessages];
1945}
1946
1947
1948// ===================================================================
1949
1950void RpcSaslProto::InitAsDefaultInstance() {
1951}
1952#if !defined(_MSC_VER) || _MSC_VER >= 1900
1953const int RpcSaslProto::kVersionFieldNumber;
1954const int RpcSaslProto::kStateFieldNumber;
1955const int RpcSaslProto::kTokenFieldNumber;
1956const int RpcSaslProto::kAuthsFieldNumber;
1957#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
1958
1959RpcSaslProto::RpcSaslProto()
1960 : ::google::protobuf::Message(), _internal_metadata_(NULL) {
1961 ::google::protobuf::internal::InitSCC(
1962 &protobuf_RpcHeader_2eproto::scc_info_RpcSaslProto.base);
1963 SharedCtor();
1964 // @@protoc_insertion_point(constructor:Hdfs.Internal.RpcSaslProto)
1965}
1966RpcSaslProto::RpcSaslProto(const RpcSaslProto& from)
1967 : ::google::protobuf::Message(),
1968 _internal_metadata_(NULL),
1969 _has_bits_(from._has_bits_),
1970 auths_(from.auths_) {
1971 _internal_metadata_.MergeFrom(from._internal_metadata_);
1972 token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1973 if (from.has_token()) {
1974 token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.token_);
1975 }
1976 ::memcpy(&version_, &from.version_,
1977 static_cast<size_t>(reinterpret_cast<char*>(&state_) -
1978 reinterpret_cast<char*>(&version_)) + sizeof(state_));
1979 // @@protoc_insertion_point(copy_constructor:Hdfs.Internal.RpcSaslProto)
1980}
1981
1982void RpcSaslProto::SharedCtor() {
1983 token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1984 ::memset(&version_, 0, static_cast<size_t>(
1985 reinterpret_cast<char*>(&state_) -
1986 reinterpret_cast<char*>(&version_)) + sizeof(state_));
1987}
1988
1989RpcSaslProto::~RpcSaslProto() {
1990 // @@protoc_insertion_point(destructor:Hdfs.Internal.RpcSaslProto)
1991 SharedDtor();
1992}
1993
1994void RpcSaslProto::SharedDtor() {
1995 token_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1996}
1997
1998void RpcSaslProto::SetCachedSize(int size) const {
1999 _cached_size_.Set(size);
2000}
2001const ::google::protobuf::Descriptor* RpcSaslProto::descriptor() {
2002 ::protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
2003 return ::protobuf_RpcHeader_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
2004}
2005
2006const RpcSaslProto& RpcSaslProto::default_instance() {
2007 ::google::protobuf::internal::InitSCC(&protobuf_RpcHeader_2eproto::scc_info_RpcSaslProto.base);
2008 return *internal_default_instance();
2009}
2010
2011
2012void RpcSaslProto::Clear() {
2013// @@protoc_insertion_point(message_clear_start:Hdfs.Internal.RpcSaslProto)
2014 ::google::protobuf::uint32 cached_has_bits = 0;
2015 // Prevent compiler warnings about cached_has_bits being unused
2016 (void) cached_has_bits;
2017
2018 auths_.Clear();
2019 cached_has_bits = _has_bits_[0];
2020 if (cached_has_bits & 0x00000001u) {
2021 token_.ClearNonDefaultToEmptyNoArena();
2022 }
2023 if (cached_has_bits & 6u) {
2024 ::memset(&version_, 0, static_cast<size_t>(
2025 reinterpret_cast<char*>(&state_) -
2026 reinterpret_cast<char*>(&version_)) + sizeof(state_));
2027 }
2028 _has_bits_.Clear();
2029 _internal_metadata_.Clear();
2030}
2031
2032bool RpcSaslProto::MergePartialFromCodedStream(
2033 ::google::protobuf::io::CodedInputStream* input) {
2034#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
2035 ::google::protobuf::uint32 tag;
2036 // @@protoc_insertion_point(parse_start:Hdfs.Internal.RpcSaslProto)
2037 for (;;) {
2038 ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
2039 tag = p.first;
2040 if (!p.second) goto handle_unusual;
2041 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2042 // optional uint32 version = 1;
2043 case 1: {
2044 if (static_cast< ::google::protobuf::uint8>(tag) ==
2045 static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
2046 set_has_version();
2047 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2048 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
2049 input, &version_)));
2050 } else {
2051 goto handle_unusual;
2052 }
2053 break;
2054 }
2055
2056 // required .Hdfs.Internal.RpcSaslProto.SaslState state = 2;
2057 case 2: {
2058 if (static_cast< ::google::protobuf::uint8>(tag) ==
2059 static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
2060 int value;
2061 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2062 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
2063 input, &value)));
2064 if (::Hdfs::Internal::RpcSaslProto_SaslState_IsValid(value)) {
2065 set_state(static_cast< ::Hdfs::Internal::RpcSaslProto_SaslState >(value));
2066 } else {
2067 mutable_unknown_fields()->AddVarint(
2068 2, static_cast< ::google::protobuf::uint64>(value));
2069 }
2070 } else {
2071 goto handle_unusual;
2072 }
2073 break;
2074 }
2075
2076 // optional bytes token = 3;
2077 case 3: {
2078 if (static_cast< ::google::protobuf::uint8>(tag) ==
2079 static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
2080 DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
2081 input, this->mutable_token()));
2082 } else {
2083 goto handle_unusual;
2084 }
2085 break;
2086 }
2087
2088 // repeated .Hdfs.Internal.RpcSaslProto.SaslAuth auths = 4;
2089 case 4: {
2090 if (static_cast< ::google::protobuf::uint8>(tag) ==
2091 static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
2092 DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
2093 input, add_auths()));
2094 } else {
2095 goto handle_unusual;
2096 }
2097 break;
2098 }
2099
2100 default: {
2101 handle_unusual:
2102 if (tag == 0) {
2103 goto success;
2104 }
2105 DO_(::google::protobuf::internal::WireFormat::SkipField(
2106 input, tag, _internal_metadata_.mutable_unknown_fields()));
2107 break;
2108 }
2109 }
2110 }
2111success:
2112 // @@protoc_insertion_point(parse_success:Hdfs.Internal.RpcSaslProto)
2113 return true;
2114failure:
2115 // @@protoc_insertion_point(parse_failure:Hdfs.Internal.RpcSaslProto)
2116 return false;
2117#undef DO_
2118}
2119
2120void RpcSaslProto::SerializeWithCachedSizes(
2121 ::google::protobuf::io::CodedOutputStream* output) const {
2122 // @@protoc_insertion_point(serialize_start:Hdfs.Internal.RpcSaslProto)
2123 ::google::protobuf::uint32 cached_has_bits = 0;
2124 (void) cached_has_bits;
2125
2126 cached_has_bits = _has_bits_[0];
2127 // optional uint32 version = 1;
2128 if (cached_has_bits & 0x00000002u) {
2129 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->version(), output);
2130 }
2131
2132 // required .Hdfs.Internal.RpcSaslProto.SaslState state = 2;
2133 if (cached_has_bits & 0x00000004u) {
2134 ::google::protobuf::internal::WireFormatLite::WriteEnum(
2135 2, this->state(), output);
2136 }
2137
2138 // optional bytes token = 3;
2139 if (cached_has_bits & 0x00000001u) {
2140 ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
2141 3, this->token(), output);
2142 }
2143
2144 // repeated .Hdfs.Internal.RpcSaslProto.SaslAuth auths = 4;
2145 for (unsigned int i = 0,
2146 n = static_cast<unsigned int>(this->auths_size()); i < n; i++) {
2147 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2148 4,
2149 this->auths(static_cast<int>(i)),
2150 output);
2151 }
2152
2153 if (_internal_metadata_.have_unknown_fields()) {
2154 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2155 _internal_metadata_.unknown_fields(), output);
2156 }
2157 // @@protoc_insertion_point(serialize_end:Hdfs.Internal.RpcSaslProto)
2158}
2159
2160::google::protobuf::uint8* RpcSaslProto::InternalSerializeWithCachedSizesToArray(
2161 bool deterministic, ::google::protobuf::uint8* target) const {
2162 (void)deterministic; // Unused
2163 // @@protoc_insertion_point(serialize_to_array_start:Hdfs.Internal.RpcSaslProto)
2164 ::google::protobuf::uint32 cached_has_bits = 0;
2165 (void) cached_has_bits;
2166
2167 cached_has_bits = _has_bits_[0];
2168 // optional uint32 version = 1;
2169 if (cached_has_bits & 0x00000002u) {
2170 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->version(), target);
2171 }
2172
2173 // required .Hdfs.Internal.RpcSaslProto.SaslState state = 2;
2174 if (cached_has_bits & 0x00000004u) {
2175 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
2176 2, this->state(), target);
2177 }
2178
2179 // optional bytes token = 3;
2180 if (cached_has_bits & 0x00000001u) {
2181 target =
2182 ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
2183 3, this->token(), target);
2184 }
2185
2186 // repeated .Hdfs.Internal.RpcSaslProto.SaslAuth auths = 4;
2187 for (unsigned int i = 0,
2188 n = static_cast<unsigned int>(this->auths_size()); i < n; i++) {
2189 target = ::google::protobuf::internal::WireFormatLite::
2190 InternalWriteMessageToArray(
2191 4, this->auths(static_cast<int>(i)), deterministic, target);
2192 }
2193
2194 if (_internal_metadata_.have_unknown_fields()) {
2195 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2196 _internal_metadata_.unknown_fields(), target);
2197 }
2198 // @@protoc_insertion_point(serialize_to_array_end:Hdfs.Internal.RpcSaslProto)
2199 return target;
2200}
2201
2202size_t RpcSaslProto::ByteSizeLong() const {
2203// @@protoc_insertion_point(message_byte_size_start:Hdfs.Internal.RpcSaslProto)
2204 size_t total_size = 0;
2205
2206 if (_internal_metadata_.have_unknown_fields()) {
2207 total_size +=
2208 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2209 _internal_metadata_.unknown_fields());
2210 }
2211 // required .Hdfs.Internal.RpcSaslProto.SaslState state = 2;
2212 if (has_state()) {
2213 total_size += 1 +
2214 ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
2215 }
2216 // repeated .Hdfs.Internal.RpcSaslProto.SaslAuth auths = 4;
2217 {
2218 unsigned int count = static_cast<unsigned int>(this->auths_size());
2219 total_size += 1UL * count;
2220 for (unsigned int i = 0; i < count; i++) {
2221 total_size +=
2222 ::google::protobuf::internal::WireFormatLite::MessageSize(
2223 this->auths(static_cast<int>(i)));
2224 }
2225 }
2226
2227 if (_has_bits_[0 / 32] & 3u) {
2228 // optional bytes token = 3;
2229 if (has_token()) {
2230 total_size += 1 +
2231 ::google::protobuf::internal::WireFormatLite::BytesSize(
2232 this->token());
2233 }
2234
2235 // optional uint32 version = 1;
2236 if (has_version()) {
2237 total_size += 1 +
2238 ::google::protobuf::internal::WireFormatLite::UInt32Size(
2239 this->version());
2240 }
2241
2242 }
2243 int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
2244 SetCachedSize(cached_size);
2245 return total_size;
2246}
2247
2248void RpcSaslProto::MergeFrom(const ::google::protobuf::Message& from) {
2249// @@protoc_insertion_point(generalized_merge_from_start:Hdfs.Internal.RpcSaslProto)
2250 GOOGLE_DCHECK_NE(&from, this);
2251 const RpcSaslProto* source =
2252 ::google::protobuf::internal::DynamicCastToGenerated<const RpcSaslProto>(
2253 &from);
2254 if (source == NULL) {
2255 // @@protoc_insertion_point(generalized_merge_from_cast_fail:Hdfs.Internal.RpcSaslProto)
2256 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2257 } else {
2258 // @@protoc_insertion_point(generalized_merge_from_cast_success:Hdfs.Internal.RpcSaslProto)
2259 MergeFrom(*source);
2260 }
2261}
2262
2263void RpcSaslProto::MergeFrom(const RpcSaslProto& from) {
2264// @@protoc_insertion_point(class_specific_merge_from_start:Hdfs.Internal.RpcSaslProto)
2265 GOOGLE_DCHECK_NE(&from, this);
2266 _internal_metadata_.MergeFrom(from._internal_metadata_);
2267 ::google::protobuf::uint32 cached_has_bits = 0;
2268 (void) cached_has_bits;
2269
2270 auths_.MergeFrom(from.auths_);
2271 cached_has_bits = from._has_bits_[0];
2272 if (cached_has_bits & 7u) {
2273 if (cached_has_bits & 0x00000001u) {
2274 set_has_token();
2275 token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.token_);
2276 }
2277 if (cached_has_bits & 0x00000002u) {
2278 version_ = from.version_;
2279 }
2280 if (cached_has_bits & 0x00000004u) {
2281 state_ = from.state_;
2282 }
2283 _has_bits_[0] |= cached_has_bits;
2284 }
2285}
2286
2287void RpcSaslProto::CopyFrom(const ::google::protobuf::Message& from) {
2288// @@protoc_insertion_point(generalized_copy_from_start:Hdfs.Internal.RpcSaslProto)
2289 if (&from == this) return;
2290 Clear();
2291 MergeFrom(from);
2292}
2293
2294void RpcSaslProto::CopyFrom(const RpcSaslProto& from) {
2295// @@protoc_insertion_point(class_specific_copy_from_start:Hdfs.Internal.RpcSaslProto)
2296 if (&from == this) return;
2297 Clear();
2298 MergeFrom(from);
2299}
2300
2301bool RpcSaslProto::IsInitialized() const {
2302 if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;
2303 if (!::google::protobuf::internal::AllAreInitialized(this->auths())) return false;
2304 return true;
2305}
2306
2307void RpcSaslProto::Swap(RpcSaslProto* other) {
2308 if (other == this) return;
2309 InternalSwap(other);
2310}
2311void RpcSaslProto::InternalSwap(RpcSaslProto* other) {
2312 using std::swap;
2313 CastToBase(&auths_)->InternalSwap(CastToBase(&other->auths_));
2314 token_.Swap(&other->token_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2315 GetArenaNoVirtual());
2316 swap(version_, other->version_);
2317 swap(state_, other->state_);
2318 swap(_has_bits_[0], other->_has_bits_[0]);
2319 _internal_metadata_.Swap(&other->_internal_metadata_);
2320}
2321
2322::google::protobuf::Metadata RpcSaslProto::GetMetadata() const {
2323 protobuf_RpcHeader_2eproto::protobuf_AssignDescriptorsOnce();
2324 return ::protobuf_RpcHeader_2eproto::file_level_metadata[kIndexInFileMessages];
2325}
2326
2327
2328// @@protoc_insertion_point(namespace_scope)
2329} // namespace Internal
2330} // namespace Hdfs
2331namespace google {
2332namespace protobuf {
2333template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::RpcRequestHeaderProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::RpcRequestHeaderProto >(Arena* arena) {
2334 return Arena::CreateInternal< ::Hdfs::Internal::RpcRequestHeaderProto >(arena);
2335}
2336template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::RpcResponseHeaderProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::RpcResponseHeaderProto >(Arena* arena) {
2337 return Arena::CreateInternal< ::Hdfs::Internal::RpcResponseHeaderProto >(arena);
2338}
2339template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::RpcSaslProto_SaslAuth* Arena::CreateMaybeMessage< ::Hdfs::Internal::RpcSaslProto_SaslAuth >(Arena* arena) {
2340 return Arena::CreateInternal< ::Hdfs::Internal::RpcSaslProto_SaslAuth >(arena);
2341}
2342template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Hdfs::Internal::RpcSaslProto* Arena::CreateMaybeMessage< ::Hdfs::Internal::RpcSaslProto >(Arena* arena) {
2343 return Arena::CreateInternal< ::Hdfs::Internal::RpcSaslProto >(arena);
2344}
2345} // namespace protobuf
2346} // namespace google
2347
2348// @@protoc_insertion_point(global_scope)
2349