1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: mysqlx_expect.proto
3 
4 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
5 #include "mysqlx_expect.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 
16 namespace Mysqlx {
17 namespace Expect {
18 
protobuf_ShutdownFile_mysqlx_5fexpect_2eproto()19 void protobuf_ShutdownFile_mysqlx_5fexpect_2eproto() {
20   delete Open::default_instance_;
21   delete Open_Condition::default_instance_;
22   delete Close::default_instance_;
23 }
24 
25 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
protobuf_AddDesc_mysqlx_5fexpect_2eproto_impl()26 void protobuf_AddDesc_mysqlx_5fexpect_2eproto_impl() {
27   GOOGLE_PROTOBUF_VERIFY_VERSION;
28 
29 #else
30 void protobuf_AddDesc_mysqlx_5fexpect_2eproto() {
31   static bool already_here = false;
32   if (already_here) return;
33   already_here = true;
34   GOOGLE_PROTOBUF_VERIFY_VERSION;
35 
36 #endif
37   Open::default_instance_ = new Open();
38   Open_Condition::default_instance_ = new Open_Condition();
39   Close::default_instance_ = new Close();
40   Open::default_instance_->InitAsDefaultInstance();
41   Open_Condition::default_instance_->InitAsDefaultInstance();
42   Close::default_instance_->InitAsDefaultInstance();
43   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_mysqlx_5fexpect_2eproto);
44 }
45 
46 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
47 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_mysqlx_5fexpect_2eproto_once_);
48 void protobuf_AddDesc_mysqlx_5fexpect_2eproto() {
49   ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_mysqlx_5fexpect_2eproto_once_,
50                  &protobuf_AddDesc_mysqlx_5fexpect_2eproto_impl);
51 }
52 #else
53 // Force AddDescriptors() to be called at static initialization time.
54 struct StaticDescriptorInitializer_mysqlx_5fexpect_2eproto {
55   StaticDescriptorInitializer_mysqlx_5fexpect_2eproto() {
56     protobuf_AddDesc_mysqlx_5fexpect_2eproto();
57   }
58 } static_descriptor_initializer_mysqlx_5fexpect_2eproto_;
59 #endif
60 
61 // ===================================================================
62 
63 bool Open_CtxOperation_IsValid(int value) {
64   switch(value) {
65     case 0:
66     case 1:
67       return true;
68     default:
69       return false;
70   }
71 }
72 
73 #ifndef _MSC_VER
74 const Open_CtxOperation Open::EXPECT_CTX_COPY_PREV;
75 const Open_CtxOperation Open::EXPECT_CTX_EMPTY;
76 const Open_CtxOperation Open::CtxOperation_MIN;
77 const Open_CtxOperation Open::CtxOperation_MAX;
78 const int Open::CtxOperation_ARRAYSIZE;
79 #endif  // _MSC_VER
80 bool Open_Condition_ConditionOperation_IsValid(int value) {
81   switch(value) {
82     case 0:
83     case 1:
84       return true;
85     default:
86       return false;
87   }
88 }
89 
90 #ifndef _MSC_VER
91 const Open_Condition_ConditionOperation Open_Condition::EXPECT_OP_SET;
92 const Open_Condition_ConditionOperation Open_Condition::EXPECT_OP_UNSET;
93 const Open_Condition_ConditionOperation Open_Condition::ConditionOperation_MIN;
94 const Open_Condition_ConditionOperation Open_Condition::ConditionOperation_MAX;
95 const int Open_Condition::ConditionOperation_ARRAYSIZE;
96 #endif  // _MSC_VER
97 #ifndef _MSC_VER
98 const int Open_Condition::kConditionKeyFieldNumber;
99 const int Open_Condition::kConditionValueFieldNumber;
100 const int Open_Condition::kOpFieldNumber;
101 #endif  // !_MSC_VER
102 
103 Open_Condition::Open_Condition()
104   : ::google::protobuf::MessageLite() {
105   SharedCtor();
106   // @@protoc_insertion_point(constructor:Mysqlx.Expect.Open.Condition)
107 }
108 
109 void Open_Condition::InitAsDefaultInstance() {
110 }
111 
112 Open_Condition::Open_Condition(const Open_Condition& from)
113   : ::google::protobuf::MessageLite() {
114   SharedCtor();
115   MergeFrom(from);
116   // @@protoc_insertion_point(copy_constructor:Mysqlx.Expect.Open.Condition)
117 }
118 
119 void Open_Condition::SharedCtor() {
120   ::google::protobuf::internal::GetEmptyString();
121   _cached_size_ = 0;
122   condition_key_ = 0u;
123   condition_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
124   op_ = 0;
125   ::memset(_has_bits_, 0, sizeof(_has_bits_));
126 }
127 
128 Open_Condition::~Open_Condition() {
129   // @@protoc_insertion_point(destructor:Mysqlx.Expect.Open.Condition)
130   SharedDtor();
131 }
132 
133 void Open_Condition::SharedDtor() {
134   if (condition_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
135     delete condition_value_;
136   }
137   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
138   if (this != &default_instance()) {
139   #else
140   if (this != default_instance_) {
141   #endif
142   }
143 }
144 
145 void Open_Condition::SetCachedSize(int size) const {
146   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
147   _cached_size_ = size;
148   GOOGLE_SAFE_CONCURRENT_WRITES_END();
149 }
150 const Open_Condition& Open_Condition::default_instance() {
151 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
152   protobuf_AddDesc_mysqlx_5fexpect_2eproto();
153 #else
154   if (default_instance_ == NULL) protobuf_AddDesc_mysqlx_5fexpect_2eproto();
155 #endif
156   return *default_instance_;
157 }
158 
159 Open_Condition* Open_Condition::default_instance_ = NULL;
160 
161 Open_Condition* Open_Condition::New() const {
162   return new Open_Condition;
163 }
164 
165 void Open_Condition::Clear() {
166 #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
167   &reinterpret_cast<Open_Condition*>(16)->f) - \
168    reinterpret_cast<char*>(16))
169 
170 #define ZR_(first, last) do {                              \
171     size_t f = OFFSET_OF_FIELD_(first);                    \
172     size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
173     ::memset(&first, 0, n);                                \
174   } while (0)
175 
176   if (_has_bits_[0 / 32] & 7) {
177     ZR_(condition_key_, op_);
178     if (has_condition_value()) {
179       if (condition_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
180         condition_value_->clear();
181       }
182     }
183   }
184 
185 #undef OFFSET_OF_FIELD_
186 #undef ZR_
187 
188   ::memset(_has_bits_, 0, sizeof(_has_bits_));
189   mutable_unknown_fields()->clear();
190 }
191 
192 bool Open_Condition::MergePartialFromCodedStream(
193     ::google::protobuf::io::CodedInputStream* input) {
194 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
195   ::google::protobuf::uint32 tag;
196   ::google::protobuf::io::StringOutputStream unknown_fields_string(
197       mutable_unknown_fields());
198   ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
199       &unknown_fields_string);
200   // @@protoc_insertion_point(parse_start:Mysqlx.Expect.Open.Condition)
201   for (;;) {
202     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
203     tag = p.first;
204     if (!p.second) goto handle_unusual;
205     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
206       // required uint32 condition_key = 1;
207       case 1: {
208         if (tag == 8) {
209           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
210                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
211                  input, &condition_key_)));
212           set_has_condition_key();
213         } else {
214           goto handle_unusual;
215         }
216         if (input->ExpectTag(18)) goto parse_condition_value;
217         break;
218       }
219 
220       // optional bytes condition_value = 2;
221       case 2: {
222         if (tag == 18) {
223          parse_condition_value:
224           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
225                 input, this->mutable_condition_value()));
226         } else {
227           goto handle_unusual;
228         }
229         if (input->ExpectTag(24)) goto parse_op;
230         break;
231       }
232 
233       // optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET];
234       case 3: {
235         if (tag == 24) {
236          parse_op:
237           int value;
238           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
239                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
240                  input, &value)));
241           if (::Mysqlx::Expect::Open_Condition_ConditionOperation_IsValid(value)) {
242             set_op(static_cast< ::Mysqlx::Expect::Open_Condition_ConditionOperation >(value));
243           } else {
244             unknown_fields_stream.WriteVarint32(tag);
245             unknown_fields_stream.WriteVarint32(value);
246           }
247         } else {
248           goto handle_unusual;
249         }
250         if (input->ExpectAtEnd()) goto success;
251         break;
252       }
253 
254       default: {
255       handle_unusual:
256         if (tag == 0 ||
257             ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
258             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
259           goto success;
260         }
261         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
262             input, tag, &unknown_fields_stream));
263         break;
264       }
265     }
266   }
267 success:
268   // @@protoc_insertion_point(parse_success:Mysqlx.Expect.Open.Condition)
269   return true;
270 failure:
271   // @@protoc_insertion_point(parse_failure:Mysqlx.Expect.Open.Condition)
272   return false;
273 #undef DO_
274 }
275 
276 void Open_Condition::SerializeWithCachedSizes(
277     ::google::protobuf::io::CodedOutputStream* output) const {
278   // @@protoc_insertion_point(serialize_start:Mysqlx.Expect.Open.Condition)
279   // required uint32 condition_key = 1;
280   if (has_condition_key()) {
281     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->condition_key(), output);
282   }
283 
284   // optional bytes condition_value = 2;
285   if (has_condition_value()) {
286     ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
287       2, this->condition_value(), output);
288   }
289 
290   // optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET];
291   if (has_op()) {
292     ::google::protobuf::internal::WireFormatLite::WriteEnum(
293       3, this->op(), output);
294   }
295 
296   output->WriteRaw(unknown_fields().data(),
297                    unknown_fields().size());
298   // @@protoc_insertion_point(serialize_end:Mysqlx.Expect.Open.Condition)
299 }
300 
301 int Open_Condition::ByteSize() const {
302   int total_size = 0;
303 
304   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
305     // required uint32 condition_key = 1;
306     if (has_condition_key()) {
307       total_size += 1 +
308         ::google::protobuf::internal::WireFormatLite::UInt32Size(
309           this->condition_key());
310     }
311 
312     // optional bytes condition_value = 2;
313     if (has_condition_value()) {
314       total_size += 1 +
315         ::google::protobuf::internal::WireFormatLite::BytesSize(
316           this->condition_value());
317     }
318 
319     // optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET];
320     if (has_op()) {
321       total_size += 1 +
322         ::google::protobuf::internal::WireFormatLite::EnumSize(this->op());
323     }
324 
325   }
326   total_size += unknown_fields().size();
327 
328   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
329   _cached_size_ = total_size;
330   GOOGLE_SAFE_CONCURRENT_WRITES_END();
331   return total_size;
332 }
333 
334 void Open_Condition::CheckTypeAndMergeFrom(
335     const ::google::protobuf::MessageLite& from) {
336   MergeFrom(*::google::protobuf::down_cast<const Open_Condition*>(&from));
337 }
338 
339 void Open_Condition::MergeFrom(const Open_Condition& from) {
340   GOOGLE_CHECK_NE(&from, this);
341   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
342     if (from.has_condition_key()) {
343       set_condition_key(from.condition_key());
344     }
345     if (from.has_condition_value()) {
346       set_condition_value(from.condition_value());
347     }
348     if (from.has_op()) {
349       set_op(from.op());
350     }
351   }
352   mutable_unknown_fields()->append(from.unknown_fields());
353 }
354 
355 void Open_Condition::CopyFrom(const Open_Condition& from) {
356   if (&from == this) return;
357   Clear();
358   MergeFrom(from);
359 }
360 
361 bool Open_Condition::IsInitialized() const {
362   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
363 
364   return true;
365 }
366 
367 void Open_Condition::Swap(Open_Condition* other) {
368   if (other != this) {
369     std::swap(condition_key_, other->condition_key_);
370     std::swap(condition_value_, other->condition_value_);
371     std::swap(op_, other->op_);
372     std::swap(_has_bits_[0], other->_has_bits_[0]);
373     _unknown_fields_.swap(other->_unknown_fields_);
374     std::swap(_cached_size_, other->_cached_size_);
375   }
376 }
377 
378 ::std::string Open_Condition::GetTypeName() const {
379   return "Mysqlx.Expect.Open.Condition";
380 }
381 
382 
383 // -------------------------------------------------------------------
384 
385 #ifndef _MSC_VER
386 const int Open::kOpFieldNumber;
387 const int Open::kCondFieldNumber;
388 #endif  // !_MSC_VER
389 
390 Open::Open()
391   : ::google::protobuf::MessageLite() {
392   SharedCtor();
393   // @@protoc_insertion_point(constructor:Mysqlx.Expect.Open)
394 }
395 
396 void Open::InitAsDefaultInstance() {
397 }
398 
399 Open::Open(const Open& from)
400   : ::google::protobuf::MessageLite() {
401   SharedCtor();
402   MergeFrom(from);
403   // @@protoc_insertion_point(copy_constructor:Mysqlx.Expect.Open)
404 }
405 
406 void Open::SharedCtor() {
407   _cached_size_ = 0;
408   op_ = 0;
409   ::memset(_has_bits_, 0, sizeof(_has_bits_));
410 }
411 
412 Open::~Open() {
413   // @@protoc_insertion_point(destructor:Mysqlx.Expect.Open)
414   SharedDtor();
415 }
416 
417 void Open::SharedDtor() {
418   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
419   if (this != &default_instance()) {
420   #else
421   if (this != default_instance_) {
422   #endif
423   }
424 }
425 
426 void Open::SetCachedSize(int size) const {
427   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
428   _cached_size_ = size;
429   GOOGLE_SAFE_CONCURRENT_WRITES_END();
430 }
431 const Open& Open::default_instance() {
432 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
433   protobuf_AddDesc_mysqlx_5fexpect_2eproto();
434 #else
435   if (default_instance_ == NULL) protobuf_AddDesc_mysqlx_5fexpect_2eproto();
436 #endif
437   return *default_instance_;
438 }
439 
440 Open* Open::default_instance_ = NULL;
441 
442 Open* Open::New() const {
443   return new Open;
444 }
445 
446 void Open::Clear() {
447   op_ = 0;
448   cond_.Clear();
449   ::memset(_has_bits_, 0, sizeof(_has_bits_));
450   mutable_unknown_fields()->clear();
451 }
452 
453 bool Open::MergePartialFromCodedStream(
454     ::google::protobuf::io::CodedInputStream* input) {
455 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
456   ::google::protobuf::uint32 tag;
457   ::google::protobuf::io::StringOutputStream unknown_fields_string(
458       mutable_unknown_fields());
459   ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
460       &unknown_fields_string);
461   // @@protoc_insertion_point(parse_start:Mysqlx.Expect.Open)
462   for (;;) {
463     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
464     tag = p.first;
465     if (!p.second) goto handle_unusual;
466     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
467       // optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV];
468       case 1: {
469         if (tag == 8) {
470           int value;
471           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
472                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
473                  input, &value)));
474           if (::Mysqlx::Expect::Open_CtxOperation_IsValid(value)) {
475             set_op(static_cast< ::Mysqlx::Expect::Open_CtxOperation >(value));
476           } else {
477             unknown_fields_stream.WriteVarint32(tag);
478             unknown_fields_stream.WriteVarint32(value);
479           }
480         } else {
481           goto handle_unusual;
482         }
483         if (input->ExpectTag(18)) goto parse_cond;
484         break;
485       }
486 
487       // repeated .Mysqlx.Expect.Open.Condition cond = 2;
488       case 2: {
489         if (tag == 18) {
490          parse_cond:
491           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
492                 input, add_cond()));
493         } else {
494           goto handle_unusual;
495         }
496         if (input->ExpectTag(18)) goto parse_cond;
497         if (input->ExpectAtEnd()) goto success;
498         break;
499       }
500 
501       default: {
502       handle_unusual:
503         if (tag == 0 ||
504             ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
505             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
506           goto success;
507         }
508         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
509             input, tag, &unknown_fields_stream));
510         break;
511       }
512     }
513   }
514 success:
515   // @@protoc_insertion_point(parse_success:Mysqlx.Expect.Open)
516   return true;
517 failure:
518   // @@protoc_insertion_point(parse_failure:Mysqlx.Expect.Open)
519   return false;
520 #undef DO_
521 }
522 
523 void Open::SerializeWithCachedSizes(
524     ::google::protobuf::io::CodedOutputStream* output) const {
525   // @@protoc_insertion_point(serialize_start:Mysqlx.Expect.Open)
526   // optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV];
527   if (has_op()) {
528     ::google::protobuf::internal::WireFormatLite::WriteEnum(
529       1, this->op(), output);
530   }
531 
532   // repeated .Mysqlx.Expect.Open.Condition cond = 2;
533   for (int i = 0; i < this->cond_size(); i++) {
534     ::google::protobuf::internal::WireFormatLite::WriteMessage(
535       2, this->cond(i), output);
536   }
537 
538   output->WriteRaw(unknown_fields().data(),
539                    unknown_fields().size());
540   // @@protoc_insertion_point(serialize_end:Mysqlx.Expect.Open)
541 }
542 
543 int Open::ByteSize() const {
544   int total_size = 0;
545 
546   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
547     // optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV];
548     if (has_op()) {
549       total_size += 1 +
550         ::google::protobuf::internal::WireFormatLite::EnumSize(this->op());
551     }
552 
553   }
554   // repeated .Mysqlx.Expect.Open.Condition cond = 2;
555   total_size += 1 * this->cond_size();
556   for (int i = 0; i < this->cond_size(); i++) {
557     total_size +=
558       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
559         this->cond(i));
560   }
561 
562   total_size += unknown_fields().size();
563 
564   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
565   _cached_size_ = total_size;
566   GOOGLE_SAFE_CONCURRENT_WRITES_END();
567   return total_size;
568 }
569 
570 void Open::CheckTypeAndMergeFrom(
571     const ::google::protobuf::MessageLite& from) {
572   MergeFrom(*::google::protobuf::down_cast<const Open*>(&from));
573 }
574 
575 void Open::MergeFrom(const Open& from) {
576   GOOGLE_CHECK_NE(&from, this);
577   cond_.MergeFrom(from.cond_);
578   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
579     if (from.has_op()) {
580       set_op(from.op());
581     }
582   }
583   mutable_unknown_fields()->append(from.unknown_fields());
584 }
585 
586 void Open::CopyFrom(const Open& from) {
587   if (&from == this) return;
588   Clear();
589   MergeFrom(from);
590 }
591 
592 bool Open::IsInitialized() const {
593 
594   if (!::google::protobuf::internal::AllAreInitialized(this->cond())) return false;
595   return true;
596 }
597 
598 void Open::Swap(Open* other) {
599   if (other != this) {
600     std::swap(op_, other->op_);
601     cond_.Swap(&other->cond_);
602     std::swap(_has_bits_[0], other->_has_bits_[0]);
603     _unknown_fields_.swap(other->_unknown_fields_);
604     std::swap(_cached_size_, other->_cached_size_);
605   }
606 }
607 
608 ::std::string Open::GetTypeName() const {
609   return "Mysqlx.Expect.Open";
610 }
611 
612 
613 // ===================================================================
614 
615 #ifndef _MSC_VER
616 #endif  // !_MSC_VER
617 
618 Close::Close()
619   : ::google::protobuf::MessageLite() {
620   SharedCtor();
621   // @@protoc_insertion_point(constructor:Mysqlx.Expect.Close)
622 }
623 
624 void Close::InitAsDefaultInstance() {
625 }
626 
627 Close::Close(const Close& from)
628   : ::google::protobuf::MessageLite() {
629   SharedCtor();
630   MergeFrom(from);
631   // @@protoc_insertion_point(copy_constructor:Mysqlx.Expect.Close)
632 }
633 
634 void Close::SharedCtor() {
635   _cached_size_ = 0;
636   ::memset(_has_bits_, 0, sizeof(_has_bits_));
637 }
638 
639 Close::~Close() {
640   // @@protoc_insertion_point(destructor:Mysqlx.Expect.Close)
641   SharedDtor();
642 }
643 
644 void Close::SharedDtor() {
645   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
646   if (this != &default_instance()) {
647   #else
648   if (this != default_instance_) {
649   #endif
650   }
651 }
652 
653 void Close::SetCachedSize(int size) const {
654   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
655   _cached_size_ = size;
656   GOOGLE_SAFE_CONCURRENT_WRITES_END();
657 }
658 const Close& Close::default_instance() {
659 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
660   protobuf_AddDesc_mysqlx_5fexpect_2eproto();
661 #else
662   if (default_instance_ == NULL) protobuf_AddDesc_mysqlx_5fexpect_2eproto();
663 #endif
664   return *default_instance_;
665 }
666 
667 Close* Close::default_instance_ = NULL;
668 
669 Close* Close::New() const {
670   return new Close;
671 }
672 
673 void Close::Clear() {
674   ::memset(_has_bits_, 0, sizeof(_has_bits_));
675   mutable_unknown_fields()->clear();
676 }
677 
678 bool Close::MergePartialFromCodedStream(
679     ::google::protobuf::io::CodedInputStream* input) {
680 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
681   ::google::protobuf::uint32 tag;
682   ::google::protobuf::io::StringOutputStream unknown_fields_string(
683       mutable_unknown_fields());
684   ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
685       &unknown_fields_string);
686   // @@protoc_insertion_point(parse_start:Mysqlx.Expect.Close)
687   for (;;) {
688     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
689     tag = p.first;
690     if (!p.second) goto handle_unusual;
691   handle_unusual:
692     if (tag == 0 ||
693         ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
694         ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
695       goto success;
696     }
697     DO_(::google::protobuf::internal::WireFormatLite::SkipField(
698         input, tag, &unknown_fields_stream));
699   }
700 success:
701   // @@protoc_insertion_point(parse_success:Mysqlx.Expect.Close)
702   return true;
703 failure:
704   // @@protoc_insertion_point(parse_failure:Mysqlx.Expect.Close)
705   return false;
706 #undef DO_
707 }
708 
709 void Close::SerializeWithCachedSizes(
710     ::google::protobuf::io::CodedOutputStream* output) const {
711   // @@protoc_insertion_point(serialize_start:Mysqlx.Expect.Close)
712   output->WriteRaw(unknown_fields().data(),
713                    unknown_fields().size());
714   // @@protoc_insertion_point(serialize_end:Mysqlx.Expect.Close)
715 }
716 
717 int Close::ByteSize() const {
718   int total_size = 0;
719 
720   total_size += unknown_fields().size();
721 
722   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
723   _cached_size_ = total_size;
724   GOOGLE_SAFE_CONCURRENT_WRITES_END();
725   return total_size;
726 }
727 
728 void Close::CheckTypeAndMergeFrom(
729     const ::google::protobuf::MessageLite& from) {
730   MergeFrom(*::google::protobuf::down_cast<const Close*>(&from));
731 }
732 
733 void Close::MergeFrom(const Close& from) {
734   GOOGLE_CHECK_NE(&from, this);
735   mutable_unknown_fields()->append(from.unknown_fields());
736 }
737 
738 void Close::CopyFrom(const Close& from) {
739   if (&from == this) return;
740   Clear();
741   MergeFrom(from);
742 }
743 
744 bool Close::IsInitialized() const {
745 
746   return true;
747 }
748 
749 void Close::Swap(Close* other) {
750   if (other != this) {
751     _unknown_fields_.swap(other->_unknown_fields_);
752     std::swap(_cached_size_, other->_cached_size_);
753   }
754 }
755 
756 ::std::string Close::GetTypeName() const {
757   return "Mysqlx.Expect.Close";
758 }
759 
760 
761 // @@protoc_insertion_point(namespace_scope)
762 
763 }  // namespace Expect
764 }  // namespace Mysqlx
765 
766 // @@protoc_insertion_point(global_scope)
767