1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: chatcleaner.proto
3 
4 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
5 #include "chatcleaner.pb.h"
6 
7 #include <algorithm>
8 
9 #include <google/protobuf/stubs/common.h>
10 #include <google/protobuf/stubs/once.h>
11 #include <google/protobuf/io/coded_stream.h>
12 #include <google/protobuf/wire_format_lite_inl.h>
13 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
14 // @@protoc_insertion_point(includes)
15 
protobuf_ShutdownFile_chatcleaner_2eproto()16 void protobuf_ShutdownFile_chatcleaner_2eproto() {
17   delete CleanerInitMessage::default_instance_;
18   delete CleanerInitAckMessage::default_instance_;
19   delete CleanerChatRequestMessage::default_instance_;
20   delete CleanerChatReplyMessage::default_instance_;
21   delete ChatCleanerMessage::default_instance_;
22 }
23 
24 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
protobuf_AddDesc_chatcleaner_2eproto_impl()25 void protobuf_AddDesc_chatcleaner_2eproto_impl() {
26   GOOGLE_PROTOBUF_VERIFY_VERSION;
27 
28 #else
29 void protobuf_AddDesc_chatcleaner_2eproto() {
30   static bool already_here = false;
31   if (already_here) return;
32   already_here = true;
33   GOOGLE_PROTOBUF_VERIFY_VERSION;
34 
35 #endif
36   CleanerInitMessage::default_instance_ = new CleanerInitMessage();
37   CleanerInitAckMessage::default_instance_ = new CleanerInitAckMessage();
38   CleanerChatRequestMessage::default_instance_ = new CleanerChatRequestMessage();
39   CleanerChatReplyMessage::default_instance_ = new CleanerChatReplyMessage();
40   ChatCleanerMessage::default_instance_ = new ChatCleanerMessage();
41   CleanerInitMessage::default_instance_->InitAsDefaultInstance();
42   CleanerInitAckMessage::default_instance_->InitAsDefaultInstance();
43   CleanerChatRequestMessage::default_instance_->InitAsDefaultInstance();
44   CleanerChatReplyMessage::default_instance_->InitAsDefaultInstance();
45   ChatCleanerMessage::default_instance_->InitAsDefaultInstance();
46   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_chatcleaner_2eproto);
47 }
48 
49 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
50 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_chatcleaner_2eproto_once_);
51 void protobuf_AddDesc_chatcleaner_2eproto() {
52   ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_chatcleaner_2eproto_once_,
53                  &protobuf_AddDesc_chatcleaner_2eproto_impl);
54 }
55 #else
56 // Force AddDescriptors() to be called at static initialization time.
57 struct StaticDescriptorInitializer_chatcleaner_2eproto {
58   StaticDescriptorInitializer_chatcleaner_2eproto() {
59     protobuf_AddDesc_chatcleaner_2eproto();
60   }
61 } static_descriptor_initializer_chatcleaner_2eproto_;
62 #endif
63 bool CleanerChatType_IsValid(int value) {
64   switch(value) {
65     case 0:
66     case 1:
67       return true;
68     default:
69       return false;
70   }
71 }
72 
73 
74 // ===================================================================
75 
76 #ifndef _MSC_VER
77 const int CleanerInitMessage::kRequestedVersionFieldNumber;
78 const int CleanerInitMessage::kClientSecretFieldNumber;
79 #endif  // !_MSC_VER
80 
81 CleanerInitMessage::CleanerInitMessage()
82   : ::google::protobuf::MessageLite() {
83   SharedCtor();
84   // @@protoc_insertion_point(constructor:CleanerInitMessage)
85 }
86 
87 void CleanerInitMessage::InitAsDefaultInstance() {
88 }
89 
90 CleanerInitMessage::CleanerInitMessage(const CleanerInitMessage& from)
91   : ::google::protobuf::MessageLite() {
92   SharedCtor();
93   MergeFrom(from);
94   // @@protoc_insertion_point(copy_constructor:CleanerInitMessage)
95 }
96 
97 void CleanerInitMessage::SharedCtor() {
98   ::google::protobuf::internal::GetEmptyString();
99   _cached_size_ = 0;
100   requestedversion_ = 0u;
101   clientsecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
102   ::memset(_has_bits_, 0, sizeof(_has_bits_));
103 }
104 
105 CleanerInitMessage::~CleanerInitMessage() {
106   // @@protoc_insertion_point(destructor:CleanerInitMessage)
107   SharedDtor();
108 }
109 
110 void CleanerInitMessage::SharedDtor() {
111   if (clientsecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
112     delete clientsecret_;
113   }
114   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
115   if (this != &default_instance()) {
116   #else
117   if (this != default_instance_) {
118   #endif
119   }
120 }
121 
122 void CleanerInitMessage::SetCachedSize(int size) const {
123   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
124   _cached_size_ = size;
125   GOOGLE_SAFE_CONCURRENT_WRITES_END();
126 }
127 const CleanerInitMessage& CleanerInitMessage::default_instance() {
128 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
129   protobuf_AddDesc_chatcleaner_2eproto();
130 #else
131   if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
132 #endif
133   return *default_instance_;
134 }
135 
136 CleanerInitMessage* CleanerInitMessage::default_instance_ = NULL;
137 
138 CleanerInitMessage* CleanerInitMessage::New() const {
139   return new CleanerInitMessage;
140 }
141 
142 void CleanerInitMessage::Clear() {
143   if (_has_bits_[0 / 32] & 3) {
144     requestedversion_ = 0u;
145     if (has_clientsecret()) {
146       if (clientsecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
147         clientsecret_->clear();
148       }
149     }
150   }
151   ::memset(_has_bits_, 0, sizeof(_has_bits_));
152   mutable_unknown_fields()->clear();
153 }
154 
155 bool CleanerInitMessage::MergePartialFromCodedStream(
156     ::google::protobuf::io::CodedInputStream* input) {
157 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
158   ::google::protobuf::uint32 tag;
159   ::google::protobuf::io::StringOutputStream unknown_fields_string(
160       mutable_unknown_fields());
161   ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
162       &unknown_fields_string);
163   // @@protoc_insertion_point(parse_start:CleanerInitMessage)
164   for (;;) {
165     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
166     tag = p.first;
167     if (!p.second) goto handle_unusual;
168     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
169       // required uint32 requestedVersion = 1;
170       case 1: {
171         if (tag == 8) {
172           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
173                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
174                  input, &requestedversion_)));
175           set_has_requestedversion();
176         } else {
177           goto handle_unusual;
178         }
179         if (input->ExpectTag(18)) goto parse_clientSecret;
180         break;
181       }
182 
183       // required string clientSecret = 2;
184       case 2: {
185         if (tag == 18) {
186          parse_clientSecret:
187           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
188                 input, this->mutable_clientsecret()));
189         } else {
190           goto handle_unusual;
191         }
192         if (input->ExpectAtEnd()) goto success;
193         break;
194       }
195 
196       default: {
197       handle_unusual:
198         if (tag == 0 ||
199             ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
200             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
201           goto success;
202         }
203         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
204             input, tag, &unknown_fields_stream));
205         break;
206       }
207     }
208   }
209 success:
210   // @@protoc_insertion_point(parse_success:CleanerInitMessage)
211   return true;
212 failure:
213   // @@protoc_insertion_point(parse_failure:CleanerInitMessage)
214   return false;
215 #undef DO_
216 }
217 
218 void CleanerInitMessage::SerializeWithCachedSizes(
219     ::google::protobuf::io::CodedOutputStream* output) const {
220   // @@protoc_insertion_point(serialize_start:CleanerInitMessage)
221   // required uint32 requestedVersion = 1;
222   if (has_requestedversion()) {
223     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestedversion(), output);
224   }
225 
226   // required string clientSecret = 2;
227   if (has_clientsecret()) {
228     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
229       2, this->clientsecret(), output);
230   }
231 
232   output->WriteRaw(unknown_fields().data(),
233                    unknown_fields().size());
234   // @@protoc_insertion_point(serialize_end:CleanerInitMessage)
235 }
236 
237 int CleanerInitMessage::ByteSize() const {
238   int total_size = 0;
239 
240   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
241     // required uint32 requestedVersion = 1;
242     if (has_requestedversion()) {
243       total_size += 1 +
244         ::google::protobuf::internal::WireFormatLite::UInt32Size(
245           this->requestedversion());
246     }
247 
248     // required string clientSecret = 2;
249     if (has_clientsecret()) {
250       total_size += 1 +
251         ::google::protobuf::internal::WireFormatLite::StringSize(
252           this->clientsecret());
253     }
254 
255   }
256   total_size += unknown_fields().size();
257 
258   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
259   _cached_size_ = total_size;
260   GOOGLE_SAFE_CONCURRENT_WRITES_END();
261   return total_size;
262 }
263 
264 void CleanerInitMessage::CheckTypeAndMergeFrom(
265     const ::google::protobuf::MessageLite& from) {
266   MergeFrom(*::google::protobuf::down_cast<const CleanerInitMessage*>(&from));
267 }
268 
269 void CleanerInitMessage::MergeFrom(const CleanerInitMessage& from) {
270   GOOGLE_CHECK_NE(&from, this);
271   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
272     if (from.has_requestedversion()) {
273       set_requestedversion(from.requestedversion());
274     }
275     if (from.has_clientsecret()) {
276       set_clientsecret(from.clientsecret());
277     }
278   }
279   mutable_unknown_fields()->append(from.unknown_fields());
280 }
281 
282 void CleanerInitMessage::CopyFrom(const CleanerInitMessage& from) {
283   if (&from == this) return;
284   Clear();
285   MergeFrom(from);
286 }
287 
288 bool CleanerInitMessage::IsInitialized() const {
289   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
290 
291   return true;
292 }
293 
294 void CleanerInitMessage::Swap(CleanerInitMessage* other) {
295   if (other != this) {
296     std::swap(requestedversion_, other->requestedversion_);
297     std::swap(clientsecret_, other->clientsecret_);
298     std::swap(_has_bits_[0], other->_has_bits_[0]);
299     _unknown_fields_.swap(other->_unknown_fields_);
300     std::swap(_cached_size_, other->_cached_size_);
301   }
302 }
303 
304 ::std::string CleanerInitMessage::GetTypeName() const {
305   return "CleanerInitMessage";
306 }
307 
308 
309 // ===================================================================
310 
311 #ifndef _MSC_VER
312 const int CleanerInitAckMessage::kServerVersionFieldNumber;
313 const int CleanerInitAckMessage::kServerSecretFieldNumber;
314 #endif  // !_MSC_VER
315 
316 CleanerInitAckMessage::CleanerInitAckMessage()
317   : ::google::protobuf::MessageLite() {
318   SharedCtor();
319   // @@protoc_insertion_point(constructor:CleanerInitAckMessage)
320 }
321 
322 void CleanerInitAckMessage::InitAsDefaultInstance() {
323 }
324 
325 CleanerInitAckMessage::CleanerInitAckMessage(const CleanerInitAckMessage& from)
326   : ::google::protobuf::MessageLite() {
327   SharedCtor();
328   MergeFrom(from);
329   // @@protoc_insertion_point(copy_constructor:CleanerInitAckMessage)
330 }
331 
332 void CleanerInitAckMessage::SharedCtor() {
333   ::google::protobuf::internal::GetEmptyString();
334   _cached_size_ = 0;
335   serverversion_ = 0u;
336   serversecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
337   ::memset(_has_bits_, 0, sizeof(_has_bits_));
338 }
339 
340 CleanerInitAckMessage::~CleanerInitAckMessage() {
341   // @@protoc_insertion_point(destructor:CleanerInitAckMessage)
342   SharedDtor();
343 }
344 
345 void CleanerInitAckMessage::SharedDtor() {
346   if (serversecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
347     delete serversecret_;
348   }
349   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
350   if (this != &default_instance()) {
351   #else
352   if (this != default_instance_) {
353   #endif
354   }
355 }
356 
357 void CleanerInitAckMessage::SetCachedSize(int size) const {
358   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
359   _cached_size_ = size;
360   GOOGLE_SAFE_CONCURRENT_WRITES_END();
361 }
362 const CleanerInitAckMessage& CleanerInitAckMessage::default_instance() {
363 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
364   protobuf_AddDesc_chatcleaner_2eproto();
365 #else
366   if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
367 #endif
368   return *default_instance_;
369 }
370 
371 CleanerInitAckMessage* CleanerInitAckMessage::default_instance_ = NULL;
372 
373 CleanerInitAckMessage* CleanerInitAckMessage::New() const {
374   return new CleanerInitAckMessage;
375 }
376 
377 void CleanerInitAckMessage::Clear() {
378   if (_has_bits_[0 / 32] & 3) {
379     serverversion_ = 0u;
380     if (has_serversecret()) {
381       if (serversecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
382         serversecret_->clear();
383       }
384     }
385   }
386   ::memset(_has_bits_, 0, sizeof(_has_bits_));
387   mutable_unknown_fields()->clear();
388 }
389 
390 bool CleanerInitAckMessage::MergePartialFromCodedStream(
391     ::google::protobuf::io::CodedInputStream* input) {
392 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
393   ::google::protobuf::uint32 tag;
394   ::google::protobuf::io::StringOutputStream unknown_fields_string(
395       mutable_unknown_fields());
396   ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
397       &unknown_fields_string);
398   // @@protoc_insertion_point(parse_start:CleanerInitAckMessage)
399   for (;;) {
400     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
401     tag = p.first;
402     if (!p.second) goto handle_unusual;
403     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
404       // required uint32 serverVersion = 1;
405       case 1: {
406         if (tag == 8) {
407           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
408                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
409                  input, &serverversion_)));
410           set_has_serverversion();
411         } else {
412           goto handle_unusual;
413         }
414         if (input->ExpectTag(18)) goto parse_serverSecret;
415         break;
416       }
417 
418       // required string serverSecret = 2;
419       case 2: {
420         if (tag == 18) {
421          parse_serverSecret:
422           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
423                 input, this->mutable_serversecret()));
424         } else {
425           goto handle_unusual;
426         }
427         if (input->ExpectAtEnd()) goto success;
428         break;
429       }
430 
431       default: {
432       handle_unusual:
433         if (tag == 0 ||
434             ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
435             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
436           goto success;
437         }
438         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
439             input, tag, &unknown_fields_stream));
440         break;
441       }
442     }
443   }
444 success:
445   // @@protoc_insertion_point(parse_success:CleanerInitAckMessage)
446   return true;
447 failure:
448   // @@protoc_insertion_point(parse_failure:CleanerInitAckMessage)
449   return false;
450 #undef DO_
451 }
452 
453 void CleanerInitAckMessage::SerializeWithCachedSizes(
454     ::google::protobuf::io::CodedOutputStream* output) const {
455   // @@protoc_insertion_point(serialize_start:CleanerInitAckMessage)
456   // required uint32 serverVersion = 1;
457   if (has_serverversion()) {
458     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->serverversion(), output);
459   }
460 
461   // required string serverSecret = 2;
462   if (has_serversecret()) {
463     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
464       2, this->serversecret(), output);
465   }
466 
467   output->WriteRaw(unknown_fields().data(),
468                    unknown_fields().size());
469   // @@protoc_insertion_point(serialize_end:CleanerInitAckMessage)
470 }
471 
472 int CleanerInitAckMessage::ByteSize() const {
473   int total_size = 0;
474 
475   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
476     // required uint32 serverVersion = 1;
477     if (has_serverversion()) {
478       total_size += 1 +
479         ::google::protobuf::internal::WireFormatLite::UInt32Size(
480           this->serverversion());
481     }
482 
483     // required string serverSecret = 2;
484     if (has_serversecret()) {
485       total_size += 1 +
486         ::google::protobuf::internal::WireFormatLite::StringSize(
487           this->serversecret());
488     }
489 
490   }
491   total_size += unknown_fields().size();
492 
493   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
494   _cached_size_ = total_size;
495   GOOGLE_SAFE_CONCURRENT_WRITES_END();
496   return total_size;
497 }
498 
499 void CleanerInitAckMessage::CheckTypeAndMergeFrom(
500     const ::google::protobuf::MessageLite& from) {
501   MergeFrom(*::google::protobuf::down_cast<const CleanerInitAckMessage*>(&from));
502 }
503 
504 void CleanerInitAckMessage::MergeFrom(const CleanerInitAckMessage& from) {
505   GOOGLE_CHECK_NE(&from, this);
506   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
507     if (from.has_serverversion()) {
508       set_serverversion(from.serverversion());
509     }
510     if (from.has_serversecret()) {
511       set_serversecret(from.serversecret());
512     }
513   }
514   mutable_unknown_fields()->append(from.unknown_fields());
515 }
516 
517 void CleanerInitAckMessage::CopyFrom(const CleanerInitAckMessage& from) {
518   if (&from == this) return;
519   Clear();
520   MergeFrom(from);
521 }
522 
523 bool CleanerInitAckMessage::IsInitialized() const {
524   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
525 
526   return true;
527 }
528 
529 void CleanerInitAckMessage::Swap(CleanerInitAckMessage* other) {
530   if (other != this) {
531     std::swap(serverversion_, other->serverversion_);
532     std::swap(serversecret_, other->serversecret_);
533     std::swap(_has_bits_[0], other->_has_bits_[0]);
534     _unknown_fields_.swap(other->_unknown_fields_);
535     std::swap(_cached_size_, other->_cached_size_);
536   }
537 }
538 
539 ::std::string CleanerInitAckMessage::GetTypeName() const {
540   return "CleanerInitAckMessage";
541 }
542 
543 
544 // ===================================================================
545 
546 #ifndef _MSC_VER
547 const int CleanerChatRequestMessage::kRequestIdFieldNumber;
548 const int CleanerChatRequestMessage::kCleanerChatTypeFieldNumber;
549 const int CleanerChatRequestMessage::kGameIdFieldNumber;
550 const int CleanerChatRequestMessage::kPlayerIdFieldNumber;
551 const int CleanerChatRequestMessage::kPlayerNameFieldNumber;
552 const int CleanerChatRequestMessage::kChatMessageFieldNumber;
553 #endif  // !_MSC_VER
554 
555 CleanerChatRequestMessage::CleanerChatRequestMessage()
556   : ::google::protobuf::MessageLite() {
557   SharedCtor();
558   // @@protoc_insertion_point(constructor:CleanerChatRequestMessage)
559 }
560 
561 void CleanerChatRequestMessage::InitAsDefaultInstance() {
562 }
563 
564 CleanerChatRequestMessage::CleanerChatRequestMessage(const CleanerChatRequestMessage& from)
565   : ::google::protobuf::MessageLite() {
566   SharedCtor();
567   MergeFrom(from);
568   // @@protoc_insertion_point(copy_constructor:CleanerChatRequestMessage)
569 }
570 
571 void CleanerChatRequestMessage::SharedCtor() {
572   ::google::protobuf::internal::GetEmptyString();
573   _cached_size_ = 0;
574   requestid_ = 0u;
575   cleanerchattype_ = 0;
576   gameid_ = 0u;
577   playerid_ = 0u;
578   playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
579   chatmessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
580   ::memset(_has_bits_, 0, sizeof(_has_bits_));
581 }
582 
583 CleanerChatRequestMessage::~CleanerChatRequestMessage() {
584   // @@protoc_insertion_point(destructor:CleanerChatRequestMessage)
585   SharedDtor();
586 }
587 
588 void CleanerChatRequestMessage::SharedDtor() {
589   if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
590     delete playername_;
591   }
592   if (chatmessage_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
593     delete chatmessage_;
594   }
595   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
596   if (this != &default_instance()) {
597   #else
598   if (this != default_instance_) {
599   #endif
600   }
601 }
602 
603 void CleanerChatRequestMessage::SetCachedSize(int size) const {
604   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
605   _cached_size_ = size;
606   GOOGLE_SAFE_CONCURRENT_WRITES_END();
607 }
608 const CleanerChatRequestMessage& CleanerChatRequestMessage::default_instance() {
609 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
610   protobuf_AddDesc_chatcleaner_2eproto();
611 #else
612   if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
613 #endif
614   return *default_instance_;
615 }
616 
617 CleanerChatRequestMessage* CleanerChatRequestMessage::default_instance_ = NULL;
618 
619 CleanerChatRequestMessage* CleanerChatRequestMessage::New() const {
620   return new CleanerChatRequestMessage;
621 }
622 
623 void CleanerChatRequestMessage::Clear() {
624 #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
625   &reinterpret_cast<CleanerChatRequestMessage*>(16)->f) - \
626    reinterpret_cast<char*>(16))
627 
628 #define ZR_(first, last) do {                              \
629     size_t f = OFFSET_OF_FIELD_(first);                    \
630     size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
631     ::memset(&first, 0, n);                                \
632   } while (0)
633 
634   if (_has_bits_[0 / 32] & 63) {
635     ZR_(requestid_, playerid_);
636     if (has_playername()) {
637       if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
638         playername_->clear();
639       }
640     }
641     if (has_chatmessage()) {
642       if (chatmessage_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
643         chatmessage_->clear();
644       }
645     }
646   }
647 
648 #undef OFFSET_OF_FIELD_
649 #undef ZR_
650 
651   ::memset(_has_bits_, 0, sizeof(_has_bits_));
652   mutable_unknown_fields()->clear();
653 }
654 
655 bool CleanerChatRequestMessage::MergePartialFromCodedStream(
656     ::google::protobuf::io::CodedInputStream* input) {
657 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
658   ::google::protobuf::uint32 tag;
659   ::google::protobuf::io::StringOutputStream unknown_fields_string(
660       mutable_unknown_fields());
661   ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
662       &unknown_fields_string);
663   // @@protoc_insertion_point(parse_start:CleanerChatRequestMessage)
664   for (;;) {
665     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
666     tag = p.first;
667     if (!p.second) goto handle_unusual;
668     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
669       // required uint32 requestId = 1;
670       case 1: {
671         if (tag == 8) {
672           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
673                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
674                  input, &requestid_)));
675           set_has_requestid();
676         } else {
677           goto handle_unusual;
678         }
679         if (input->ExpectTag(16)) goto parse_cleanerChatType;
680         break;
681       }
682 
683       // required .CleanerChatType cleanerChatType = 2;
684       case 2: {
685         if (tag == 16) {
686          parse_cleanerChatType:
687           int value;
688           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
689                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
690                  input, &value)));
691           if (::CleanerChatType_IsValid(value)) {
692             set_cleanerchattype(static_cast< ::CleanerChatType >(value));
693           } else {
694             unknown_fields_stream.WriteVarint32(tag);
695             unknown_fields_stream.WriteVarint32(value);
696           }
697         } else {
698           goto handle_unusual;
699         }
700         if (input->ExpectTag(24)) goto parse_gameId;
701         break;
702       }
703 
704       // optional uint32 gameId = 3 [default = 0];
705       case 3: {
706         if (tag == 24) {
707          parse_gameId:
708           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
709                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
710                  input, &gameid_)));
711           set_has_gameid();
712         } else {
713           goto handle_unusual;
714         }
715         if (input->ExpectTag(32)) goto parse_playerId;
716         break;
717       }
718 
719       // required uint32 playerId = 4;
720       case 4: {
721         if (tag == 32) {
722          parse_playerId:
723           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
724                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
725                  input, &playerid_)));
726           set_has_playerid();
727         } else {
728           goto handle_unusual;
729         }
730         if (input->ExpectTag(42)) goto parse_playerName;
731         break;
732       }
733 
734       // required string playerName = 5;
735       case 5: {
736         if (tag == 42) {
737          parse_playerName:
738           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
739                 input, this->mutable_playername()));
740         } else {
741           goto handle_unusual;
742         }
743         if (input->ExpectTag(50)) goto parse_chatMessage;
744         break;
745       }
746 
747       // required string chatMessage = 6;
748       case 6: {
749         if (tag == 50) {
750          parse_chatMessage:
751           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
752                 input, this->mutable_chatmessage()));
753         } else {
754           goto handle_unusual;
755         }
756         if (input->ExpectAtEnd()) goto success;
757         break;
758       }
759 
760       default: {
761       handle_unusual:
762         if (tag == 0 ||
763             ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
764             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
765           goto success;
766         }
767         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
768             input, tag, &unknown_fields_stream));
769         break;
770       }
771     }
772   }
773 success:
774   // @@protoc_insertion_point(parse_success:CleanerChatRequestMessage)
775   return true;
776 failure:
777   // @@protoc_insertion_point(parse_failure:CleanerChatRequestMessage)
778   return false;
779 #undef DO_
780 }
781 
782 void CleanerChatRequestMessage::SerializeWithCachedSizes(
783     ::google::protobuf::io::CodedOutputStream* output) const {
784   // @@protoc_insertion_point(serialize_start:CleanerChatRequestMessage)
785   // required uint32 requestId = 1;
786   if (has_requestid()) {
787     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
788   }
789 
790   // required .CleanerChatType cleanerChatType = 2;
791   if (has_cleanerchattype()) {
792     ::google::protobuf::internal::WireFormatLite::WriteEnum(
793       2, this->cleanerchattype(), output);
794   }
795 
796   // optional uint32 gameId = 3 [default = 0];
797   if (has_gameid()) {
798     ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->gameid(), output);
799   }
800 
801   // required uint32 playerId = 4;
802   if (has_playerid()) {
803     ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->playerid(), output);
804   }
805 
806   // required string playerName = 5;
807   if (has_playername()) {
808     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
809       5, this->playername(), output);
810   }
811 
812   // required string chatMessage = 6;
813   if (has_chatmessage()) {
814     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
815       6, this->chatmessage(), output);
816   }
817 
818   output->WriteRaw(unknown_fields().data(),
819                    unknown_fields().size());
820   // @@protoc_insertion_point(serialize_end:CleanerChatRequestMessage)
821 }
822 
823 int CleanerChatRequestMessage::ByteSize() const {
824   int total_size = 0;
825 
826   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
827     // required uint32 requestId = 1;
828     if (has_requestid()) {
829       total_size += 1 +
830         ::google::protobuf::internal::WireFormatLite::UInt32Size(
831           this->requestid());
832     }
833 
834     // required .CleanerChatType cleanerChatType = 2;
835     if (has_cleanerchattype()) {
836       total_size += 1 +
837         ::google::protobuf::internal::WireFormatLite::EnumSize(this->cleanerchattype());
838     }
839 
840     // optional uint32 gameId = 3 [default = 0];
841     if (has_gameid()) {
842       total_size += 1 +
843         ::google::protobuf::internal::WireFormatLite::UInt32Size(
844           this->gameid());
845     }
846 
847     // required uint32 playerId = 4;
848     if (has_playerid()) {
849       total_size += 1 +
850         ::google::protobuf::internal::WireFormatLite::UInt32Size(
851           this->playerid());
852     }
853 
854     // required string playerName = 5;
855     if (has_playername()) {
856       total_size += 1 +
857         ::google::protobuf::internal::WireFormatLite::StringSize(
858           this->playername());
859     }
860 
861     // required string chatMessage = 6;
862     if (has_chatmessage()) {
863       total_size += 1 +
864         ::google::protobuf::internal::WireFormatLite::StringSize(
865           this->chatmessage());
866     }
867 
868   }
869   total_size += unknown_fields().size();
870 
871   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
872   _cached_size_ = total_size;
873   GOOGLE_SAFE_CONCURRENT_WRITES_END();
874   return total_size;
875 }
876 
877 void CleanerChatRequestMessage::CheckTypeAndMergeFrom(
878     const ::google::protobuf::MessageLite& from) {
879   MergeFrom(*::google::protobuf::down_cast<const CleanerChatRequestMessage*>(&from));
880 }
881 
882 void CleanerChatRequestMessage::MergeFrom(const CleanerChatRequestMessage& from) {
883   GOOGLE_CHECK_NE(&from, this);
884   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
885     if (from.has_requestid()) {
886       set_requestid(from.requestid());
887     }
888     if (from.has_cleanerchattype()) {
889       set_cleanerchattype(from.cleanerchattype());
890     }
891     if (from.has_gameid()) {
892       set_gameid(from.gameid());
893     }
894     if (from.has_playerid()) {
895       set_playerid(from.playerid());
896     }
897     if (from.has_playername()) {
898       set_playername(from.playername());
899     }
900     if (from.has_chatmessage()) {
901       set_chatmessage(from.chatmessage());
902     }
903   }
904   mutable_unknown_fields()->append(from.unknown_fields());
905 }
906 
907 void CleanerChatRequestMessage::CopyFrom(const CleanerChatRequestMessage& from) {
908   if (&from == this) return;
909   Clear();
910   MergeFrom(from);
911 }
912 
913 bool CleanerChatRequestMessage::IsInitialized() const {
914   if ((_has_bits_[0] & 0x0000003b) != 0x0000003b) return false;
915 
916   return true;
917 }
918 
919 void CleanerChatRequestMessage::Swap(CleanerChatRequestMessage* other) {
920   if (other != this) {
921     std::swap(requestid_, other->requestid_);
922     std::swap(cleanerchattype_, other->cleanerchattype_);
923     std::swap(gameid_, other->gameid_);
924     std::swap(playerid_, other->playerid_);
925     std::swap(playername_, other->playername_);
926     std::swap(chatmessage_, other->chatmessage_);
927     std::swap(_has_bits_[0], other->_has_bits_[0]);
928     _unknown_fields_.swap(other->_unknown_fields_);
929     std::swap(_cached_size_, other->_cached_size_);
930   }
931 }
932 
933 ::std::string CleanerChatRequestMessage::GetTypeName() const {
934   return "CleanerChatRequestMessage";
935 }
936 
937 
938 // ===================================================================
939 
940 bool CleanerChatReplyMessage_CleanerActionType_IsValid(int value) {
941   switch(value) {
942     case 0:
943     case 1:
944     case 2:
945     case 3:
946     case 4:
947       return true;
948     default:
949       return false;
950   }
951 }
952 
953 #ifndef _MSC_VER
954 const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionNone;
955 const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionWarning;
956 const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionKick;
957 const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionBan;
958 const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionMute;
959 const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::CleanerActionType_MIN;
960 const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::CleanerActionType_MAX;
961 const int CleanerChatReplyMessage::CleanerActionType_ARRAYSIZE;
962 #endif  // _MSC_VER
963 #ifndef _MSC_VER
964 const int CleanerChatReplyMessage::kRequestIdFieldNumber;
965 const int CleanerChatReplyMessage::kCleanerChatTypeFieldNumber;
966 const int CleanerChatReplyMessage::kGameIdFieldNumber;
967 const int CleanerChatReplyMessage::kPlayerIdFieldNumber;
968 const int CleanerChatReplyMessage::kCleanerActionTypeFieldNumber;
969 const int CleanerChatReplyMessage::kCleanerTextFieldNumber;
970 #endif  // !_MSC_VER
971 
972 CleanerChatReplyMessage::CleanerChatReplyMessage()
973   : ::google::protobuf::MessageLite() {
974   SharedCtor();
975   // @@protoc_insertion_point(constructor:CleanerChatReplyMessage)
976 }
977 
978 void CleanerChatReplyMessage::InitAsDefaultInstance() {
979 }
980 
981 CleanerChatReplyMessage::CleanerChatReplyMessage(const CleanerChatReplyMessage& from)
982   : ::google::protobuf::MessageLite() {
983   SharedCtor();
984   MergeFrom(from);
985   // @@protoc_insertion_point(copy_constructor:CleanerChatReplyMessage)
986 }
987 
988 void CleanerChatReplyMessage::SharedCtor() {
989   ::google::protobuf::internal::GetEmptyString();
990   _cached_size_ = 0;
991   requestid_ = 0u;
992   cleanerchattype_ = 0;
993   gameid_ = 0u;
994   playerid_ = 0u;
995   cleaneractiontype_ = 0;
996   cleanertext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
997   ::memset(_has_bits_, 0, sizeof(_has_bits_));
998 }
999 
1000 CleanerChatReplyMessage::~CleanerChatReplyMessage() {
1001   // @@protoc_insertion_point(destructor:CleanerChatReplyMessage)
1002   SharedDtor();
1003 }
1004 
1005 void CleanerChatReplyMessage::SharedDtor() {
1006   if (cleanertext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1007     delete cleanertext_;
1008   }
1009   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1010   if (this != &default_instance()) {
1011   #else
1012   if (this != default_instance_) {
1013   #endif
1014   }
1015 }
1016 
1017 void CleanerChatReplyMessage::SetCachedSize(int size) const {
1018   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1019   _cached_size_ = size;
1020   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1021 }
1022 const CleanerChatReplyMessage& CleanerChatReplyMessage::default_instance() {
1023 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1024   protobuf_AddDesc_chatcleaner_2eproto();
1025 #else
1026   if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
1027 #endif
1028   return *default_instance_;
1029 }
1030 
1031 CleanerChatReplyMessage* CleanerChatReplyMessage::default_instance_ = NULL;
1032 
1033 CleanerChatReplyMessage* CleanerChatReplyMessage::New() const {
1034   return new CleanerChatReplyMessage;
1035 }
1036 
1037 void CleanerChatReplyMessage::Clear() {
1038 #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
1039   &reinterpret_cast<CleanerChatReplyMessage*>(16)->f) - \
1040    reinterpret_cast<char*>(16))
1041 
1042 #define ZR_(first, last) do {                              \
1043     size_t f = OFFSET_OF_FIELD_(first);                    \
1044     size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
1045     ::memset(&first, 0, n);                                \
1046   } while (0)
1047 
1048   if (_has_bits_[0 / 32] & 63) {
1049     ZR_(requestid_, playerid_);
1050     cleaneractiontype_ = 0;
1051     if (has_cleanertext()) {
1052       if (cleanertext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1053         cleanertext_->clear();
1054       }
1055     }
1056   }
1057 
1058 #undef OFFSET_OF_FIELD_
1059 #undef ZR_
1060 
1061   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1062   mutable_unknown_fields()->clear();
1063 }
1064 
1065 bool CleanerChatReplyMessage::MergePartialFromCodedStream(
1066     ::google::protobuf::io::CodedInputStream* input) {
1067 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
1068   ::google::protobuf::uint32 tag;
1069   ::google::protobuf::io::StringOutputStream unknown_fields_string(
1070       mutable_unknown_fields());
1071   ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
1072       &unknown_fields_string);
1073   // @@protoc_insertion_point(parse_start:CleanerChatReplyMessage)
1074   for (;;) {
1075     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
1076     tag = p.first;
1077     if (!p.second) goto handle_unusual;
1078     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1079       // required uint32 requestId = 1;
1080       case 1: {
1081         if (tag == 8) {
1082           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1083                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
1084                  input, &requestid_)));
1085           set_has_requestid();
1086         } else {
1087           goto handle_unusual;
1088         }
1089         if (input->ExpectTag(16)) goto parse_cleanerChatType;
1090         break;
1091       }
1092 
1093       // required .CleanerChatType cleanerChatType = 2;
1094       case 2: {
1095         if (tag == 16) {
1096          parse_cleanerChatType:
1097           int value;
1098           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1099                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1100                  input, &value)));
1101           if (::CleanerChatType_IsValid(value)) {
1102             set_cleanerchattype(static_cast< ::CleanerChatType >(value));
1103           } else {
1104             unknown_fields_stream.WriteVarint32(tag);
1105             unknown_fields_stream.WriteVarint32(value);
1106           }
1107         } else {
1108           goto handle_unusual;
1109         }
1110         if (input->ExpectTag(24)) goto parse_gameId;
1111         break;
1112       }
1113 
1114       // optional uint32 gameId = 3 [default = 0];
1115       case 3: {
1116         if (tag == 24) {
1117          parse_gameId:
1118           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1119                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
1120                  input, &gameid_)));
1121           set_has_gameid();
1122         } else {
1123           goto handle_unusual;
1124         }
1125         if (input->ExpectTag(32)) goto parse_playerId;
1126         break;
1127       }
1128 
1129       // required uint32 playerId = 4;
1130       case 4: {
1131         if (tag == 32) {
1132          parse_playerId:
1133           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1134                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
1135                  input, &playerid_)));
1136           set_has_playerid();
1137         } else {
1138           goto handle_unusual;
1139         }
1140         if (input->ExpectTag(40)) goto parse_cleanerActionType;
1141         break;
1142       }
1143 
1144       // required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
1145       case 5: {
1146         if (tag == 40) {
1147          parse_cleanerActionType:
1148           int value;
1149           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1150                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1151                  input, &value)));
1152           if (::CleanerChatReplyMessage_CleanerActionType_IsValid(value)) {
1153             set_cleaneractiontype(static_cast< ::CleanerChatReplyMessage_CleanerActionType >(value));
1154           } else {
1155             unknown_fields_stream.WriteVarint32(tag);
1156             unknown_fields_stream.WriteVarint32(value);
1157           }
1158         } else {
1159           goto handle_unusual;
1160         }
1161         if (input->ExpectTag(50)) goto parse_cleanerText;
1162         break;
1163       }
1164 
1165       // optional string cleanerText = 6 [default = ""];
1166       case 6: {
1167         if (tag == 50) {
1168          parse_cleanerText:
1169           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1170                 input, this->mutable_cleanertext()));
1171         } else {
1172           goto handle_unusual;
1173         }
1174         if (input->ExpectAtEnd()) goto success;
1175         break;
1176       }
1177 
1178       default: {
1179       handle_unusual:
1180         if (tag == 0 ||
1181             ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1182             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1183           goto success;
1184         }
1185         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
1186             input, tag, &unknown_fields_stream));
1187         break;
1188       }
1189     }
1190   }
1191 success:
1192   // @@protoc_insertion_point(parse_success:CleanerChatReplyMessage)
1193   return true;
1194 failure:
1195   // @@protoc_insertion_point(parse_failure:CleanerChatReplyMessage)
1196   return false;
1197 #undef DO_
1198 }
1199 
1200 void CleanerChatReplyMessage::SerializeWithCachedSizes(
1201     ::google::protobuf::io::CodedOutputStream* output) const {
1202   // @@protoc_insertion_point(serialize_start:CleanerChatReplyMessage)
1203   // required uint32 requestId = 1;
1204   if (has_requestid()) {
1205     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
1206   }
1207 
1208   // required .CleanerChatType cleanerChatType = 2;
1209   if (has_cleanerchattype()) {
1210     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1211       2, this->cleanerchattype(), output);
1212   }
1213 
1214   // optional uint32 gameId = 3 [default = 0];
1215   if (has_gameid()) {
1216     ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->gameid(), output);
1217   }
1218 
1219   // required uint32 playerId = 4;
1220   if (has_playerid()) {
1221     ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->playerid(), output);
1222   }
1223 
1224   // required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
1225   if (has_cleaneractiontype()) {
1226     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1227       5, this->cleaneractiontype(), output);
1228   }
1229 
1230   // optional string cleanerText = 6 [default = ""];
1231   if (has_cleanertext()) {
1232     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1233       6, this->cleanertext(), output);
1234   }
1235 
1236   output->WriteRaw(unknown_fields().data(),
1237                    unknown_fields().size());
1238   // @@protoc_insertion_point(serialize_end:CleanerChatReplyMessage)
1239 }
1240 
1241 int CleanerChatReplyMessage::ByteSize() const {
1242   int total_size = 0;
1243 
1244   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1245     // required uint32 requestId = 1;
1246     if (has_requestid()) {
1247       total_size += 1 +
1248         ::google::protobuf::internal::WireFormatLite::UInt32Size(
1249           this->requestid());
1250     }
1251 
1252     // required .CleanerChatType cleanerChatType = 2;
1253     if (has_cleanerchattype()) {
1254       total_size += 1 +
1255         ::google::protobuf::internal::WireFormatLite::EnumSize(this->cleanerchattype());
1256     }
1257 
1258     // optional uint32 gameId = 3 [default = 0];
1259     if (has_gameid()) {
1260       total_size += 1 +
1261         ::google::protobuf::internal::WireFormatLite::UInt32Size(
1262           this->gameid());
1263     }
1264 
1265     // required uint32 playerId = 4;
1266     if (has_playerid()) {
1267       total_size += 1 +
1268         ::google::protobuf::internal::WireFormatLite::UInt32Size(
1269           this->playerid());
1270     }
1271 
1272     // required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
1273     if (has_cleaneractiontype()) {
1274       total_size += 1 +
1275         ::google::protobuf::internal::WireFormatLite::EnumSize(this->cleaneractiontype());
1276     }
1277 
1278     // optional string cleanerText = 6 [default = ""];
1279     if (has_cleanertext()) {
1280       total_size += 1 +
1281         ::google::protobuf::internal::WireFormatLite::StringSize(
1282           this->cleanertext());
1283     }
1284 
1285   }
1286   total_size += unknown_fields().size();
1287 
1288   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1289   _cached_size_ = total_size;
1290   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1291   return total_size;
1292 }
1293 
1294 void CleanerChatReplyMessage::CheckTypeAndMergeFrom(
1295     const ::google::protobuf::MessageLite& from) {
1296   MergeFrom(*::google::protobuf::down_cast<const CleanerChatReplyMessage*>(&from));
1297 }
1298 
1299 void CleanerChatReplyMessage::MergeFrom(const CleanerChatReplyMessage& from) {
1300   GOOGLE_CHECK_NE(&from, this);
1301   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1302     if (from.has_requestid()) {
1303       set_requestid(from.requestid());
1304     }
1305     if (from.has_cleanerchattype()) {
1306       set_cleanerchattype(from.cleanerchattype());
1307     }
1308     if (from.has_gameid()) {
1309       set_gameid(from.gameid());
1310     }
1311     if (from.has_playerid()) {
1312       set_playerid(from.playerid());
1313     }
1314     if (from.has_cleaneractiontype()) {
1315       set_cleaneractiontype(from.cleaneractiontype());
1316     }
1317     if (from.has_cleanertext()) {
1318       set_cleanertext(from.cleanertext());
1319     }
1320   }
1321   mutable_unknown_fields()->append(from.unknown_fields());
1322 }
1323 
1324 void CleanerChatReplyMessage::CopyFrom(const CleanerChatReplyMessage& from) {
1325   if (&from == this) return;
1326   Clear();
1327   MergeFrom(from);
1328 }
1329 
1330 bool CleanerChatReplyMessage::IsInitialized() const {
1331   if ((_has_bits_[0] & 0x0000001b) != 0x0000001b) return false;
1332 
1333   return true;
1334 }
1335 
1336 void CleanerChatReplyMessage::Swap(CleanerChatReplyMessage* other) {
1337   if (other != this) {
1338     std::swap(requestid_, other->requestid_);
1339     std::swap(cleanerchattype_, other->cleanerchattype_);
1340     std::swap(gameid_, other->gameid_);
1341     std::swap(playerid_, other->playerid_);
1342     std::swap(cleaneractiontype_, other->cleaneractiontype_);
1343     std::swap(cleanertext_, other->cleanertext_);
1344     std::swap(_has_bits_[0], other->_has_bits_[0]);
1345     _unknown_fields_.swap(other->_unknown_fields_);
1346     std::swap(_cached_size_, other->_cached_size_);
1347   }
1348 }
1349 
1350 ::std::string CleanerChatReplyMessage::GetTypeName() const {
1351   return "CleanerChatReplyMessage";
1352 }
1353 
1354 
1355 // ===================================================================
1356 
1357 bool ChatCleanerMessage_ChatCleanerMessageType_IsValid(int value) {
1358   switch(value) {
1359     case 1:
1360     case 2:
1361     case 3:
1362     case 4:
1363       return true;
1364     default:
1365       return false;
1366   }
1367 }
1368 
1369 #ifndef _MSC_VER
1370 const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerInitMessage;
1371 const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerInitAckMessage;
1372 const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerChatRequestMessage;
1373 const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerChatReplyMessage;
1374 const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::ChatCleanerMessageType_MIN;
1375 const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::ChatCleanerMessageType_MAX;
1376 const int ChatCleanerMessage::ChatCleanerMessageType_ARRAYSIZE;
1377 #endif  // _MSC_VER
1378 #ifndef _MSC_VER
1379 const int ChatCleanerMessage::kMessageTypeFieldNumber;
1380 const int ChatCleanerMessage::kCleanerInitMessageFieldNumber;
1381 const int ChatCleanerMessage::kCleanerInitAckMessageFieldNumber;
1382 const int ChatCleanerMessage::kCleanerChatRequestMessageFieldNumber;
1383 const int ChatCleanerMessage::kCleanerChatReplyMessageFieldNumber;
1384 #endif  // !_MSC_VER
1385 
1386 ChatCleanerMessage::ChatCleanerMessage()
1387   : ::google::protobuf::MessageLite() {
1388   SharedCtor();
1389   // @@protoc_insertion_point(constructor:ChatCleanerMessage)
1390 }
1391 
1392 void ChatCleanerMessage::InitAsDefaultInstance() {
1393 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1394   cleanerinitmessage_ = const_cast< ::CleanerInitMessage*>(
1395       ::CleanerInitMessage::internal_default_instance());
1396 #else
1397   cleanerinitmessage_ = const_cast< ::CleanerInitMessage*>(&::CleanerInitMessage::default_instance());
1398 #endif
1399 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1400   cleanerinitackmessage_ = const_cast< ::CleanerInitAckMessage*>(
1401       ::CleanerInitAckMessage::internal_default_instance());
1402 #else
1403   cleanerinitackmessage_ = const_cast< ::CleanerInitAckMessage*>(&::CleanerInitAckMessage::default_instance());
1404 #endif
1405 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1406   cleanerchatrequestmessage_ = const_cast< ::CleanerChatRequestMessage*>(
1407       ::CleanerChatRequestMessage::internal_default_instance());
1408 #else
1409   cleanerchatrequestmessage_ = const_cast< ::CleanerChatRequestMessage*>(&::CleanerChatRequestMessage::default_instance());
1410 #endif
1411 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1412   cleanerchatreplymessage_ = const_cast< ::CleanerChatReplyMessage*>(
1413       ::CleanerChatReplyMessage::internal_default_instance());
1414 #else
1415   cleanerchatreplymessage_ = const_cast< ::CleanerChatReplyMessage*>(&::CleanerChatReplyMessage::default_instance());
1416 #endif
1417 }
1418 
1419 ChatCleanerMessage::ChatCleanerMessage(const ChatCleanerMessage& from)
1420   : ::google::protobuf::MessageLite() {
1421   SharedCtor();
1422   MergeFrom(from);
1423   // @@protoc_insertion_point(copy_constructor:ChatCleanerMessage)
1424 }
1425 
1426 void ChatCleanerMessage::SharedCtor() {
1427   _cached_size_ = 0;
1428   messagetype_ = 1;
1429   cleanerinitmessage_ = NULL;
1430   cleanerinitackmessage_ = NULL;
1431   cleanerchatrequestmessage_ = NULL;
1432   cleanerchatreplymessage_ = NULL;
1433   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1434 }
1435 
1436 ChatCleanerMessage::~ChatCleanerMessage() {
1437   // @@protoc_insertion_point(destructor:ChatCleanerMessage)
1438   SharedDtor();
1439 }
1440 
1441 void ChatCleanerMessage::SharedDtor() {
1442   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1443   if (this != &default_instance()) {
1444   #else
1445   if (this != default_instance_) {
1446   #endif
1447     delete cleanerinitmessage_;
1448     delete cleanerinitackmessage_;
1449     delete cleanerchatrequestmessage_;
1450     delete cleanerchatreplymessage_;
1451   }
1452 }
1453 
1454 void ChatCleanerMessage::SetCachedSize(int size) const {
1455   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1456   _cached_size_ = size;
1457   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1458 }
1459 const ChatCleanerMessage& ChatCleanerMessage::default_instance() {
1460 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1461   protobuf_AddDesc_chatcleaner_2eproto();
1462 #else
1463   if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
1464 #endif
1465   return *default_instance_;
1466 }
1467 
1468 ChatCleanerMessage* ChatCleanerMessage::default_instance_ = NULL;
1469 
1470 ChatCleanerMessage* ChatCleanerMessage::New() const {
1471   return new ChatCleanerMessage;
1472 }
1473 
1474 void ChatCleanerMessage::Clear() {
1475   if (_has_bits_[0 / 32] & 31) {
1476     messagetype_ = 1;
1477     if (has_cleanerinitmessage()) {
1478       if (cleanerinitmessage_ != NULL) cleanerinitmessage_->::CleanerInitMessage::Clear();
1479     }
1480     if (has_cleanerinitackmessage()) {
1481       if (cleanerinitackmessage_ != NULL) cleanerinitackmessage_->::CleanerInitAckMessage::Clear();
1482     }
1483     if (has_cleanerchatrequestmessage()) {
1484       if (cleanerchatrequestmessage_ != NULL) cleanerchatrequestmessage_->::CleanerChatRequestMessage::Clear();
1485     }
1486     if (has_cleanerchatreplymessage()) {
1487       if (cleanerchatreplymessage_ != NULL) cleanerchatreplymessage_->::CleanerChatReplyMessage::Clear();
1488     }
1489   }
1490   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1491   mutable_unknown_fields()->clear();
1492 }
1493 
1494 bool ChatCleanerMessage::MergePartialFromCodedStream(
1495     ::google::protobuf::io::CodedInputStream* input) {
1496 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
1497   ::google::protobuf::uint32 tag;
1498   ::google::protobuf::io::StringOutputStream unknown_fields_string(
1499       mutable_unknown_fields());
1500   ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
1501       &unknown_fields_string);
1502   // @@protoc_insertion_point(parse_start:ChatCleanerMessage)
1503   for (;;) {
1504     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
1505     tag = p.first;
1506     if (!p.second) goto handle_unusual;
1507     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1508       // required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
1509       case 1: {
1510         if (tag == 8) {
1511           int value;
1512           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1513                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1514                  input, &value)));
1515           if (::ChatCleanerMessage_ChatCleanerMessageType_IsValid(value)) {
1516             set_messagetype(static_cast< ::ChatCleanerMessage_ChatCleanerMessageType >(value));
1517           } else {
1518             unknown_fields_stream.WriteVarint32(tag);
1519             unknown_fields_stream.WriteVarint32(value);
1520           }
1521         } else {
1522           goto handle_unusual;
1523         }
1524         if (input->ExpectTag(18)) goto parse_cleanerInitMessage;
1525         break;
1526       }
1527 
1528       // optional .CleanerInitMessage cleanerInitMessage = 2;
1529       case 2: {
1530         if (tag == 18) {
1531          parse_cleanerInitMessage:
1532           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1533                input, mutable_cleanerinitmessage()));
1534         } else {
1535           goto handle_unusual;
1536         }
1537         if (input->ExpectTag(26)) goto parse_cleanerInitAckMessage;
1538         break;
1539       }
1540 
1541       // optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
1542       case 3: {
1543         if (tag == 26) {
1544          parse_cleanerInitAckMessage:
1545           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1546                input, mutable_cleanerinitackmessage()));
1547         } else {
1548           goto handle_unusual;
1549         }
1550         if (input->ExpectTag(34)) goto parse_cleanerChatRequestMessage;
1551         break;
1552       }
1553 
1554       // optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
1555       case 4: {
1556         if (tag == 34) {
1557          parse_cleanerChatRequestMessage:
1558           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1559                input, mutable_cleanerchatrequestmessage()));
1560         } else {
1561           goto handle_unusual;
1562         }
1563         if (input->ExpectTag(42)) goto parse_cleanerChatReplyMessage;
1564         break;
1565       }
1566 
1567       // optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
1568       case 5: {
1569         if (tag == 42) {
1570          parse_cleanerChatReplyMessage:
1571           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1572                input, mutable_cleanerchatreplymessage()));
1573         } else {
1574           goto handle_unusual;
1575         }
1576         if (input->ExpectAtEnd()) goto success;
1577         break;
1578       }
1579 
1580       default: {
1581       handle_unusual:
1582         if (tag == 0 ||
1583             ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1584             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1585           goto success;
1586         }
1587         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
1588             input, tag, &unknown_fields_stream));
1589         break;
1590       }
1591     }
1592   }
1593 success:
1594   // @@protoc_insertion_point(parse_success:ChatCleanerMessage)
1595   return true;
1596 failure:
1597   // @@protoc_insertion_point(parse_failure:ChatCleanerMessage)
1598   return false;
1599 #undef DO_
1600 }
1601 
1602 void ChatCleanerMessage::SerializeWithCachedSizes(
1603     ::google::protobuf::io::CodedOutputStream* output) const {
1604   // @@protoc_insertion_point(serialize_start:ChatCleanerMessage)
1605   // required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
1606   if (has_messagetype()) {
1607     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1608       1, this->messagetype(), output);
1609   }
1610 
1611   // optional .CleanerInitMessage cleanerInitMessage = 2;
1612   if (has_cleanerinitmessage()) {
1613     ::google::protobuf::internal::WireFormatLite::WriteMessage(
1614       2, this->cleanerinitmessage(), output);
1615   }
1616 
1617   // optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
1618   if (has_cleanerinitackmessage()) {
1619     ::google::protobuf::internal::WireFormatLite::WriteMessage(
1620       3, this->cleanerinitackmessage(), output);
1621   }
1622 
1623   // optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
1624   if (has_cleanerchatrequestmessage()) {
1625     ::google::protobuf::internal::WireFormatLite::WriteMessage(
1626       4, this->cleanerchatrequestmessage(), output);
1627   }
1628 
1629   // optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
1630   if (has_cleanerchatreplymessage()) {
1631     ::google::protobuf::internal::WireFormatLite::WriteMessage(
1632       5, this->cleanerchatreplymessage(), output);
1633   }
1634 
1635   output->WriteRaw(unknown_fields().data(),
1636                    unknown_fields().size());
1637   // @@protoc_insertion_point(serialize_end:ChatCleanerMessage)
1638 }
1639 
1640 int ChatCleanerMessage::ByteSize() const {
1641   int total_size = 0;
1642 
1643   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1644     // required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
1645     if (has_messagetype()) {
1646       total_size += 1 +
1647         ::google::protobuf::internal::WireFormatLite::EnumSize(this->messagetype());
1648     }
1649 
1650     // optional .CleanerInitMessage cleanerInitMessage = 2;
1651     if (has_cleanerinitmessage()) {
1652       total_size += 1 +
1653         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1654           this->cleanerinitmessage());
1655     }
1656 
1657     // optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
1658     if (has_cleanerinitackmessage()) {
1659       total_size += 1 +
1660         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1661           this->cleanerinitackmessage());
1662     }
1663 
1664     // optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
1665     if (has_cleanerchatrequestmessage()) {
1666       total_size += 1 +
1667         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1668           this->cleanerchatrequestmessage());
1669     }
1670 
1671     // optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
1672     if (has_cleanerchatreplymessage()) {
1673       total_size += 1 +
1674         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1675           this->cleanerchatreplymessage());
1676     }
1677 
1678   }
1679   total_size += unknown_fields().size();
1680 
1681   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1682   _cached_size_ = total_size;
1683   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1684   return total_size;
1685 }
1686 
1687 void ChatCleanerMessage::CheckTypeAndMergeFrom(
1688     const ::google::protobuf::MessageLite& from) {
1689   MergeFrom(*::google::protobuf::down_cast<const ChatCleanerMessage*>(&from));
1690 }
1691 
1692 void ChatCleanerMessage::MergeFrom(const ChatCleanerMessage& from) {
1693   GOOGLE_CHECK_NE(&from, this);
1694   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1695     if (from.has_messagetype()) {
1696       set_messagetype(from.messagetype());
1697     }
1698     if (from.has_cleanerinitmessage()) {
1699       mutable_cleanerinitmessage()->::CleanerInitMessage::MergeFrom(from.cleanerinitmessage());
1700     }
1701     if (from.has_cleanerinitackmessage()) {
1702       mutable_cleanerinitackmessage()->::CleanerInitAckMessage::MergeFrom(from.cleanerinitackmessage());
1703     }
1704     if (from.has_cleanerchatrequestmessage()) {
1705       mutable_cleanerchatrequestmessage()->::CleanerChatRequestMessage::MergeFrom(from.cleanerchatrequestmessage());
1706     }
1707     if (from.has_cleanerchatreplymessage()) {
1708       mutable_cleanerchatreplymessage()->::CleanerChatReplyMessage::MergeFrom(from.cleanerchatreplymessage());
1709     }
1710   }
1711   mutable_unknown_fields()->append(from.unknown_fields());
1712 }
1713 
1714 void ChatCleanerMessage::CopyFrom(const ChatCleanerMessage& from) {
1715   if (&from == this) return;
1716   Clear();
1717   MergeFrom(from);
1718 }
1719 
1720 bool ChatCleanerMessage::IsInitialized() const {
1721   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
1722 
1723   if (has_cleanerinitmessage()) {
1724     if (!this->cleanerinitmessage().IsInitialized()) return false;
1725   }
1726   if (has_cleanerinitackmessage()) {
1727     if (!this->cleanerinitackmessage().IsInitialized()) return false;
1728   }
1729   if (has_cleanerchatrequestmessage()) {
1730     if (!this->cleanerchatrequestmessage().IsInitialized()) return false;
1731   }
1732   if (has_cleanerchatreplymessage()) {
1733     if (!this->cleanerchatreplymessage().IsInitialized()) return false;
1734   }
1735   return true;
1736 }
1737 
1738 void ChatCleanerMessage::Swap(ChatCleanerMessage* other) {
1739   if (other != this) {
1740     std::swap(messagetype_, other->messagetype_);
1741     std::swap(cleanerinitmessage_, other->cleanerinitmessage_);
1742     std::swap(cleanerinitackmessage_, other->cleanerinitackmessage_);
1743     std::swap(cleanerchatrequestmessage_, other->cleanerchatrequestmessage_);
1744     std::swap(cleanerchatreplymessage_, other->cleanerchatreplymessage_);
1745     std::swap(_has_bits_[0], other->_has_bits_[0]);
1746     _unknown_fields_.swap(other->_unknown_fields_);
1747     std::swap(_cached_size_, other->_cached_size_);
1748   }
1749 }
1750 
1751 ::std::string ChatCleanerMessage::GetTypeName() const {
1752   return "ChatCleanerMessage";
1753 }
1754 
1755 
1756 // @@protoc_insertion_point(namespace_scope)
1757 
1758 // @@protoc_insertion_point(global_scope)
1759