1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: mysqlx_expr.proto
3
4 #ifndef PROTOBUF_mysqlx_5fexpr_2eproto__INCLUDED
5 #define PROTOBUF_mysqlx_5fexpr_2eproto__INCLUDED
6
7 #include <string>
8
9 #include <google/protobuf/stubs/common.h>
10
11 #if GOOGLE_PROTOBUF_VERSION < 2006000
12 #error This file was generated by a newer version of protoc which is
13 #error incompatible with your Protocol Buffer headers. Please update
14 #error your headers.
15 #endif
16 #if 2006000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17 #error This file was generated by an older version of protoc which is
18 #error incompatible with your Protocol Buffer headers. Please
19 #error regenerate this file with a newer version of protoc.
20 #endif
21
22 #include <google/protobuf/generated_message_util.h>
23 #include <google/protobuf/message_lite.h>
24 #include <google/protobuf/repeated_field.h>
25 #include <google/protobuf/extension_set.h>
26 #include "mysqlx_datatypes.pb.h"
27 // @@protoc_insertion_point(includes)
28
29 namespace Mysqlx {
30 namespace Expr {
31
32 // Internal implementation detail -- do not call these.
33 void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
34 void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
35 void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
36
37 class Expr;
38 class Identifier;
39 class DocumentPathItem;
40 class ColumnIdentifier;
41 class FunctionCall;
42 class Operator;
43 class Object;
44 class Object_ObjectField;
45 class Array;
46
47 enum Expr_Type {
48 Expr_Type_IDENT = 1,
49 Expr_Type_LITERAL = 2,
50 Expr_Type_VARIABLE = 3,
51 Expr_Type_FUNC_CALL = 4,
52 Expr_Type_OPERATOR = 5,
53 Expr_Type_PLACEHOLDER = 6,
54 Expr_Type_OBJECT = 7,
55 Expr_Type_ARRAY = 8
56 };
57 bool Expr_Type_IsValid(int value);
58 const Expr_Type Expr_Type_Type_MIN = Expr_Type_IDENT;
59 const Expr_Type Expr_Type_Type_MAX = Expr_Type_ARRAY;
60 const int Expr_Type_Type_ARRAYSIZE = Expr_Type_Type_MAX + 1;
61
62 enum DocumentPathItem_Type {
63 DocumentPathItem_Type_MEMBER = 1,
64 DocumentPathItem_Type_MEMBER_ASTERISK = 2,
65 DocumentPathItem_Type_ARRAY_INDEX = 3,
66 DocumentPathItem_Type_ARRAY_INDEX_ASTERISK = 4,
67 DocumentPathItem_Type_DOUBLE_ASTERISK = 5
68 };
69 bool DocumentPathItem_Type_IsValid(int value);
70 const DocumentPathItem_Type DocumentPathItem_Type_Type_MIN = DocumentPathItem_Type_MEMBER;
71 const DocumentPathItem_Type DocumentPathItem_Type_Type_MAX = DocumentPathItem_Type_DOUBLE_ASTERISK;
72 const int DocumentPathItem_Type_Type_ARRAYSIZE = DocumentPathItem_Type_Type_MAX + 1;
73
74 // ===================================================================
75
76 class Expr : public ::google::protobuf::MessageLite {
77 public:
78 Expr();
79 virtual ~Expr();
80
81 Expr(const Expr& from);
82
83 inline Expr& operator=(const Expr& from) {
84 CopyFrom(from);
85 return *this;
86 }
87
unknown_fields()88 inline const ::std::string& unknown_fields() const {
89 return _unknown_fields_;
90 }
91
mutable_unknown_fields()92 inline ::std::string* mutable_unknown_fields() {
93 return &_unknown_fields_;
94 }
95
96 static const Expr& default_instance();
97
98 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
99 // Returns the internal default instance pointer. This function can
100 // return NULL thus should not be used by the user. This is intended
101 // for Protobuf internal code. Please use default_instance() declared
102 // above instead.
internal_default_instance()103 static inline const Expr* internal_default_instance() {
104 return default_instance_;
105 }
106 #endif
107
108 void Swap(Expr* other);
109
110 // implements Message ----------------------------------------------
111
112 Expr* New() const;
113 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
114 void CopyFrom(const Expr& from);
115 void MergeFrom(const Expr& from);
116 void Clear();
117 bool IsInitialized() const;
118
119 int ByteSize() const;
120 bool MergePartialFromCodedStream(
121 ::google::protobuf::io::CodedInputStream* input);
122 void SerializeWithCachedSizes(
123 ::google::protobuf::io::CodedOutputStream* output) const;
124 void DiscardUnknownFields();
GetCachedSize()125 int GetCachedSize() const { return _cached_size_; }
126 private:
127 void SharedCtor();
128 void SharedDtor();
129 void SetCachedSize(int size) const;
130 public:
131 ::std::string GetTypeName() const;
132
133 // nested types ----------------------------------------------------
134
135 typedef Expr_Type Type;
136 static const Type IDENT = Expr_Type_IDENT;
137 static const Type LITERAL = Expr_Type_LITERAL;
138 static const Type VARIABLE = Expr_Type_VARIABLE;
139 static const Type FUNC_CALL = Expr_Type_FUNC_CALL;
140 static const Type OPERATOR = Expr_Type_OPERATOR;
141 static const Type PLACEHOLDER = Expr_Type_PLACEHOLDER;
142 static const Type OBJECT = Expr_Type_OBJECT;
143 static const Type ARRAY = Expr_Type_ARRAY;
Type_IsValid(int value)144 static inline bool Type_IsValid(int value) {
145 return Expr_Type_IsValid(value);
146 }
147 static const Type Type_MIN =
148 Expr_Type_Type_MIN;
149 static const Type Type_MAX =
150 Expr_Type_Type_MAX;
151 static const int Type_ARRAYSIZE =
152 Expr_Type_Type_ARRAYSIZE;
153
154 // accessors -------------------------------------------------------
155
156 // required .Mysqlx.Expr.Expr.Type type = 1;
157 inline bool has_type() const;
158 inline void clear_type();
159 static const int kTypeFieldNumber = 1;
160 inline ::Mysqlx::Expr::Expr_Type type() const;
161 inline void set_type(::Mysqlx::Expr::Expr_Type value);
162
163 // optional .Mysqlx.Expr.ColumnIdentifier identifier = 2;
164 inline bool has_identifier() const;
165 inline void clear_identifier();
166 static const int kIdentifierFieldNumber = 2;
167 inline const ::Mysqlx::Expr::ColumnIdentifier& identifier() const;
168 inline ::Mysqlx::Expr::ColumnIdentifier* mutable_identifier();
169 inline ::Mysqlx::Expr::ColumnIdentifier* release_identifier();
170 inline void set_allocated_identifier(::Mysqlx::Expr::ColumnIdentifier* identifier);
171
172 // optional string variable = 3;
173 inline bool has_variable() const;
174 inline void clear_variable();
175 static const int kVariableFieldNumber = 3;
176 inline const ::std::string& variable() const;
177 inline void set_variable(const ::std::string& value);
178 inline void set_variable(const char* value);
179 inline void set_variable(const char* value, size_t size);
180 inline ::std::string* mutable_variable();
181 inline ::std::string* release_variable();
182 inline void set_allocated_variable(::std::string* variable);
183
184 // optional .Mysqlx.Datatypes.Scalar literal = 4;
185 inline bool has_literal() const;
186 inline void clear_literal();
187 static const int kLiteralFieldNumber = 4;
188 inline const ::Mysqlx::Datatypes::Scalar& literal() const;
189 inline ::Mysqlx::Datatypes::Scalar* mutable_literal();
190 inline ::Mysqlx::Datatypes::Scalar* release_literal();
191 inline void set_allocated_literal(::Mysqlx::Datatypes::Scalar* literal);
192
193 // optional .Mysqlx.Expr.FunctionCall function_call = 5;
194 inline bool has_function_call() const;
195 inline void clear_function_call();
196 static const int kFunctionCallFieldNumber = 5;
197 inline const ::Mysqlx::Expr::FunctionCall& function_call() const;
198 inline ::Mysqlx::Expr::FunctionCall* mutable_function_call();
199 inline ::Mysqlx::Expr::FunctionCall* release_function_call();
200 inline void set_allocated_function_call(::Mysqlx::Expr::FunctionCall* function_call);
201
202 // optional .Mysqlx.Expr.Operator operator = 6;
203 inline bool has_operator_() const;
204 inline void clear_operator_();
205 static const int kOperatorFieldNumber = 6;
206 inline const ::Mysqlx::Expr::Operator& operator_() const;
207 inline ::Mysqlx::Expr::Operator* mutable_operator_();
208 inline ::Mysqlx::Expr::Operator* release_operator_();
209 inline void set_allocated_operator_(::Mysqlx::Expr::Operator* operator_);
210
211 // optional uint32 position = 7;
212 inline bool has_position() const;
213 inline void clear_position();
214 static const int kPositionFieldNumber = 7;
215 inline ::google::protobuf::uint32 position() const;
216 inline void set_position(::google::protobuf::uint32 value);
217
218 // optional .Mysqlx.Expr.Object object = 8;
219 inline bool has_object() const;
220 inline void clear_object();
221 static const int kObjectFieldNumber = 8;
222 inline const ::Mysqlx::Expr::Object& object() const;
223 inline ::Mysqlx::Expr::Object* mutable_object();
224 inline ::Mysqlx::Expr::Object* release_object();
225 inline void set_allocated_object(::Mysqlx::Expr::Object* object);
226
227 // optional .Mysqlx.Expr.Array array = 9;
228 inline bool has_array() const;
229 inline void clear_array();
230 static const int kArrayFieldNumber = 9;
231 inline const ::Mysqlx::Expr::Array& array() const;
232 inline ::Mysqlx::Expr::Array* mutable_array();
233 inline ::Mysqlx::Expr::Array* release_array();
234 inline void set_allocated_array(::Mysqlx::Expr::Array* array);
235
236 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Expr)
237 private:
238 inline void set_has_type();
239 inline void clear_has_type();
240 inline void set_has_identifier();
241 inline void clear_has_identifier();
242 inline void set_has_variable();
243 inline void clear_has_variable();
244 inline void set_has_literal();
245 inline void clear_has_literal();
246 inline void set_has_function_call();
247 inline void clear_has_function_call();
248 inline void set_has_operator_();
249 inline void clear_has_operator_();
250 inline void set_has_position();
251 inline void clear_has_position();
252 inline void set_has_object();
253 inline void clear_has_object();
254 inline void set_has_array();
255 inline void clear_has_array();
256
257 ::std::string _unknown_fields_;
258
259 ::google::protobuf::uint32 _has_bits_[1];
260 mutable int _cached_size_;
261 ::Mysqlx::Expr::ColumnIdentifier* identifier_;
262 ::std::string* variable_;
263 ::Mysqlx::Datatypes::Scalar* literal_;
264 int type_;
265 ::google::protobuf::uint32 position_;
266 ::Mysqlx::Expr::FunctionCall* function_call_;
267 ::Mysqlx::Expr::Operator* operator__;
268 ::Mysqlx::Expr::Object* object_;
269 ::Mysqlx::Expr::Array* array_;
270 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
271 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
272 #else
273 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
274 #endif
275 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
276 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
277
278 void InitAsDefaultInstance();
279 static Expr* default_instance_;
280 };
281 // -------------------------------------------------------------------
282
283 class Identifier : public ::google::protobuf::MessageLite {
284 public:
285 Identifier();
286 virtual ~Identifier();
287
288 Identifier(const Identifier& from);
289
290 inline Identifier& operator=(const Identifier& from) {
291 CopyFrom(from);
292 return *this;
293 }
294
unknown_fields()295 inline const ::std::string& unknown_fields() const {
296 return _unknown_fields_;
297 }
298
mutable_unknown_fields()299 inline ::std::string* mutable_unknown_fields() {
300 return &_unknown_fields_;
301 }
302
303 static const Identifier& default_instance();
304
305 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
306 // Returns the internal default instance pointer. This function can
307 // return NULL thus should not be used by the user. This is intended
308 // for Protobuf internal code. Please use default_instance() declared
309 // above instead.
internal_default_instance()310 static inline const Identifier* internal_default_instance() {
311 return default_instance_;
312 }
313 #endif
314
315 void Swap(Identifier* other);
316
317 // implements Message ----------------------------------------------
318
319 Identifier* New() const;
320 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
321 void CopyFrom(const Identifier& from);
322 void MergeFrom(const Identifier& from);
323 void Clear();
324 bool IsInitialized() const;
325
326 int ByteSize() const;
327 bool MergePartialFromCodedStream(
328 ::google::protobuf::io::CodedInputStream* input);
329 void SerializeWithCachedSizes(
330 ::google::protobuf::io::CodedOutputStream* output) const;
331 void DiscardUnknownFields();
GetCachedSize()332 int GetCachedSize() const { return _cached_size_; }
333 private:
334 void SharedCtor();
335 void SharedDtor();
336 void SetCachedSize(int size) const;
337 public:
338 ::std::string GetTypeName() const;
339
340 // nested types ----------------------------------------------------
341
342 // accessors -------------------------------------------------------
343
344 // required string name = 1;
345 inline bool has_name() const;
346 inline void clear_name();
347 static const int kNameFieldNumber = 1;
348 inline const ::std::string& name() const;
349 inline void set_name(const ::std::string& value);
350 inline void set_name(const char* value);
351 inline void set_name(const char* value, size_t size);
352 inline ::std::string* mutable_name();
353 inline ::std::string* release_name();
354 inline void set_allocated_name(::std::string* name);
355
356 // optional string schema_name = 2;
357 inline bool has_schema_name() const;
358 inline void clear_schema_name();
359 static const int kSchemaNameFieldNumber = 2;
360 inline const ::std::string& schema_name() const;
361 inline void set_schema_name(const ::std::string& value);
362 inline void set_schema_name(const char* value);
363 inline void set_schema_name(const char* value, size_t size);
364 inline ::std::string* mutable_schema_name();
365 inline ::std::string* release_schema_name();
366 inline void set_allocated_schema_name(::std::string* schema_name);
367
368 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Identifier)
369 private:
370 inline void set_has_name();
371 inline void clear_has_name();
372 inline void set_has_schema_name();
373 inline void clear_has_schema_name();
374
375 ::std::string _unknown_fields_;
376
377 ::google::protobuf::uint32 _has_bits_[1];
378 mutable int _cached_size_;
379 ::std::string* name_;
380 ::std::string* schema_name_;
381 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
382 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
383 #else
384 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
385 #endif
386 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
387 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
388
389 void InitAsDefaultInstance();
390 static Identifier* default_instance_;
391 };
392 // -------------------------------------------------------------------
393
394 class DocumentPathItem : public ::google::protobuf::MessageLite {
395 public:
396 DocumentPathItem();
397 virtual ~DocumentPathItem();
398
399 DocumentPathItem(const DocumentPathItem& from);
400
401 inline DocumentPathItem& operator=(const DocumentPathItem& from) {
402 CopyFrom(from);
403 return *this;
404 }
405
unknown_fields()406 inline const ::std::string& unknown_fields() const {
407 return _unknown_fields_;
408 }
409
mutable_unknown_fields()410 inline ::std::string* mutable_unknown_fields() {
411 return &_unknown_fields_;
412 }
413
414 static const DocumentPathItem& default_instance();
415
416 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
417 // Returns the internal default instance pointer. This function can
418 // return NULL thus should not be used by the user. This is intended
419 // for Protobuf internal code. Please use default_instance() declared
420 // above instead.
internal_default_instance()421 static inline const DocumentPathItem* internal_default_instance() {
422 return default_instance_;
423 }
424 #endif
425
426 void Swap(DocumentPathItem* other);
427
428 // implements Message ----------------------------------------------
429
430 DocumentPathItem* New() const;
431 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
432 void CopyFrom(const DocumentPathItem& from);
433 void MergeFrom(const DocumentPathItem& from);
434 void Clear();
435 bool IsInitialized() const;
436
437 int ByteSize() const;
438 bool MergePartialFromCodedStream(
439 ::google::protobuf::io::CodedInputStream* input);
440 void SerializeWithCachedSizes(
441 ::google::protobuf::io::CodedOutputStream* output) const;
442 void DiscardUnknownFields();
GetCachedSize()443 int GetCachedSize() const { return _cached_size_; }
444 private:
445 void SharedCtor();
446 void SharedDtor();
447 void SetCachedSize(int size) const;
448 public:
449 ::std::string GetTypeName() const;
450
451 // nested types ----------------------------------------------------
452
453 typedef DocumentPathItem_Type Type;
454 static const Type MEMBER = DocumentPathItem_Type_MEMBER;
455 static const Type MEMBER_ASTERISK = DocumentPathItem_Type_MEMBER_ASTERISK;
456 static const Type ARRAY_INDEX = DocumentPathItem_Type_ARRAY_INDEX;
457 static const Type ARRAY_INDEX_ASTERISK = DocumentPathItem_Type_ARRAY_INDEX_ASTERISK;
458 static const Type DOUBLE_ASTERISK = DocumentPathItem_Type_DOUBLE_ASTERISK;
Type_IsValid(int value)459 static inline bool Type_IsValid(int value) {
460 return DocumentPathItem_Type_IsValid(value);
461 }
462 static const Type Type_MIN =
463 DocumentPathItem_Type_Type_MIN;
464 static const Type Type_MAX =
465 DocumentPathItem_Type_Type_MAX;
466 static const int Type_ARRAYSIZE =
467 DocumentPathItem_Type_Type_ARRAYSIZE;
468
469 // accessors -------------------------------------------------------
470
471 // required .Mysqlx.Expr.DocumentPathItem.Type type = 1;
472 inline bool has_type() const;
473 inline void clear_type();
474 static const int kTypeFieldNumber = 1;
475 inline ::Mysqlx::Expr::DocumentPathItem_Type type() const;
476 inline void set_type(::Mysqlx::Expr::DocumentPathItem_Type value);
477
478 // optional string value = 2;
479 inline bool has_value() const;
480 inline void clear_value();
481 static const int kValueFieldNumber = 2;
482 inline const ::std::string& value() const;
483 inline void set_value(const ::std::string& value);
484 inline void set_value(const char* value);
485 inline void set_value(const char* value, size_t size);
486 inline ::std::string* mutable_value();
487 inline ::std::string* release_value();
488 inline void set_allocated_value(::std::string* value);
489
490 // optional uint32 index = 3;
491 inline bool has_index() const;
492 inline void clear_index();
493 static const int kIndexFieldNumber = 3;
494 inline ::google::protobuf::uint32 index() const;
495 inline void set_index(::google::protobuf::uint32 value);
496
497 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.DocumentPathItem)
498 private:
499 inline void set_has_type();
500 inline void clear_has_type();
501 inline void set_has_value();
502 inline void clear_has_value();
503 inline void set_has_index();
504 inline void clear_has_index();
505
506 ::std::string _unknown_fields_;
507
508 ::google::protobuf::uint32 _has_bits_[1];
509 mutable int _cached_size_;
510 ::std::string* value_;
511 int type_;
512 ::google::protobuf::uint32 index_;
513 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
514 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
515 #else
516 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
517 #endif
518 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
519 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
520
521 void InitAsDefaultInstance();
522 static DocumentPathItem* default_instance_;
523 };
524 // -------------------------------------------------------------------
525
526 class ColumnIdentifier : public ::google::protobuf::MessageLite {
527 public:
528 ColumnIdentifier();
529 virtual ~ColumnIdentifier();
530
531 ColumnIdentifier(const ColumnIdentifier& from);
532
533 inline ColumnIdentifier& operator=(const ColumnIdentifier& from) {
534 CopyFrom(from);
535 return *this;
536 }
537
unknown_fields()538 inline const ::std::string& unknown_fields() const {
539 return _unknown_fields_;
540 }
541
mutable_unknown_fields()542 inline ::std::string* mutable_unknown_fields() {
543 return &_unknown_fields_;
544 }
545
546 static const ColumnIdentifier& default_instance();
547
548 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
549 // Returns the internal default instance pointer. This function can
550 // return NULL thus should not be used by the user. This is intended
551 // for Protobuf internal code. Please use default_instance() declared
552 // above instead.
internal_default_instance()553 static inline const ColumnIdentifier* internal_default_instance() {
554 return default_instance_;
555 }
556 #endif
557
558 void Swap(ColumnIdentifier* other);
559
560 // implements Message ----------------------------------------------
561
562 ColumnIdentifier* New() const;
563 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
564 void CopyFrom(const ColumnIdentifier& from);
565 void MergeFrom(const ColumnIdentifier& from);
566 void Clear();
567 bool IsInitialized() const;
568
569 int ByteSize() const;
570 bool MergePartialFromCodedStream(
571 ::google::protobuf::io::CodedInputStream* input);
572 void SerializeWithCachedSizes(
573 ::google::protobuf::io::CodedOutputStream* output) const;
574 void DiscardUnknownFields();
GetCachedSize()575 int GetCachedSize() const { return _cached_size_; }
576 private:
577 void SharedCtor();
578 void SharedDtor();
579 void SetCachedSize(int size) const;
580 public:
581 ::std::string GetTypeName() const;
582
583 // nested types ----------------------------------------------------
584
585 // accessors -------------------------------------------------------
586
587 // repeated .Mysqlx.Expr.DocumentPathItem document_path = 1;
588 inline int document_path_size() const;
589 inline void clear_document_path();
590 static const int kDocumentPathFieldNumber = 1;
591 inline const ::Mysqlx::Expr::DocumentPathItem& document_path(int index) const;
592 inline ::Mysqlx::Expr::DocumentPathItem* mutable_document_path(int index);
593 inline ::Mysqlx::Expr::DocumentPathItem* add_document_path();
594 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::DocumentPathItem >&
595 document_path() const;
596 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::DocumentPathItem >*
597 mutable_document_path();
598
599 // optional string name = 2;
600 inline bool has_name() const;
601 inline void clear_name();
602 static const int kNameFieldNumber = 2;
603 inline const ::std::string& name() const;
604 inline void set_name(const ::std::string& value);
605 inline void set_name(const char* value);
606 inline void set_name(const char* value, size_t size);
607 inline ::std::string* mutable_name();
608 inline ::std::string* release_name();
609 inline void set_allocated_name(::std::string* name);
610
611 // optional string table_name = 3;
612 inline bool has_table_name() const;
613 inline void clear_table_name();
614 static const int kTableNameFieldNumber = 3;
615 inline const ::std::string& table_name() const;
616 inline void set_table_name(const ::std::string& value);
617 inline void set_table_name(const char* value);
618 inline void set_table_name(const char* value, size_t size);
619 inline ::std::string* mutable_table_name();
620 inline ::std::string* release_table_name();
621 inline void set_allocated_table_name(::std::string* table_name);
622
623 // optional string schema_name = 4;
624 inline bool has_schema_name() const;
625 inline void clear_schema_name();
626 static const int kSchemaNameFieldNumber = 4;
627 inline const ::std::string& schema_name() const;
628 inline void set_schema_name(const ::std::string& value);
629 inline void set_schema_name(const char* value);
630 inline void set_schema_name(const char* value, size_t size);
631 inline ::std::string* mutable_schema_name();
632 inline ::std::string* release_schema_name();
633 inline void set_allocated_schema_name(::std::string* schema_name);
634
635 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.ColumnIdentifier)
636 private:
637 inline void set_has_name();
638 inline void clear_has_name();
639 inline void set_has_table_name();
640 inline void clear_has_table_name();
641 inline void set_has_schema_name();
642 inline void clear_has_schema_name();
643
644 ::std::string _unknown_fields_;
645
646 ::google::protobuf::uint32 _has_bits_[1];
647 mutable int _cached_size_;
648 ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::DocumentPathItem > document_path_;
649 ::std::string* name_;
650 ::std::string* table_name_;
651 ::std::string* schema_name_;
652 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
653 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
654 #else
655 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
656 #endif
657 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
658 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
659
660 void InitAsDefaultInstance();
661 static ColumnIdentifier* default_instance_;
662 };
663 // -------------------------------------------------------------------
664
665 class FunctionCall : public ::google::protobuf::MessageLite {
666 public:
667 FunctionCall();
668 virtual ~FunctionCall();
669
670 FunctionCall(const FunctionCall& from);
671
672 inline FunctionCall& operator=(const FunctionCall& from) {
673 CopyFrom(from);
674 return *this;
675 }
676
unknown_fields()677 inline const ::std::string& unknown_fields() const {
678 return _unknown_fields_;
679 }
680
mutable_unknown_fields()681 inline ::std::string* mutable_unknown_fields() {
682 return &_unknown_fields_;
683 }
684
685 static const FunctionCall& default_instance();
686
687 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
688 // Returns the internal default instance pointer. This function can
689 // return NULL thus should not be used by the user. This is intended
690 // for Protobuf internal code. Please use default_instance() declared
691 // above instead.
internal_default_instance()692 static inline const FunctionCall* internal_default_instance() {
693 return default_instance_;
694 }
695 #endif
696
697 void Swap(FunctionCall* other);
698
699 // implements Message ----------------------------------------------
700
701 FunctionCall* New() const;
702 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
703 void CopyFrom(const FunctionCall& from);
704 void MergeFrom(const FunctionCall& from);
705 void Clear();
706 bool IsInitialized() const;
707
708 int ByteSize() const;
709 bool MergePartialFromCodedStream(
710 ::google::protobuf::io::CodedInputStream* input);
711 void SerializeWithCachedSizes(
712 ::google::protobuf::io::CodedOutputStream* output) const;
713 void DiscardUnknownFields();
GetCachedSize()714 int GetCachedSize() const { return _cached_size_; }
715 private:
716 void SharedCtor();
717 void SharedDtor();
718 void SetCachedSize(int size) const;
719 public:
720 ::std::string GetTypeName() const;
721
722 // nested types ----------------------------------------------------
723
724 // accessors -------------------------------------------------------
725
726 // required .Mysqlx.Expr.Identifier name = 1;
727 inline bool has_name() const;
728 inline void clear_name();
729 static const int kNameFieldNumber = 1;
730 inline const ::Mysqlx::Expr::Identifier& name() const;
731 inline ::Mysqlx::Expr::Identifier* mutable_name();
732 inline ::Mysqlx::Expr::Identifier* release_name();
733 inline void set_allocated_name(::Mysqlx::Expr::Identifier* name);
734
735 // repeated .Mysqlx.Expr.Expr param = 2;
736 inline int param_size() const;
737 inline void clear_param();
738 static const int kParamFieldNumber = 2;
739 inline const ::Mysqlx::Expr::Expr& param(int index) const;
740 inline ::Mysqlx::Expr::Expr* mutable_param(int index);
741 inline ::Mysqlx::Expr::Expr* add_param();
742 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >&
743 param() const;
744 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >*
745 mutable_param();
746
747 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.FunctionCall)
748 private:
749 inline void set_has_name();
750 inline void clear_has_name();
751
752 ::std::string _unknown_fields_;
753
754 ::google::protobuf::uint32 _has_bits_[1];
755 mutable int _cached_size_;
756 ::Mysqlx::Expr::Identifier* name_;
757 ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr > param_;
758 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
759 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
760 #else
761 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
762 #endif
763 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
764 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
765
766 void InitAsDefaultInstance();
767 static FunctionCall* default_instance_;
768 };
769 // -------------------------------------------------------------------
770
771 class Operator : public ::google::protobuf::MessageLite {
772 public:
773 Operator();
774 virtual ~Operator();
775
776 Operator(const Operator& from);
777
778 inline Operator& operator=(const Operator& from) {
779 CopyFrom(from);
780 return *this;
781 }
782
unknown_fields()783 inline const ::std::string& unknown_fields() const {
784 return _unknown_fields_;
785 }
786
mutable_unknown_fields()787 inline ::std::string* mutable_unknown_fields() {
788 return &_unknown_fields_;
789 }
790
791 static const Operator& default_instance();
792
793 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
794 // Returns the internal default instance pointer. This function can
795 // return NULL thus should not be used by the user. This is intended
796 // for Protobuf internal code. Please use default_instance() declared
797 // above instead.
internal_default_instance()798 static inline const Operator* internal_default_instance() {
799 return default_instance_;
800 }
801 #endif
802
803 void Swap(Operator* other);
804
805 // implements Message ----------------------------------------------
806
807 Operator* New() const;
808 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
809 void CopyFrom(const Operator& from);
810 void MergeFrom(const Operator& from);
811 void Clear();
812 bool IsInitialized() const;
813
814 int ByteSize() const;
815 bool MergePartialFromCodedStream(
816 ::google::protobuf::io::CodedInputStream* input);
817 void SerializeWithCachedSizes(
818 ::google::protobuf::io::CodedOutputStream* output) const;
819 void DiscardUnknownFields();
GetCachedSize()820 int GetCachedSize() const { return _cached_size_; }
821 private:
822 void SharedCtor();
823 void SharedDtor();
824 void SetCachedSize(int size) const;
825 public:
826 ::std::string GetTypeName() const;
827
828 // nested types ----------------------------------------------------
829
830 // accessors -------------------------------------------------------
831
832 // required string name = 1;
833 inline bool has_name() const;
834 inline void clear_name();
835 static const int kNameFieldNumber = 1;
836 inline const ::std::string& name() const;
837 inline void set_name(const ::std::string& value);
838 inline void set_name(const char* value);
839 inline void set_name(const char* value, size_t size);
840 inline ::std::string* mutable_name();
841 inline ::std::string* release_name();
842 inline void set_allocated_name(::std::string* name);
843
844 // repeated .Mysqlx.Expr.Expr param = 2;
845 inline int param_size() const;
846 inline void clear_param();
847 static const int kParamFieldNumber = 2;
848 inline const ::Mysqlx::Expr::Expr& param(int index) const;
849 inline ::Mysqlx::Expr::Expr* mutable_param(int index);
850 inline ::Mysqlx::Expr::Expr* add_param();
851 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >&
852 param() const;
853 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >*
854 mutable_param();
855
856 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Operator)
857 private:
858 inline void set_has_name();
859 inline void clear_has_name();
860
861 ::std::string _unknown_fields_;
862
863 ::google::protobuf::uint32 _has_bits_[1];
864 mutable int _cached_size_;
865 ::std::string* name_;
866 ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr > param_;
867 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
868 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
869 #else
870 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
871 #endif
872 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
873 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
874
875 void InitAsDefaultInstance();
876 static Operator* default_instance_;
877 };
878 // -------------------------------------------------------------------
879
880 class Object_ObjectField : public ::google::protobuf::MessageLite {
881 public:
882 Object_ObjectField();
883 virtual ~Object_ObjectField();
884
885 Object_ObjectField(const Object_ObjectField& from);
886
887 inline Object_ObjectField& operator=(const Object_ObjectField& from) {
888 CopyFrom(from);
889 return *this;
890 }
891
unknown_fields()892 inline const ::std::string& unknown_fields() const {
893 return _unknown_fields_;
894 }
895
mutable_unknown_fields()896 inline ::std::string* mutable_unknown_fields() {
897 return &_unknown_fields_;
898 }
899
900 static const Object_ObjectField& default_instance();
901
902 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
903 // Returns the internal default instance pointer. This function can
904 // return NULL thus should not be used by the user. This is intended
905 // for Protobuf internal code. Please use default_instance() declared
906 // above instead.
internal_default_instance()907 static inline const Object_ObjectField* internal_default_instance() {
908 return default_instance_;
909 }
910 #endif
911
912 void Swap(Object_ObjectField* other);
913
914 // implements Message ----------------------------------------------
915
916 Object_ObjectField* New() const;
917 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
918 void CopyFrom(const Object_ObjectField& from);
919 void MergeFrom(const Object_ObjectField& from);
920 void Clear();
921 bool IsInitialized() const;
922
923 int ByteSize() const;
924 bool MergePartialFromCodedStream(
925 ::google::protobuf::io::CodedInputStream* input);
926 void SerializeWithCachedSizes(
927 ::google::protobuf::io::CodedOutputStream* output) const;
928 void DiscardUnknownFields();
GetCachedSize()929 int GetCachedSize() const { return _cached_size_; }
930 private:
931 void SharedCtor();
932 void SharedDtor();
933 void SetCachedSize(int size) const;
934 public:
935 ::std::string GetTypeName() const;
936
937 // nested types ----------------------------------------------------
938
939 // accessors -------------------------------------------------------
940
941 // required string key = 1;
942 inline bool has_key() const;
943 inline void clear_key();
944 static const int kKeyFieldNumber = 1;
945 inline const ::std::string& key() const;
946 inline void set_key(const ::std::string& value);
947 inline void set_key(const char* value);
948 inline void set_key(const char* value, size_t size);
949 inline ::std::string* mutable_key();
950 inline ::std::string* release_key();
951 inline void set_allocated_key(::std::string* key);
952
953 // required .Mysqlx.Expr.Expr value = 2;
954 inline bool has_value() const;
955 inline void clear_value();
956 static const int kValueFieldNumber = 2;
957 inline const ::Mysqlx::Expr::Expr& value() const;
958 inline ::Mysqlx::Expr::Expr* mutable_value();
959 inline ::Mysqlx::Expr::Expr* release_value();
960 inline void set_allocated_value(::Mysqlx::Expr::Expr* value);
961
962 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Object.ObjectField)
963 private:
964 inline void set_has_key();
965 inline void clear_has_key();
966 inline void set_has_value();
967 inline void clear_has_value();
968
969 ::std::string _unknown_fields_;
970
971 ::google::protobuf::uint32 _has_bits_[1];
972 mutable int _cached_size_;
973 ::std::string* key_;
974 ::Mysqlx::Expr::Expr* value_;
975 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
976 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
977 #else
978 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
979 #endif
980 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
981 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
982
983 void InitAsDefaultInstance();
984 static Object_ObjectField* default_instance_;
985 };
986 // -------------------------------------------------------------------
987
988 class Object : public ::google::protobuf::MessageLite {
989 public:
990 Object();
991 virtual ~Object();
992
993 Object(const Object& from);
994
995 inline Object& operator=(const Object& from) {
996 CopyFrom(from);
997 return *this;
998 }
999
unknown_fields()1000 inline const ::std::string& unknown_fields() const {
1001 return _unknown_fields_;
1002 }
1003
mutable_unknown_fields()1004 inline ::std::string* mutable_unknown_fields() {
1005 return &_unknown_fields_;
1006 }
1007
1008 static const Object& default_instance();
1009
1010 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1011 // Returns the internal default instance pointer. This function can
1012 // return NULL thus should not be used by the user. This is intended
1013 // for Protobuf internal code. Please use default_instance() declared
1014 // above instead.
internal_default_instance()1015 static inline const Object* internal_default_instance() {
1016 return default_instance_;
1017 }
1018 #endif
1019
1020 void Swap(Object* other);
1021
1022 // implements Message ----------------------------------------------
1023
1024 Object* New() const;
1025 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
1026 void CopyFrom(const Object& from);
1027 void MergeFrom(const Object& from);
1028 void Clear();
1029 bool IsInitialized() const;
1030
1031 int ByteSize() const;
1032 bool MergePartialFromCodedStream(
1033 ::google::protobuf::io::CodedInputStream* input);
1034 void SerializeWithCachedSizes(
1035 ::google::protobuf::io::CodedOutputStream* output) const;
1036 void DiscardUnknownFields();
GetCachedSize()1037 int GetCachedSize() const { return _cached_size_; }
1038 private:
1039 void SharedCtor();
1040 void SharedDtor();
1041 void SetCachedSize(int size) const;
1042 public:
1043 ::std::string GetTypeName() const;
1044
1045 // nested types ----------------------------------------------------
1046
1047 typedef Object_ObjectField ObjectField;
1048
1049 // accessors -------------------------------------------------------
1050
1051 // repeated .Mysqlx.Expr.Object.ObjectField fld = 1;
1052 inline int fld_size() const;
1053 inline void clear_fld();
1054 static const int kFldFieldNumber = 1;
1055 inline const ::Mysqlx::Expr::Object_ObjectField& fld(int index) const;
1056 inline ::Mysqlx::Expr::Object_ObjectField* mutable_fld(int index);
1057 inline ::Mysqlx::Expr::Object_ObjectField* add_fld();
1058 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Object_ObjectField >&
1059 fld() const;
1060 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Object_ObjectField >*
1061 mutable_fld();
1062
1063 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Object)
1064 private:
1065
1066 ::std::string _unknown_fields_;
1067
1068 ::google::protobuf::uint32 _has_bits_[1];
1069 mutable int _cached_size_;
1070 ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Object_ObjectField > fld_;
1071 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1072 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
1073 #else
1074 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
1075 #endif
1076 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
1077 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
1078
1079 void InitAsDefaultInstance();
1080 static Object* default_instance_;
1081 };
1082 // -------------------------------------------------------------------
1083
1084 class Array : public ::google::protobuf::MessageLite {
1085 public:
1086 Array();
1087 virtual ~Array();
1088
1089 Array(const Array& from);
1090
1091 inline Array& operator=(const Array& from) {
1092 CopyFrom(from);
1093 return *this;
1094 }
1095
unknown_fields()1096 inline const ::std::string& unknown_fields() const {
1097 return _unknown_fields_;
1098 }
1099
mutable_unknown_fields()1100 inline ::std::string* mutable_unknown_fields() {
1101 return &_unknown_fields_;
1102 }
1103
1104 static const Array& default_instance();
1105
1106 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1107 // Returns the internal default instance pointer. This function can
1108 // return NULL thus should not be used by the user. This is intended
1109 // for Protobuf internal code. Please use default_instance() declared
1110 // above instead.
internal_default_instance()1111 static inline const Array* internal_default_instance() {
1112 return default_instance_;
1113 }
1114 #endif
1115
1116 void Swap(Array* other);
1117
1118 // implements Message ----------------------------------------------
1119
1120 Array* New() const;
1121 void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
1122 void CopyFrom(const Array& from);
1123 void MergeFrom(const Array& from);
1124 void Clear();
1125 bool IsInitialized() const;
1126
1127 int ByteSize() const;
1128 bool MergePartialFromCodedStream(
1129 ::google::protobuf::io::CodedInputStream* input);
1130 void SerializeWithCachedSizes(
1131 ::google::protobuf::io::CodedOutputStream* output) const;
1132 void DiscardUnknownFields();
GetCachedSize()1133 int GetCachedSize() const { return _cached_size_; }
1134 private:
1135 void SharedCtor();
1136 void SharedDtor();
1137 void SetCachedSize(int size) const;
1138 public:
1139 ::std::string GetTypeName() const;
1140
1141 // nested types ----------------------------------------------------
1142
1143 // accessors -------------------------------------------------------
1144
1145 // repeated .Mysqlx.Expr.Expr value = 1;
1146 inline int value_size() const;
1147 inline void clear_value();
1148 static const int kValueFieldNumber = 1;
1149 inline const ::Mysqlx::Expr::Expr& value(int index) const;
1150 inline ::Mysqlx::Expr::Expr* mutable_value(int index);
1151 inline ::Mysqlx::Expr::Expr* add_value();
1152 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >&
1153 value() const;
1154 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >*
1155 mutable_value();
1156
1157 // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Array)
1158 private:
1159
1160 ::std::string _unknown_fields_;
1161
1162 ::google::protobuf::uint32 _has_bits_[1];
1163 mutable int _cached_size_;
1164 ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr > value_;
1165 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1166 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto_impl();
1167 #else
1168 friend void protobuf_AddDesc_mysqlx_5fexpr_2eproto();
1169 #endif
1170 friend void protobuf_AssignDesc_mysqlx_5fexpr_2eproto();
1171 friend void protobuf_ShutdownFile_mysqlx_5fexpr_2eproto();
1172
1173 void InitAsDefaultInstance();
1174 static Array* default_instance_;
1175 };
1176 // ===================================================================
1177
1178
1179 // ===================================================================
1180
1181 // Expr
1182
1183 // required .Mysqlx.Expr.Expr.Type type = 1;
has_type()1184 inline bool Expr::has_type() const {
1185 return (_has_bits_[0] & 0x00000001u) != 0;
1186 }
set_has_type()1187 inline void Expr::set_has_type() {
1188 _has_bits_[0] |= 0x00000001u;
1189 }
clear_has_type()1190 inline void Expr::clear_has_type() {
1191 _has_bits_[0] &= ~0x00000001u;
1192 }
clear_type()1193 inline void Expr::clear_type() {
1194 type_ = 1;
1195 clear_has_type();
1196 }
type()1197 inline ::Mysqlx::Expr::Expr_Type Expr::type() const {
1198 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.type)
1199 return static_cast< ::Mysqlx::Expr::Expr_Type >(type_);
1200 }
set_type(::Mysqlx::Expr::Expr_Type value)1201 inline void Expr::set_type(::Mysqlx::Expr::Expr_Type value) {
1202 assert(::Mysqlx::Expr::Expr_Type_IsValid(value));
1203 set_has_type();
1204 type_ = value;
1205 // @@protoc_insertion_point(field_set:Mysqlx.Expr.Expr.type)
1206 }
1207
1208 // optional .Mysqlx.Expr.ColumnIdentifier identifier = 2;
has_identifier()1209 inline bool Expr::has_identifier() const {
1210 return (_has_bits_[0] & 0x00000002u) != 0;
1211 }
set_has_identifier()1212 inline void Expr::set_has_identifier() {
1213 _has_bits_[0] |= 0x00000002u;
1214 }
clear_has_identifier()1215 inline void Expr::clear_has_identifier() {
1216 _has_bits_[0] &= ~0x00000002u;
1217 }
clear_identifier()1218 inline void Expr::clear_identifier() {
1219 if (identifier_ != NULL) identifier_->::Mysqlx::Expr::ColumnIdentifier::Clear();
1220 clear_has_identifier();
1221 }
identifier()1222 inline const ::Mysqlx::Expr::ColumnIdentifier& Expr::identifier() const {
1223 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.identifier)
1224 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1225 return identifier_ != NULL ? *identifier_ : *default_instance().identifier_;
1226 #else
1227 return identifier_ != NULL ? *identifier_ : *default_instance_->identifier_;
1228 #endif
1229 }
mutable_identifier()1230 inline ::Mysqlx::Expr::ColumnIdentifier* Expr::mutable_identifier() {
1231 set_has_identifier();
1232 if (identifier_ == NULL) identifier_ = new ::Mysqlx::Expr::ColumnIdentifier;
1233 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Expr.identifier)
1234 return identifier_;
1235 }
release_identifier()1236 inline ::Mysqlx::Expr::ColumnIdentifier* Expr::release_identifier() {
1237 clear_has_identifier();
1238 ::Mysqlx::Expr::ColumnIdentifier* temp = identifier_;
1239 identifier_ = NULL;
1240 return temp;
1241 }
set_allocated_identifier(::Mysqlx::Expr::ColumnIdentifier * identifier)1242 inline void Expr::set_allocated_identifier(::Mysqlx::Expr::ColumnIdentifier* identifier) {
1243 delete identifier_;
1244 identifier_ = identifier;
1245 if (identifier) {
1246 set_has_identifier();
1247 } else {
1248 clear_has_identifier();
1249 }
1250 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Expr.identifier)
1251 }
1252
1253 // optional string variable = 3;
has_variable()1254 inline bool Expr::has_variable() const {
1255 return (_has_bits_[0] & 0x00000004u) != 0;
1256 }
set_has_variable()1257 inline void Expr::set_has_variable() {
1258 _has_bits_[0] |= 0x00000004u;
1259 }
clear_has_variable()1260 inline void Expr::clear_has_variable() {
1261 _has_bits_[0] &= ~0x00000004u;
1262 }
clear_variable()1263 inline void Expr::clear_variable() {
1264 if (variable_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1265 variable_->clear();
1266 }
1267 clear_has_variable();
1268 }
variable()1269 inline const ::std::string& Expr::variable() const {
1270 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.variable)
1271 return *variable_;
1272 }
set_variable(const::std::string & value)1273 inline void Expr::set_variable(const ::std::string& value) {
1274 set_has_variable();
1275 if (variable_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1276 variable_ = new ::std::string;
1277 }
1278 variable_->assign(value);
1279 // @@protoc_insertion_point(field_set:Mysqlx.Expr.Expr.variable)
1280 }
set_variable(const char * value)1281 inline void Expr::set_variable(const char* value) {
1282 set_has_variable();
1283 if (variable_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1284 variable_ = new ::std::string;
1285 }
1286 variable_->assign(value);
1287 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.Expr.variable)
1288 }
set_variable(const char * value,size_t size)1289 inline void Expr::set_variable(const char* value, size_t size) {
1290 set_has_variable();
1291 if (variable_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1292 variable_ = new ::std::string;
1293 }
1294 variable_->assign(reinterpret_cast<const char*>(value), size);
1295 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.Expr.variable)
1296 }
mutable_variable()1297 inline ::std::string* Expr::mutable_variable() {
1298 set_has_variable();
1299 if (variable_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1300 variable_ = new ::std::string;
1301 }
1302 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Expr.variable)
1303 return variable_;
1304 }
release_variable()1305 inline ::std::string* Expr::release_variable() {
1306 clear_has_variable();
1307 if (variable_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1308 return NULL;
1309 } else {
1310 ::std::string* temp = variable_;
1311 variable_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1312 return temp;
1313 }
1314 }
set_allocated_variable(::std::string * variable)1315 inline void Expr::set_allocated_variable(::std::string* variable) {
1316 if (variable_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1317 delete variable_;
1318 }
1319 if (variable) {
1320 set_has_variable();
1321 variable_ = variable;
1322 } else {
1323 clear_has_variable();
1324 variable_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1325 }
1326 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Expr.variable)
1327 }
1328
1329 // optional .Mysqlx.Datatypes.Scalar literal = 4;
has_literal()1330 inline bool Expr::has_literal() const {
1331 return (_has_bits_[0] & 0x00000008u) != 0;
1332 }
set_has_literal()1333 inline void Expr::set_has_literal() {
1334 _has_bits_[0] |= 0x00000008u;
1335 }
clear_has_literal()1336 inline void Expr::clear_has_literal() {
1337 _has_bits_[0] &= ~0x00000008u;
1338 }
clear_literal()1339 inline void Expr::clear_literal() {
1340 if (literal_ != NULL) literal_->::Mysqlx::Datatypes::Scalar::Clear();
1341 clear_has_literal();
1342 }
literal()1343 inline const ::Mysqlx::Datatypes::Scalar& Expr::literal() const {
1344 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.literal)
1345 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1346 return literal_ != NULL ? *literal_ : *default_instance().literal_;
1347 #else
1348 return literal_ != NULL ? *literal_ : *default_instance_->literal_;
1349 #endif
1350 }
mutable_literal()1351 inline ::Mysqlx::Datatypes::Scalar* Expr::mutable_literal() {
1352 set_has_literal();
1353 if (literal_ == NULL) literal_ = new ::Mysqlx::Datatypes::Scalar;
1354 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Expr.literal)
1355 return literal_;
1356 }
release_literal()1357 inline ::Mysqlx::Datatypes::Scalar* Expr::release_literal() {
1358 clear_has_literal();
1359 ::Mysqlx::Datatypes::Scalar* temp = literal_;
1360 literal_ = NULL;
1361 return temp;
1362 }
set_allocated_literal(::Mysqlx::Datatypes::Scalar * literal)1363 inline void Expr::set_allocated_literal(::Mysqlx::Datatypes::Scalar* literal) {
1364 delete literal_;
1365 literal_ = literal;
1366 if (literal) {
1367 set_has_literal();
1368 } else {
1369 clear_has_literal();
1370 }
1371 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Expr.literal)
1372 }
1373
1374 // optional .Mysqlx.Expr.FunctionCall function_call = 5;
has_function_call()1375 inline bool Expr::has_function_call() const {
1376 return (_has_bits_[0] & 0x00000010u) != 0;
1377 }
set_has_function_call()1378 inline void Expr::set_has_function_call() {
1379 _has_bits_[0] |= 0x00000010u;
1380 }
clear_has_function_call()1381 inline void Expr::clear_has_function_call() {
1382 _has_bits_[0] &= ~0x00000010u;
1383 }
clear_function_call()1384 inline void Expr::clear_function_call() {
1385 if (function_call_ != NULL) function_call_->::Mysqlx::Expr::FunctionCall::Clear();
1386 clear_has_function_call();
1387 }
function_call()1388 inline const ::Mysqlx::Expr::FunctionCall& Expr::function_call() const {
1389 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.function_call)
1390 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1391 return function_call_ != NULL ? *function_call_ : *default_instance().function_call_;
1392 #else
1393 return function_call_ != NULL ? *function_call_ : *default_instance_->function_call_;
1394 #endif
1395 }
mutable_function_call()1396 inline ::Mysqlx::Expr::FunctionCall* Expr::mutable_function_call() {
1397 set_has_function_call();
1398 if (function_call_ == NULL) function_call_ = new ::Mysqlx::Expr::FunctionCall;
1399 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Expr.function_call)
1400 return function_call_;
1401 }
release_function_call()1402 inline ::Mysqlx::Expr::FunctionCall* Expr::release_function_call() {
1403 clear_has_function_call();
1404 ::Mysqlx::Expr::FunctionCall* temp = function_call_;
1405 function_call_ = NULL;
1406 return temp;
1407 }
set_allocated_function_call(::Mysqlx::Expr::FunctionCall * function_call)1408 inline void Expr::set_allocated_function_call(::Mysqlx::Expr::FunctionCall* function_call) {
1409 delete function_call_;
1410 function_call_ = function_call;
1411 if (function_call) {
1412 set_has_function_call();
1413 } else {
1414 clear_has_function_call();
1415 }
1416 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Expr.function_call)
1417 }
1418
1419 // optional .Mysqlx.Expr.Operator operator = 6;
has_operator_()1420 inline bool Expr::has_operator_() const {
1421 return (_has_bits_[0] & 0x00000020u) != 0;
1422 }
set_has_operator_()1423 inline void Expr::set_has_operator_() {
1424 _has_bits_[0] |= 0x00000020u;
1425 }
clear_has_operator_()1426 inline void Expr::clear_has_operator_() {
1427 _has_bits_[0] &= ~0x00000020u;
1428 }
clear_operator_()1429 inline void Expr::clear_operator_() {
1430 if (operator__ != NULL) operator__->::Mysqlx::Expr::Operator::Clear();
1431 clear_has_operator_();
1432 }
operator_()1433 inline const ::Mysqlx::Expr::Operator& Expr::operator_() const {
1434 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.operator)
1435 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1436 return operator__ != NULL ? *operator__ : *default_instance().operator__;
1437 #else
1438 return operator__ != NULL ? *operator__ : *default_instance_->operator__;
1439 #endif
1440 }
mutable_operator_()1441 inline ::Mysqlx::Expr::Operator* Expr::mutable_operator_() {
1442 set_has_operator_();
1443 if (operator__ == NULL) operator__ = new ::Mysqlx::Expr::Operator;
1444 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Expr.operator)
1445 return operator__;
1446 }
release_operator_()1447 inline ::Mysqlx::Expr::Operator* Expr::release_operator_() {
1448 clear_has_operator_();
1449 ::Mysqlx::Expr::Operator* temp = operator__;
1450 operator__ = NULL;
1451 return temp;
1452 }
set_allocated_operator_(::Mysqlx::Expr::Operator * operator_)1453 inline void Expr::set_allocated_operator_(::Mysqlx::Expr::Operator* operator_) {
1454 delete operator__;
1455 operator__ = operator_;
1456 if (operator_) {
1457 set_has_operator_();
1458 } else {
1459 clear_has_operator_();
1460 }
1461 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Expr.operator)
1462 }
1463
1464 // optional uint32 position = 7;
has_position()1465 inline bool Expr::has_position() const {
1466 return (_has_bits_[0] & 0x00000040u) != 0;
1467 }
set_has_position()1468 inline void Expr::set_has_position() {
1469 _has_bits_[0] |= 0x00000040u;
1470 }
clear_has_position()1471 inline void Expr::clear_has_position() {
1472 _has_bits_[0] &= ~0x00000040u;
1473 }
clear_position()1474 inline void Expr::clear_position() {
1475 position_ = 0u;
1476 clear_has_position();
1477 }
position()1478 inline ::google::protobuf::uint32 Expr::position() const {
1479 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.position)
1480 return position_;
1481 }
set_position(::google::protobuf::uint32 value)1482 inline void Expr::set_position(::google::protobuf::uint32 value) {
1483 set_has_position();
1484 position_ = value;
1485 // @@protoc_insertion_point(field_set:Mysqlx.Expr.Expr.position)
1486 }
1487
1488 // optional .Mysqlx.Expr.Object object = 8;
has_object()1489 inline bool Expr::has_object() const {
1490 return (_has_bits_[0] & 0x00000080u) != 0;
1491 }
set_has_object()1492 inline void Expr::set_has_object() {
1493 _has_bits_[0] |= 0x00000080u;
1494 }
clear_has_object()1495 inline void Expr::clear_has_object() {
1496 _has_bits_[0] &= ~0x00000080u;
1497 }
clear_object()1498 inline void Expr::clear_object() {
1499 if (object_ != NULL) object_->::Mysqlx::Expr::Object::Clear();
1500 clear_has_object();
1501 }
object()1502 inline const ::Mysqlx::Expr::Object& Expr::object() const {
1503 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.object)
1504 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1505 return object_ != NULL ? *object_ : *default_instance().object_;
1506 #else
1507 return object_ != NULL ? *object_ : *default_instance_->object_;
1508 #endif
1509 }
mutable_object()1510 inline ::Mysqlx::Expr::Object* Expr::mutable_object() {
1511 set_has_object();
1512 if (object_ == NULL) object_ = new ::Mysqlx::Expr::Object;
1513 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Expr.object)
1514 return object_;
1515 }
release_object()1516 inline ::Mysqlx::Expr::Object* Expr::release_object() {
1517 clear_has_object();
1518 ::Mysqlx::Expr::Object* temp = object_;
1519 object_ = NULL;
1520 return temp;
1521 }
set_allocated_object(::Mysqlx::Expr::Object * object)1522 inline void Expr::set_allocated_object(::Mysqlx::Expr::Object* object) {
1523 delete object_;
1524 object_ = object;
1525 if (object) {
1526 set_has_object();
1527 } else {
1528 clear_has_object();
1529 }
1530 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Expr.object)
1531 }
1532
1533 // optional .Mysqlx.Expr.Array array = 9;
has_array()1534 inline bool Expr::has_array() const {
1535 return (_has_bits_[0] & 0x00000100u) != 0;
1536 }
set_has_array()1537 inline void Expr::set_has_array() {
1538 _has_bits_[0] |= 0x00000100u;
1539 }
clear_has_array()1540 inline void Expr::clear_has_array() {
1541 _has_bits_[0] &= ~0x00000100u;
1542 }
clear_array()1543 inline void Expr::clear_array() {
1544 if (array_ != NULL) array_->::Mysqlx::Expr::Array::Clear();
1545 clear_has_array();
1546 }
array()1547 inline const ::Mysqlx::Expr::Array& Expr::array() const {
1548 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Expr.array)
1549 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
1550 return array_ != NULL ? *array_ : *default_instance().array_;
1551 #else
1552 return array_ != NULL ? *array_ : *default_instance_->array_;
1553 #endif
1554 }
mutable_array()1555 inline ::Mysqlx::Expr::Array* Expr::mutable_array() {
1556 set_has_array();
1557 if (array_ == NULL) array_ = new ::Mysqlx::Expr::Array;
1558 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Expr.array)
1559 return array_;
1560 }
release_array()1561 inline ::Mysqlx::Expr::Array* Expr::release_array() {
1562 clear_has_array();
1563 ::Mysqlx::Expr::Array* temp = array_;
1564 array_ = NULL;
1565 return temp;
1566 }
set_allocated_array(::Mysqlx::Expr::Array * array)1567 inline void Expr::set_allocated_array(::Mysqlx::Expr::Array* array) {
1568 delete array_;
1569 array_ = array;
1570 if (array) {
1571 set_has_array();
1572 } else {
1573 clear_has_array();
1574 }
1575 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Expr.array)
1576 }
1577
1578 // -------------------------------------------------------------------
1579
1580 // Identifier
1581
1582 // required string name = 1;
has_name()1583 inline bool Identifier::has_name() const {
1584 return (_has_bits_[0] & 0x00000001u) != 0;
1585 }
set_has_name()1586 inline void Identifier::set_has_name() {
1587 _has_bits_[0] |= 0x00000001u;
1588 }
clear_has_name()1589 inline void Identifier::clear_has_name() {
1590 _has_bits_[0] &= ~0x00000001u;
1591 }
clear_name()1592 inline void Identifier::clear_name() {
1593 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1594 name_->clear();
1595 }
1596 clear_has_name();
1597 }
name()1598 inline const ::std::string& Identifier::name() const {
1599 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Identifier.name)
1600 return *name_;
1601 }
set_name(const::std::string & value)1602 inline void Identifier::set_name(const ::std::string& value) {
1603 set_has_name();
1604 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1605 name_ = new ::std::string;
1606 }
1607 name_->assign(value);
1608 // @@protoc_insertion_point(field_set:Mysqlx.Expr.Identifier.name)
1609 }
set_name(const char * value)1610 inline void Identifier::set_name(const char* value) {
1611 set_has_name();
1612 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1613 name_ = new ::std::string;
1614 }
1615 name_->assign(value);
1616 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.Identifier.name)
1617 }
set_name(const char * value,size_t size)1618 inline void Identifier::set_name(const char* value, size_t size) {
1619 set_has_name();
1620 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1621 name_ = new ::std::string;
1622 }
1623 name_->assign(reinterpret_cast<const char*>(value), size);
1624 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.Identifier.name)
1625 }
mutable_name()1626 inline ::std::string* Identifier::mutable_name() {
1627 set_has_name();
1628 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1629 name_ = new ::std::string;
1630 }
1631 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Identifier.name)
1632 return name_;
1633 }
release_name()1634 inline ::std::string* Identifier::release_name() {
1635 clear_has_name();
1636 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1637 return NULL;
1638 } else {
1639 ::std::string* temp = name_;
1640 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1641 return temp;
1642 }
1643 }
set_allocated_name(::std::string * name)1644 inline void Identifier::set_allocated_name(::std::string* name) {
1645 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1646 delete name_;
1647 }
1648 if (name) {
1649 set_has_name();
1650 name_ = name;
1651 } else {
1652 clear_has_name();
1653 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1654 }
1655 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Identifier.name)
1656 }
1657
1658 // optional string schema_name = 2;
has_schema_name()1659 inline bool Identifier::has_schema_name() const {
1660 return (_has_bits_[0] & 0x00000002u) != 0;
1661 }
set_has_schema_name()1662 inline void Identifier::set_has_schema_name() {
1663 _has_bits_[0] |= 0x00000002u;
1664 }
clear_has_schema_name()1665 inline void Identifier::clear_has_schema_name() {
1666 _has_bits_[0] &= ~0x00000002u;
1667 }
clear_schema_name()1668 inline void Identifier::clear_schema_name() {
1669 if (schema_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1670 schema_name_->clear();
1671 }
1672 clear_has_schema_name();
1673 }
schema_name()1674 inline const ::std::string& Identifier::schema_name() const {
1675 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Identifier.schema_name)
1676 return *schema_name_;
1677 }
set_schema_name(const::std::string & value)1678 inline void Identifier::set_schema_name(const ::std::string& value) {
1679 set_has_schema_name();
1680 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1681 schema_name_ = new ::std::string;
1682 }
1683 schema_name_->assign(value);
1684 // @@protoc_insertion_point(field_set:Mysqlx.Expr.Identifier.schema_name)
1685 }
set_schema_name(const char * value)1686 inline void Identifier::set_schema_name(const char* value) {
1687 set_has_schema_name();
1688 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1689 schema_name_ = new ::std::string;
1690 }
1691 schema_name_->assign(value);
1692 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.Identifier.schema_name)
1693 }
set_schema_name(const char * value,size_t size)1694 inline void Identifier::set_schema_name(const char* value, size_t size) {
1695 set_has_schema_name();
1696 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1697 schema_name_ = new ::std::string;
1698 }
1699 schema_name_->assign(reinterpret_cast<const char*>(value), size);
1700 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.Identifier.schema_name)
1701 }
mutable_schema_name()1702 inline ::std::string* Identifier::mutable_schema_name() {
1703 set_has_schema_name();
1704 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1705 schema_name_ = new ::std::string;
1706 }
1707 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Identifier.schema_name)
1708 return schema_name_;
1709 }
release_schema_name()1710 inline ::std::string* Identifier::release_schema_name() {
1711 clear_has_schema_name();
1712 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1713 return NULL;
1714 } else {
1715 ::std::string* temp = schema_name_;
1716 schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1717 return temp;
1718 }
1719 }
set_allocated_schema_name(::std::string * schema_name)1720 inline void Identifier::set_allocated_schema_name(::std::string* schema_name) {
1721 if (schema_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1722 delete schema_name_;
1723 }
1724 if (schema_name) {
1725 set_has_schema_name();
1726 schema_name_ = schema_name;
1727 } else {
1728 clear_has_schema_name();
1729 schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1730 }
1731 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Identifier.schema_name)
1732 }
1733
1734 // -------------------------------------------------------------------
1735
1736 // DocumentPathItem
1737
1738 // required .Mysqlx.Expr.DocumentPathItem.Type type = 1;
has_type()1739 inline bool DocumentPathItem::has_type() const {
1740 return (_has_bits_[0] & 0x00000001u) != 0;
1741 }
set_has_type()1742 inline void DocumentPathItem::set_has_type() {
1743 _has_bits_[0] |= 0x00000001u;
1744 }
clear_has_type()1745 inline void DocumentPathItem::clear_has_type() {
1746 _has_bits_[0] &= ~0x00000001u;
1747 }
clear_type()1748 inline void DocumentPathItem::clear_type() {
1749 type_ = 1;
1750 clear_has_type();
1751 }
type()1752 inline ::Mysqlx::Expr::DocumentPathItem_Type DocumentPathItem::type() const {
1753 // @@protoc_insertion_point(field_get:Mysqlx.Expr.DocumentPathItem.type)
1754 return static_cast< ::Mysqlx::Expr::DocumentPathItem_Type >(type_);
1755 }
set_type(::Mysqlx::Expr::DocumentPathItem_Type value)1756 inline void DocumentPathItem::set_type(::Mysqlx::Expr::DocumentPathItem_Type value) {
1757 assert(::Mysqlx::Expr::DocumentPathItem_Type_IsValid(value));
1758 set_has_type();
1759 type_ = value;
1760 // @@protoc_insertion_point(field_set:Mysqlx.Expr.DocumentPathItem.type)
1761 }
1762
1763 // optional string value = 2;
has_value()1764 inline bool DocumentPathItem::has_value() const {
1765 return (_has_bits_[0] & 0x00000002u) != 0;
1766 }
set_has_value()1767 inline void DocumentPathItem::set_has_value() {
1768 _has_bits_[0] |= 0x00000002u;
1769 }
clear_has_value()1770 inline void DocumentPathItem::clear_has_value() {
1771 _has_bits_[0] &= ~0x00000002u;
1772 }
clear_value()1773 inline void DocumentPathItem::clear_value() {
1774 if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1775 value_->clear();
1776 }
1777 clear_has_value();
1778 }
value()1779 inline const ::std::string& DocumentPathItem::value() const {
1780 // @@protoc_insertion_point(field_get:Mysqlx.Expr.DocumentPathItem.value)
1781 return *value_;
1782 }
set_value(const::std::string & value)1783 inline void DocumentPathItem::set_value(const ::std::string& value) {
1784 set_has_value();
1785 if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1786 value_ = new ::std::string;
1787 }
1788 value_->assign(value);
1789 // @@protoc_insertion_point(field_set:Mysqlx.Expr.DocumentPathItem.value)
1790 }
set_value(const char * value)1791 inline void DocumentPathItem::set_value(const char* value) {
1792 set_has_value();
1793 if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1794 value_ = new ::std::string;
1795 }
1796 value_->assign(value);
1797 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.DocumentPathItem.value)
1798 }
set_value(const char * value,size_t size)1799 inline void DocumentPathItem::set_value(const char* value, size_t size) {
1800 set_has_value();
1801 if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1802 value_ = new ::std::string;
1803 }
1804 value_->assign(reinterpret_cast<const char*>(value), size);
1805 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.DocumentPathItem.value)
1806 }
mutable_value()1807 inline ::std::string* DocumentPathItem::mutable_value() {
1808 set_has_value();
1809 if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1810 value_ = new ::std::string;
1811 }
1812 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.DocumentPathItem.value)
1813 return value_;
1814 }
release_value()1815 inline ::std::string* DocumentPathItem::release_value() {
1816 clear_has_value();
1817 if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1818 return NULL;
1819 } else {
1820 ::std::string* temp = value_;
1821 value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1822 return temp;
1823 }
1824 }
set_allocated_value(::std::string * value)1825 inline void DocumentPathItem::set_allocated_value(::std::string* value) {
1826 if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1827 delete value_;
1828 }
1829 if (value) {
1830 set_has_value();
1831 value_ = value;
1832 } else {
1833 clear_has_value();
1834 value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1835 }
1836 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.DocumentPathItem.value)
1837 }
1838
1839 // optional uint32 index = 3;
has_index()1840 inline bool DocumentPathItem::has_index() const {
1841 return (_has_bits_[0] & 0x00000004u) != 0;
1842 }
set_has_index()1843 inline void DocumentPathItem::set_has_index() {
1844 _has_bits_[0] |= 0x00000004u;
1845 }
clear_has_index()1846 inline void DocumentPathItem::clear_has_index() {
1847 _has_bits_[0] &= ~0x00000004u;
1848 }
clear_index()1849 inline void DocumentPathItem::clear_index() {
1850 index_ = 0u;
1851 clear_has_index();
1852 }
index()1853 inline ::google::protobuf::uint32 DocumentPathItem::index() const {
1854 // @@protoc_insertion_point(field_get:Mysqlx.Expr.DocumentPathItem.index)
1855 return index_;
1856 }
set_index(::google::protobuf::uint32 value)1857 inline void DocumentPathItem::set_index(::google::protobuf::uint32 value) {
1858 set_has_index();
1859 index_ = value;
1860 // @@protoc_insertion_point(field_set:Mysqlx.Expr.DocumentPathItem.index)
1861 }
1862
1863 // -------------------------------------------------------------------
1864
1865 // ColumnIdentifier
1866
1867 // repeated .Mysqlx.Expr.DocumentPathItem document_path = 1;
document_path_size()1868 inline int ColumnIdentifier::document_path_size() const {
1869 return document_path_.size();
1870 }
clear_document_path()1871 inline void ColumnIdentifier::clear_document_path() {
1872 document_path_.Clear();
1873 }
document_path(int index)1874 inline const ::Mysqlx::Expr::DocumentPathItem& ColumnIdentifier::document_path(int index) const {
1875 // @@protoc_insertion_point(field_get:Mysqlx.Expr.ColumnIdentifier.document_path)
1876 return document_path_.Get(index);
1877 }
mutable_document_path(int index)1878 inline ::Mysqlx::Expr::DocumentPathItem* ColumnIdentifier::mutable_document_path(int index) {
1879 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.ColumnIdentifier.document_path)
1880 return document_path_.Mutable(index);
1881 }
add_document_path()1882 inline ::Mysqlx::Expr::DocumentPathItem* ColumnIdentifier::add_document_path() {
1883 // @@protoc_insertion_point(field_add:Mysqlx.Expr.ColumnIdentifier.document_path)
1884 return document_path_.Add();
1885 }
1886 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::DocumentPathItem >&
document_path()1887 ColumnIdentifier::document_path() const {
1888 // @@protoc_insertion_point(field_list:Mysqlx.Expr.ColumnIdentifier.document_path)
1889 return document_path_;
1890 }
1891 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::DocumentPathItem >*
mutable_document_path()1892 ColumnIdentifier::mutable_document_path() {
1893 // @@protoc_insertion_point(field_mutable_list:Mysqlx.Expr.ColumnIdentifier.document_path)
1894 return &document_path_;
1895 }
1896
1897 // optional string name = 2;
has_name()1898 inline bool ColumnIdentifier::has_name() const {
1899 return (_has_bits_[0] & 0x00000002u) != 0;
1900 }
set_has_name()1901 inline void ColumnIdentifier::set_has_name() {
1902 _has_bits_[0] |= 0x00000002u;
1903 }
clear_has_name()1904 inline void ColumnIdentifier::clear_has_name() {
1905 _has_bits_[0] &= ~0x00000002u;
1906 }
clear_name()1907 inline void ColumnIdentifier::clear_name() {
1908 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1909 name_->clear();
1910 }
1911 clear_has_name();
1912 }
name()1913 inline const ::std::string& ColumnIdentifier::name() const {
1914 // @@protoc_insertion_point(field_get:Mysqlx.Expr.ColumnIdentifier.name)
1915 return *name_;
1916 }
set_name(const::std::string & value)1917 inline void ColumnIdentifier::set_name(const ::std::string& value) {
1918 set_has_name();
1919 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1920 name_ = new ::std::string;
1921 }
1922 name_->assign(value);
1923 // @@protoc_insertion_point(field_set:Mysqlx.Expr.ColumnIdentifier.name)
1924 }
set_name(const char * value)1925 inline void ColumnIdentifier::set_name(const char* value) {
1926 set_has_name();
1927 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1928 name_ = new ::std::string;
1929 }
1930 name_->assign(value);
1931 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.ColumnIdentifier.name)
1932 }
set_name(const char * value,size_t size)1933 inline void ColumnIdentifier::set_name(const char* value, size_t size) {
1934 set_has_name();
1935 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1936 name_ = new ::std::string;
1937 }
1938 name_->assign(reinterpret_cast<const char*>(value), size);
1939 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.ColumnIdentifier.name)
1940 }
mutable_name()1941 inline ::std::string* ColumnIdentifier::mutable_name() {
1942 set_has_name();
1943 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1944 name_ = new ::std::string;
1945 }
1946 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.ColumnIdentifier.name)
1947 return name_;
1948 }
release_name()1949 inline ::std::string* ColumnIdentifier::release_name() {
1950 clear_has_name();
1951 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1952 return NULL;
1953 } else {
1954 ::std::string* temp = name_;
1955 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1956 return temp;
1957 }
1958 }
set_allocated_name(::std::string * name)1959 inline void ColumnIdentifier::set_allocated_name(::std::string* name) {
1960 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1961 delete name_;
1962 }
1963 if (name) {
1964 set_has_name();
1965 name_ = name;
1966 } else {
1967 clear_has_name();
1968 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1969 }
1970 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.ColumnIdentifier.name)
1971 }
1972
1973 // optional string table_name = 3;
has_table_name()1974 inline bool ColumnIdentifier::has_table_name() const {
1975 return (_has_bits_[0] & 0x00000004u) != 0;
1976 }
set_has_table_name()1977 inline void ColumnIdentifier::set_has_table_name() {
1978 _has_bits_[0] |= 0x00000004u;
1979 }
clear_has_table_name()1980 inline void ColumnIdentifier::clear_has_table_name() {
1981 _has_bits_[0] &= ~0x00000004u;
1982 }
clear_table_name()1983 inline void ColumnIdentifier::clear_table_name() {
1984 if (table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1985 table_name_->clear();
1986 }
1987 clear_has_table_name();
1988 }
table_name()1989 inline const ::std::string& ColumnIdentifier::table_name() const {
1990 // @@protoc_insertion_point(field_get:Mysqlx.Expr.ColumnIdentifier.table_name)
1991 return *table_name_;
1992 }
set_table_name(const::std::string & value)1993 inline void ColumnIdentifier::set_table_name(const ::std::string& value) {
1994 set_has_table_name();
1995 if (table_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1996 table_name_ = new ::std::string;
1997 }
1998 table_name_->assign(value);
1999 // @@protoc_insertion_point(field_set:Mysqlx.Expr.ColumnIdentifier.table_name)
2000 }
set_table_name(const char * value)2001 inline void ColumnIdentifier::set_table_name(const char* value) {
2002 set_has_table_name();
2003 if (table_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2004 table_name_ = new ::std::string;
2005 }
2006 table_name_->assign(value);
2007 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.ColumnIdentifier.table_name)
2008 }
set_table_name(const char * value,size_t size)2009 inline void ColumnIdentifier::set_table_name(const char* value, size_t size) {
2010 set_has_table_name();
2011 if (table_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2012 table_name_ = new ::std::string;
2013 }
2014 table_name_->assign(reinterpret_cast<const char*>(value), size);
2015 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.ColumnIdentifier.table_name)
2016 }
mutable_table_name()2017 inline ::std::string* ColumnIdentifier::mutable_table_name() {
2018 set_has_table_name();
2019 if (table_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2020 table_name_ = new ::std::string;
2021 }
2022 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.ColumnIdentifier.table_name)
2023 return table_name_;
2024 }
release_table_name()2025 inline ::std::string* ColumnIdentifier::release_table_name() {
2026 clear_has_table_name();
2027 if (table_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2028 return NULL;
2029 } else {
2030 ::std::string* temp = table_name_;
2031 table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2032 return temp;
2033 }
2034 }
set_allocated_table_name(::std::string * table_name)2035 inline void ColumnIdentifier::set_allocated_table_name(::std::string* table_name) {
2036 if (table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2037 delete table_name_;
2038 }
2039 if (table_name) {
2040 set_has_table_name();
2041 table_name_ = table_name;
2042 } else {
2043 clear_has_table_name();
2044 table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2045 }
2046 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.ColumnIdentifier.table_name)
2047 }
2048
2049 // optional string schema_name = 4;
has_schema_name()2050 inline bool ColumnIdentifier::has_schema_name() const {
2051 return (_has_bits_[0] & 0x00000008u) != 0;
2052 }
set_has_schema_name()2053 inline void ColumnIdentifier::set_has_schema_name() {
2054 _has_bits_[0] |= 0x00000008u;
2055 }
clear_has_schema_name()2056 inline void ColumnIdentifier::clear_has_schema_name() {
2057 _has_bits_[0] &= ~0x00000008u;
2058 }
clear_schema_name()2059 inline void ColumnIdentifier::clear_schema_name() {
2060 if (schema_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2061 schema_name_->clear();
2062 }
2063 clear_has_schema_name();
2064 }
schema_name()2065 inline const ::std::string& ColumnIdentifier::schema_name() const {
2066 // @@protoc_insertion_point(field_get:Mysqlx.Expr.ColumnIdentifier.schema_name)
2067 return *schema_name_;
2068 }
set_schema_name(const::std::string & value)2069 inline void ColumnIdentifier::set_schema_name(const ::std::string& value) {
2070 set_has_schema_name();
2071 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2072 schema_name_ = new ::std::string;
2073 }
2074 schema_name_->assign(value);
2075 // @@protoc_insertion_point(field_set:Mysqlx.Expr.ColumnIdentifier.schema_name)
2076 }
set_schema_name(const char * value)2077 inline void ColumnIdentifier::set_schema_name(const char* value) {
2078 set_has_schema_name();
2079 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2080 schema_name_ = new ::std::string;
2081 }
2082 schema_name_->assign(value);
2083 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.ColumnIdentifier.schema_name)
2084 }
set_schema_name(const char * value,size_t size)2085 inline void ColumnIdentifier::set_schema_name(const char* value, size_t size) {
2086 set_has_schema_name();
2087 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2088 schema_name_ = new ::std::string;
2089 }
2090 schema_name_->assign(reinterpret_cast<const char*>(value), size);
2091 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.ColumnIdentifier.schema_name)
2092 }
mutable_schema_name()2093 inline ::std::string* ColumnIdentifier::mutable_schema_name() {
2094 set_has_schema_name();
2095 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2096 schema_name_ = new ::std::string;
2097 }
2098 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.ColumnIdentifier.schema_name)
2099 return schema_name_;
2100 }
release_schema_name()2101 inline ::std::string* ColumnIdentifier::release_schema_name() {
2102 clear_has_schema_name();
2103 if (schema_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2104 return NULL;
2105 } else {
2106 ::std::string* temp = schema_name_;
2107 schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2108 return temp;
2109 }
2110 }
set_allocated_schema_name(::std::string * schema_name)2111 inline void ColumnIdentifier::set_allocated_schema_name(::std::string* schema_name) {
2112 if (schema_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2113 delete schema_name_;
2114 }
2115 if (schema_name) {
2116 set_has_schema_name();
2117 schema_name_ = schema_name;
2118 } else {
2119 clear_has_schema_name();
2120 schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2121 }
2122 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.ColumnIdentifier.schema_name)
2123 }
2124
2125 // -------------------------------------------------------------------
2126
2127 // FunctionCall
2128
2129 // required .Mysqlx.Expr.Identifier name = 1;
has_name()2130 inline bool FunctionCall::has_name() const {
2131 return (_has_bits_[0] & 0x00000001u) != 0;
2132 }
set_has_name()2133 inline void FunctionCall::set_has_name() {
2134 _has_bits_[0] |= 0x00000001u;
2135 }
clear_has_name()2136 inline void FunctionCall::clear_has_name() {
2137 _has_bits_[0] &= ~0x00000001u;
2138 }
clear_name()2139 inline void FunctionCall::clear_name() {
2140 if (name_ != NULL) name_->::Mysqlx::Expr::Identifier::Clear();
2141 clear_has_name();
2142 }
name()2143 inline const ::Mysqlx::Expr::Identifier& FunctionCall::name() const {
2144 // @@protoc_insertion_point(field_get:Mysqlx.Expr.FunctionCall.name)
2145 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
2146 return name_ != NULL ? *name_ : *default_instance().name_;
2147 #else
2148 return name_ != NULL ? *name_ : *default_instance_->name_;
2149 #endif
2150 }
mutable_name()2151 inline ::Mysqlx::Expr::Identifier* FunctionCall::mutable_name() {
2152 set_has_name();
2153 if (name_ == NULL) name_ = new ::Mysqlx::Expr::Identifier;
2154 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.FunctionCall.name)
2155 return name_;
2156 }
release_name()2157 inline ::Mysqlx::Expr::Identifier* FunctionCall::release_name() {
2158 clear_has_name();
2159 ::Mysqlx::Expr::Identifier* temp = name_;
2160 name_ = NULL;
2161 return temp;
2162 }
set_allocated_name(::Mysqlx::Expr::Identifier * name)2163 inline void FunctionCall::set_allocated_name(::Mysqlx::Expr::Identifier* name) {
2164 delete name_;
2165 name_ = name;
2166 if (name) {
2167 set_has_name();
2168 } else {
2169 clear_has_name();
2170 }
2171 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.FunctionCall.name)
2172 }
2173
2174 // repeated .Mysqlx.Expr.Expr param = 2;
param_size()2175 inline int FunctionCall::param_size() const {
2176 return param_.size();
2177 }
clear_param()2178 inline void FunctionCall::clear_param() {
2179 param_.Clear();
2180 }
param(int index)2181 inline const ::Mysqlx::Expr::Expr& FunctionCall::param(int index) const {
2182 // @@protoc_insertion_point(field_get:Mysqlx.Expr.FunctionCall.param)
2183 return param_.Get(index);
2184 }
mutable_param(int index)2185 inline ::Mysqlx::Expr::Expr* FunctionCall::mutable_param(int index) {
2186 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.FunctionCall.param)
2187 return param_.Mutable(index);
2188 }
add_param()2189 inline ::Mysqlx::Expr::Expr* FunctionCall::add_param() {
2190 // @@protoc_insertion_point(field_add:Mysqlx.Expr.FunctionCall.param)
2191 return param_.Add();
2192 }
2193 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >&
param()2194 FunctionCall::param() const {
2195 // @@protoc_insertion_point(field_list:Mysqlx.Expr.FunctionCall.param)
2196 return param_;
2197 }
2198 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >*
mutable_param()2199 FunctionCall::mutable_param() {
2200 // @@protoc_insertion_point(field_mutable_list:Mysqlx.Expr.FunctionCall.param)
2201 return ¶m_;
2202 }
2203
2204 // -------------------------------------------------------------------
2205
2206 // Operator
2207
2208 // required string name = 1;
has_name()2209 inline bool Operator::has_name() const {
2210 return (_has_bits_[0] & 0x00000001u) != 0;
2211 }
set_has_name()2212 inline void Operator::set_has_name() {
2213 _has_bits_[0] |= 0x00000001u;
2214 }
clear_has_name()2215 inline void Operator::clear_has_name() {
2216 _has_bits_[0] &= ~0x00000001u;
2217 }
clear_name()2218 inline void Operator::clear_name() {
2219 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2220 name_->clear();
2221 }
2222 clear_has_name();
2223 }
name()2224 inline const ::std::string& Operator::name() const {
2225 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Operator.name)
2226 return *name_;
2227 }
set_name(const::std::string & value)2228 inline void Operator::set_name(const ::std::string& value) {
2229 set_has_name();
2230 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2231 name_ = new ::std::string;
2232 }
2233 name_->assign(value);
2234 // @@protoc_insertion_point(field_set:Mysqlx.Expr.Operator.name)
2235 }
set_name(const char * value)2236 inline void Operator::set_name(const char* value) {
2237 set_has_name();
2238 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2239 name_ = new ::std::string;
2240 }
2241 name_->assign(value);
2242 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.Operator.name)
2243 }
set_name(const char * value,size_t size)2244 inline void Operator::set_name(const char* value, size_t size) {
2245 set_has_name();
2246 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2247 name_ = new ::std::string;
2248 }
2249 name_->assign(reinterpret_cast<const char*>(value), size);
2250 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.Operator.name)
2251 }
mutable_name()2252 inline ::std::string* Operator::mutable_name() {
2253 set_has_name();
2254 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2255 name_ = new ::std::string;
2256 }
2257 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Operator.name)
2258 return name_;
2259 }
release_name()2260 inline ::std::string* Operator::release_name() {
2261 clear_has_name();
2262 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2263 return NULL;
2264 } else {
2265 ::std::string* temp = name_;
2266 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2267 return temp;
2268 }
2269 }
set_allocated_name(::std::string * name)2270 inline void Operator::set_allocated_name(::std::string* name) {
2271 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2272 delete name_;
2273 }
2274 if (name) {
2275 set_has_name();
2276 name_ = name;
2277 } else {
2278 clear_has_name();
2279 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2280 }
2281 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Operator.name)
2282 }
2283
2284 // repeated .Mysqlx.Expr.Expr param = 2;
param_size()2285 inline int Operator::param_size() const {
2286 return param_.size();
2287 }
clear_param()2288 inline void Operator::clear_param() {
2289 param_.Clear();
2290 }
param(int index)2291 inline const ::Mysqlx::Expr::Expr& Operator::param(int index) const {
2292 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Operator.param)
2293 return param_.Get(index);
2294 }
mutable_param(int index)2295 inline ::Mysqlx::Expr::Expr* Operator::mutable_param(int index) {
2296 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Operator.param)
2297 return param_.Mutable(index);
2298 }
add_param()2299 inline ::Mysqlx::Expr::Expr* Operator::add_param() {
2300 // @@protoc_insertion_point(field_add:Mysqlx.Expr.Operator.param)
2301 return param_.Add();
2302 }
2303 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >&
param()2304 Operator::param() const {
2305 // @@protoc_insertion_point(field_list:Mysqlx.Expr.Operator.param)
2306 return param_;
2307 }
2308 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >*
mutable_param()2309 Operator::mutable_param() {
2310 // @@protoc_insertion_point(field_mutable_list:Mysqlx.Expr.Operator.param)
2311 return ¶m_;
2312 }
2313
2314 // -------------------------------------------------------------------
2315
2316 // Object_ObjectField
2317
2318 // required string key = 1;
has_key()2319 inline bool Object_ObjectField::has_key() const {
2320 return (_has_bits_[0] & 0x00000001u) != 0;
2321 }
set_has_key()2322 inline void Object_ObjectField::set_has_key() {
2323 _has_bits_[0] |= 0x00000001u;
2324 }
clear_has_key()2325 inline void Object_ObjectField::clear_has_key() {
2326 _has_bits_[0] &= ~0x00000001u;
2327 }
clear_key()2328 inline void Object_ObjectField::clear_key() {
2329 if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2330 key_->clear();
2331 }
2332 clear_has_key();
2333 }
key()2334 inline const ::std::string& Object_ObjectField::key() const {
2335 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Object.ObjectField.key)
2336 return *key_;
2337 }
set_key(const::std::string & value)2338 inline void Object_ObjectField::set_key(const ::std::string& value) {
2339 set_has_key();
2340 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2341 key_ = new ::std::string;
2342 }
2343 key_->assign(value);
2344 // @@protoc_insertion_point(field_set:Mysqlx.Expr.Object.ObjectField.key)
2345 }
set_key(const char * value)2346 inline void Object_ObjectField::set_key(const char* value) {
2347 set_has_key();
2348 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2349 key_ = new ::std::string;
2350 }
2351 key_->assign(value);
2352 // @@protoc_insertion_point(field_set_char:Mysqlx.Expr.Object.ObjectField.key)
2353 }
set_key(const char * value,size_t size)2354 inline void Object_ObjectField::set_key(const char* value, size_t size) {
2355 set_has_key();
2356 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2357 key_ = new ::std::string;
2358 }
2359 key_->assign(reinterpret_cast<const char*>(value), size);
2360 // @@protoc_insertion_point(field_set_pointer:Mysqlx.Expr.Object.ObjectField.key)
2361 }
mutable_key()2362 inline ::std::string* Object_ObjectField::mutable_key() {
2363 set_has_key();
2364 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2365 key_ = new ::std::string;
2366 }
2367 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Object.ObjectField.key)
2368 return key_;
2369 }
release_key()2370 inline ::std::string* Object_ObjectField::release_key() {
2371 clear_has_key();
2372 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2373 return NULL;
2374 } else {
2375 ::std::string* temp = key_;
2376 key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2377 return temp;
2378 }
2379 }
set_allocated_key(::std::string * key)2380 inline void Object_ObjectField::set_allocated_key(::std::string* key) {
2381 if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
2382 delete key_;
2383 }
2384 if (key) {
2385 set_has_key();
2386 key_ = key;
2387 } else {
2388 clear_has_key();
2389 key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2390 }
2391 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Object.ObjectField.key)
2392 }
2393
2394 // required .Mysqlx.Expr.Expr value = 2;
has_value()2395 inline bool Object_ObjectField::has_value() const {
2396 return (_has_bits_[0] & 0x00000002u) != 0;
2397 }
set_has_value()2398 inline void Object_ObjectField::set_has_value() {
2399 _has_bits_[0] |= 0x00000002u;
2400 }
clear_has_value()2401 inline void Object_ObjectField::clear_has_value() {
2402 _has_bits_[0] &= ~0x00000002u;
2403 }
clear_value()2404 inline void Object_ObjectField::clear_value() {
2405 if (value_ != NULL) value_->::Mysqlx::Expr::Expr::Clear();
2406 clear_has_value();
2407 }
value()2408 inline const ::Mysqlx::Expr::Expr& Object_ObjectField::value() const {
2409 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Object.ObjectField.value)
2410 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
2411 return value_ != NULL ? *value_ : *default_instance().value_;
2412 #else
2413 return value_ != NULL ? *value_ : *default_instance_->value_;
2414 #endif
2415 }
mutable_value()2416 inline ::Mysqlx::Expr::Expr* Object_ObjectField::mutable_value() {
2417 set_has_value();
2418 if (value_ == NULL) value_ = new ::Mysqlx::Expr::Expr;
2419 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Object.ObjectField.value)
2420 return value_;
2421 }
release_value()2422 inline ::Mysqlx::Expr::Expr* Object_ObjectField::release_value() {
2423 clear_has_value();
2424 ::Mysqlx::Expr::Expr* temp = value_;
2425 value_ = NULL;
2426 return temp;
2427 }
set_allocated_value(::Mysqlx::Expr::Expr * value)2428 inline void Object_ObjectField::set_allocated_value(::Mysqlx::Expr::Expr* value) {
2429 delete value_;
2430 value_ = value;
2431 if (value) {
2432 set_has_value();
2433 } else {
2434 clear_has_value();
2435 }
2436 // @@protoc_insertion_point(field_set_allocated:Mysqlx.Expr.Object.ObjectField.value)
2437 }
2438
2439 // -------------------------------------------------------------------
2440
2441 // Object
2442
2443 // repeated .Mysqlx.Expr.Object.ObjectField fld = 1;
fld_size()2444 inline int Object::fld_size() const {
2445 return fld_.size();
2446 }
clear_fld()2447 inline void Object::clear_fld() {
2448 fld_.Clear();
2449 }
fld(int index)2450 inline const ::Mysqlx::Expr::Object_ObjectField& Object::fld(int index) const {
2451 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Object.fld)
2452 return fld_.Get(index);
2453 }
mutable_fld(int index)2454 inline ::Mysqlx::Expr::Object_ObjectField* Object::mutable_fld(int index) {
2455 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Object.fld)
2456 return fld_.Mutable(index);
2457 }
add_fld()2458 inline ::Mysqlx::Expr::Object_ObjectField* Object::add_fld() {
2459 // @@protoc_insertion_point(field_add:Mysqlx.Expr.Object.fld)
2460 return fld_.Add();
2461 }
2462 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Object_ObjectField >&
fld()2463 Object::fld() const {
2464 // @@protoc_insertion_point(field_list:Mysqlx.Expr.Object.fld)
2465 return fld_;
2466 }
2467 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Object_ObjectField >*
mutable_fld()2468 Object::mutable_fld() {
2469 // @@protoc_insertion_point(field_mutable_list:Mysqlx.Expr.Object.fld)
2470 return &fld_;
2471 }
2472
2473 // -------------------------------------------------------------------
2474
2475 // Array
2476
2477 // repeated .Mysqlx.Expr.Expr value = 1;
value_size()2478 inline int Array::value_size() const {
2479 return value_.size();
2480 }
clear_value()2481 inline void Array::clear_value() {
2482 value_.Clear();
2483 }
value(int index)2484 inline const ::Mysqlx::Expr::Expr& Array::value(int index) const {
2485 // @@protoc_insertion_point(field_get:Mysqlx.Expr.Array.value)
2486 return value_.Get(index);
2487 }
mutable_value(int index)2488 inline ::Mysqlx::Expr::Expr* Array::mutable_value(int index) {
2489 // @@protoc_insertion_point(field_mutable:Mysqlx.Expr.Array.value)
2490 return value_.Mutable(index);
2491 }
add_value()2492 inline ::Mysqlx::Expr::Expr* Array::add_value() {
2493 // @@protoc_insertion_point(field_add:Mysqlx.Expr.Array.value)
2494 return value_.Add();
2495 }
2496 inline const ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >&
value()2497 Array::value() const {
2498 // @@protoc_insertion_point(field_list:Mysqlx.Expr.Array.value)
2499 return value_;
2500 }
2501 inline ::google::protobuf::RepeatedPtrField< ::Mysqlx::Expr::Expr >*
mutable_value()2502 Array::mutable_value() {
2503 // @@protoc_insertion_point(field_mutable_list:Mysqlx.Expr.Array.value)
2504 return &value_;
2505 }
2506
2507
2508 // @@protoc_insertion_point(namespace_scope)
2509
2510 } // namespace Expr
2511 } // namespace Mysqlx
2512
2513 // @@protoc_insertion_point(global_scope)
2514
2515 #endif // PROTOBUF_mysqlx_5fexpr_2eproto__INCLUDED
2516