Drizzled Public API Documentation

schema.pb.h
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: schema.proto
3 
4 #ifndef PROTOBUF_schema_2eproto__INCLUDED
5 #define PROTOBUF_schema_2eproto__INCLUDED
6 
7 #include <string>
8 
9 #include <google/protobuf/stubs/common.h>
10 
11 #if GOOGLE_PROTOBUF_VERSION < 2005000
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 2005000 < 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.h>
24 #include <google/protobuf/repeated_field.h>
25 #include <google/protobuf/extension_set.h>
26 #include <google/protobuf/unknown_field_set.h>
27 #include "engine.pb.h"
28 #include "access.pb.h"
29 #include "replication_options.pb.h"
30 // @@protoc_insertion_point(includes)
31 
32 namespace drizzled {
33 namespace message {
34 
35 // Internal implementation detail -- do not call these.
36 void protobuf_AddDesc_schema_2eproto();
37 void protobuf_AssignDesc_schema_2eproto();
38 void protobuf_ShutdownFile_schema_2eproto();
39 
40 class Schema;
41 class Schema_Options;
42 
43 // ===================================================================
44 
45 class Schema_Options : public ::google::protobuf::Message {
46  public:
48  virtual ~Schema_Options();
49 
50  Schema_Options(const Schema_Options& from);
51 
52  inline Schema_Options& operator=(const Schema_Options& from) {
53  CopyFrom(from);
54  return *this;
55  }
56 
57  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
58  return _unknown_fields_;
59  }
60 
61  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
62  return &_unknown_fields_;
63  }
64 
65  static const ::google::protobuf::Descriptor* descriptor();
66  static const Schema_Options& default_instance();
67 
68  void Swap(Schema_Options* other);
69 
70  // implements Message ----------------------------------------------
71 
72  Schema_Options* New() const;
73  void CopyFrom(const ::google::protobuf::Message& from);
74  void MergeFrom(const ::google::protobuf::Message& from);
75  void CopyFrom(const Schema_Options& from);
76  void MergeFrom(const Schema_Options& from);
77  void Clear();
78  bool IsInitialized() const;
79 
80  int ByteSize() const;
81  bool MergePartialFromCodedStream(
82  ::google::protobuf::io::CodedInputStream* input);
83  void SerializeWithCachedSizes(
84  ::google::protobuf::io::CodedOutputStream* output) const;
85  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
86  int GetCachedSize() const { return _cached_size_; }
87  private:
88  void SharedCtor();
89  void SharedDtor();
90  void SetCachedSize(int size) const;
91  public:
92 
93  ::google::protobuf::Metadata GetMetadata() const;
94 
95  // nested types ----------------------------------------------------
96 
97  // accessors -------------------------------------------------------
98 
99  // @@protoc_insertion_point(class_scope:drizzled.message.Schema.Options)
100  private:
101 
102  ::google::protobuf::UnknownFieldSet _unknown_fields_;
103 
104 
105  mutable int _cached_size_;
106  ::google::protobuf::uint32 _has_bits_[1];
107 
108  friend void protobuf_AddDesc_schema_2eproto();
109  friend void protobuf_AssignDesc_schema_2eproto();
110  friend void protobuf_ShutdownFile_schema_2eproto();
111 
112  void InitAsDefaultInstance();
113  static Schema_Options* default_instance_;
114 };
115 // -------------------------------------------------------------------
116 
117 class Schema : public ::google::protobuf::Message {
118  public:
119  Schema();
120  virtual ~Schema();
121 
122  Schema(const Schema& from);
123 
124  inline Schema& operator=(const Schema& from) {
125  CopyFrom(from);
126  return *this;
127  }
128 
129  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
130  return _unknown_fields_;
131  }
132 
133  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
134  return &_unknown_fields_;
135  }
136 
137  static const ::google::protobuf::Descriptor* descriptor();
138  static const Schema& default_instance();
139 
140  void Swap(Schema* other);
141 
142  // implements Message ----------------------------------------------
143 
144  Schema* New() const;
145  void CopyFrom(const ::google::protobuf::Message& from);
146  void MergeFrom(const ::google::protobuf::Message& from);
147  void CopyFrom(const Schema& from);
148  void MergeFrom(const Schema& from);
149  void Clear();
150  bool IsInitialized() const;
151 
152  int ByteSize() const;
153  bool MergePartialFromCodedStream(
154  ::google::protobuf::io::CodedInputStream* input);
155  void SerializeWithCachedSizes(
156  ::google::protobuf::io::CodedOutputStream* output) const;
157  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
158  int GetCachedSize() const { return _cached_size_; }
159  private:
160  void SharedCtor();
161  void SharedDtor();
162  void SetCachedSize(int size) const;
163  public:
164 
165  ::google::protobuf::Metadata GetMetadata() const;
166 
167  // nested types ----------------------------------------------------
168 
169  typedef Schema_Options Options;
170 
171  // accessors -------------------------------------------------------
172 
173  // required string name = 1;
174  inline bool has_name() const;
175  inline void clear_name();
176  static const int kNameFieldNumber = 1;
177  inline const ::std::string& name() const;
178  inline void set_name(const ::std::string& value);
179  inline void set_name(const char* value);
180  inline void set_name(const char* value, size_t size);
181  inline ::std::string* mutable_name();
182  inline ::std::string* release_name();
183  inline void set_allocated_name(::std::string* name);
184 
185  // optional string collation = 2;
186  inline bool has_collation() const;
187  inline void clear_collation();
188  static const int kCollationFieldNumber = 2;
189  inline const ::std::string& collation() const;
190  inline void set_collation(const ::std::string& value);
191  inline void set_collation(const char* value);
192  inline void set_collation(const char* value, size_t size);
193  inline ::std::string* mutable_collation();
194  inline ::std::string* release_collation();
195  inline void set_allocated_collation(::std::string* collation);
196 
197  // required .drizzled.message.Engine engine = 3;
198  inline bool has_engine() const;
199  inline void clear_engine();
200  static const int kEngineFieldNumber = 3;
201  inline const ::drizzled::message::Engine& engine() const;
202  inline ::drizzled::message::Engine* mutable_engine();
203  inline ::drizzled::message::Engine* release_engine();
204  inline void set_allocated_engine(::drizzled::message::Engine* engine);
205 
206  // optional string catalog = 4;
207  inline bool has_catalog() const;
208  inline void clear_catalog();
209  static const int kCatalogFieldNumber = 4;
210  inline const ::std::string& catalog() const;
211  inline void set_catalog(const ::std::string& value);
212  inline void set_catalog(const char* value);
213  inline void set_catalog(const char* value, size_t size);
214  inline ::std::string* mutable_catalog();
215  inline ::std::string* release_catalog();
216  inline void set_allocated_catalog(::std::string* catalog);
217 
218  // required uint64 creation_timestamp = 11 [default = 0];
219  inline bool has_creation_timestamp() const;
220  inline void clear_creation_timestamp();
221  static const int kCreationTimestampFieldNumber = 11;
222  inline ::google::protobuf::uint64 creation_timestamp() const;
223  inline void set_creation_timestamp(::google::protobuf::uint64 value);
224 
225  // required uint64 update_timestamp = 12 [default = 0];
226  inline bool has_update_timestamp() const;
227  inline void clear_update_timestamp();
228  static const int kUpdateTimestampFieldNumber = 12;
229  inline ::google::protobuf::uint64 update_timestamp() const;
230  inline void set_update_timestamp(::google::protobuf::uint64 value);
231 
232  // optional string uuid = 13;
233  inline bool has_uuid() const;
234  inline void clear_uuid();
235  static const int kUuidFieldNumber = 13;
236  inline const ::std::string& uuid() const;
237  inline void set_uuid(const ::std::string& value);
238  inline void set_uuid(const char* value);
239  inline void set_uuid(const char* value, size_t size);
240  inline ::std::string* mutable_uuid();
241  inline ::std::string* release_uuid();
242  inline void set_allocated_uuid(::std::string* uuid);
243 
244  // optional uint64 version = 14;
245  inline bool has_version() const;
246  inline void clear_version();
247  static const int kVersionFieldNumber = 14;
248  inline ::google::protobuf::uint64 version() const;
249  inline void set_version(::google::protobuf::uint64 value);
250 
251  // optional .drizzled.message.Schema.Options options = 15;
252  inline bool has_options() const;
253  inline void clear_options();
254  static const int kOptionsFieldNumber = 15;
255  inline const ::drizzled::message::Schema_Options& options() const;
256  inline ::drizzled::message::Schema_Options* mutable_options();
257  inline ::drizzled::message::Schema_Options* release_options();
258  inline void set_allocated_options(::drizzled::message::Schema_Options* options);
259 
260  // optional .drizzled.message.ReplicationOptions replication_options = 16;
261  inline bool has_replication_options() const;
262  inline void clear_replication_options();
263  static const int kReplicationOptionsFieldNumber = 16;
264  inline const ::drizzled::message::ReplicationOptions& replication_options() const;
265  inline ::drizzled::message::ReplicationOptions* mutable_replication_options();
266  inline ::drizzled::message::ReplicationOptions* release_replication_options();
267  inline void set_allocated_replication_options(::drizzled::message::ReplicationOptions* replication_options);
268 
269  // optional .drizzled.message.Access access = 17;
270  inline bool has_access() const;
271  inline void clear_access();
272  static const int kAccessFieldNumber = 17;
273  inline const ::drizzled::message::Access& access() const;
274  inline ::drizzled::message::Access* mutable_access();
275  inline ::drizzled::message::Access* release_access();
276  inline void set_allocated_access(::drizzled::message::Access* access);
277 
278  // @@protoc_insertion_point(class_scope:drizzled.message.Schema)
279  private:
280  inline void set_has_name();
281  inline void clear_has_name();
282  inline void set_has_collation();
283  inline void clear_has_collation();
284  inline void set_has_engine();
285  inline void clear_has_engine();
286  inline void set_has_catalog();
287  inline void clear_has_catalog();
288  inline void set_has_creation_timestamp();
289  inline void clear_has_creation_timestamp();
290  inline void set_has_update_timestamp();
291  inline void clear_has_update_timestamp();
292  inline void set_has_uuid();
293  inline void clear_has_uuid();
294  inline void set_has_version();
295  inline void clear_has_version();
296  inline void set_has_options();
297  inline void clear_has_options();
298  inline void set_has_replication_options();
299  inline void clear_has_replication_options();
300  inline void set_has_access();
301  inline void clear_has_access();
302 
303  ::google::protobuf::UnknownFieldSet _unknown_fields_;
304 
305  ::std::string* name_;
306  ::std::string* collation_;
308  ::std::string* catalog_;
309  ::google::protobuf::uint64 creation_timestamp_;
310  ::google::protobuf::uint64 update_timestamp_;
311  ::std::string* uuid_;
312  ::google::protobuf::uint64 version_;
314  ::drizzled::message::ReplicationOptions* replication_options_;
316 
317  mutable int _cached_size_;
318  ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32];
319 
320  friend void protobuf_AddDesc_schema_2eproto();
321  friend void protobuf_AssignDesc_schema_2eproto();
322  friend void protobuf_ShutdownFile_schema_2eproto();
323 
324  void InitAsDefaultInstance();
325  static Schema* default_instance_;
326 };
327 // ===================================================================
328 
329 
330 // ===================================================================
331 
332 // Schema_Options
333 
334 // -------------------------------------------------------------------
335 
336 // Schema
337 
338 // required string name = 1;
339 inline bool Schema::has_name() const {
340  return (_has_bits_[0] & 0x00000001u) != 0;
341 }
342 inline void Schema::set_has_name() {
343  _has_bits_[0] |= 0x00000001u;
344 }
345 inline void Schema::clear_has_name() {
346  _has_bits_[0] &= ~0x00000001u;
347 }
348 inline void Schema::clear_name() {
349  if (name_ != &::google::protobuf::internal::kEmptyString) {
350  name_->clear();
351  }
352  clear_has_name();
353 }
354 inline const ::std::string& Schema::name() const {
355  return *name_;
356 }
357 inline void Schema::set_name(const ::std::string& value) {
358  set_has_name();
359  if (name_ == &::google::protobuf::internal::kEmptyString) {
360  name_ = new ::std::string;
361  }
362  name_->assign(value);
363 }
364 inline void Schema::set_name(const char* value) {
365  set_has_name();
366  if (name_ == &::google::protobuf::internal::kEmptyString) {
367  name_ = new ::std::string;
368  }
369  name_->assign(value);
370 }
371 inline void Schema::set_name(const char* value, size_t size) {
372  set_has_name();
373  if (name_ == &::google::protobuf::internal::kEmptyString) {
374  name_ = new ::std::string;
375  }
376  name_->assign(reinterpret_cast<const char*>(value), size);
377 }
378 inline ::std::string* Schema::mutable_name() {
379  set_has_name();
380  if (name_ == &::google::protobuf::internal::kEmptyString) {
381  name_ = new ::std::string;
382  }
383  return name_;
384 }
385 inline ::std::string* Schema::release_name() {
386  clear_has_name();
387  if (name_ == &::google::protobuf::internal::kEmptyString) {
388  return NULL;
389  } else {
390  ::std::string* temp = name_;
391  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
392  return temp;
393  }
394 }
395 inline void Schema::set_allocated_name(::std::string* name) {
396  if (name_ != &::google::protobuf::internal::kEmptyString) {
397  delete name_;
398  }
399  if (name) {
400  set_has_name();
401  name_ = name;
402  } else {
403  clear_has_name();
404  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
405  }
406 }
407 
408 // optional string collation = 2;
409 inline bool Schema::has_collation() const {
410  return (_has_bits_[0] & 0x00000002u) != 0;
411 }
412 inline void Schema::set_has_collation() {
413  _has_bits_[0] |= 0x00000002u;
414 }
415 inline void Schema::clear_has_collation() {
416  _has_bits_[0] &= ~0x00000002u;
417 }
418 inline void Schema::clear_collation() {
419  if (collation_ != &::google::protobuf::internal::kEmptyString) {
420  collation_->clear();
421  }
422  clear_has_collation();
423 }
424 inline const ::std::string& Schema::collation() const {
425  return *collation_;
426 }
427 inline void Schema::set_collation(const ::std::string& value) {
428  set_has_collation();
429  if (collation_ == &::google::protobuf::internal::kEmptyString) {
430  collation_ = new ::std::string;
431  }
432  collation_->assign(value);
433 }
434 inline void Schema::set_collation(const char* value) {
435  set_has_collation();
436  if (collation_ == &::google::protobuf::internal::kEmptyString) {
437  collation_ = new ::std::string;
438  }
439  collation_->assign(value);
440 }
441 inline void Schema::set_collation(const char* value, size_t size) {
442  set_has_collation();
443  if (collation_ == &::google::protobuf::internal::kEmptyString) {
444  collation_ = new ::std::string;
445  }
446  collation_->assign(reinterpret_cast<const char*>(value), size);
447 }
448 inline ::std::string* Schema::mutable_collation() {
449  set_has_collation();
450  if (collation_ == &::google::protobuf::internal::kEmptyString) {
451  collation_ = new ::std::string;
452  }
453  return collation_;
454 }
455 inline ::std::string* Schema::release_collation() {
456  clear_has_collation();
457  if (collation_ == &::google::protobuf::internal::kEmptyString) {
458  return NULL;
459  } else {
460  ::std::string* temp = collation_;
461  collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
462  return temp;
463  }
464 }
465 inline void Schema::set_allocated_collation(::std::string* collation) {
466  if (collation_ != &::google::protobuf::internal::kEmptyString) {
467  delete collation_;
468  }
469  if (collation) {
470  set_has_collation();
471  collation_ = collation;
472  } else {
473  clear_has_collation();
474  collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
475  }
476 }
477 
478 // required .drizzled.message.Engine engine = 3;
479 inline bool Schema::has_engine() const {
480  return (_has_bits_[0] & 0x00000004u) != 0;
481 }
482 inline void Schema::set_has_engine() {
483  _has_bits_[0] |= 0x00000004u;
484 }
485 inline void Schema::clear_has_engine() {
486  _has_bits_[0] &= ~0x00000004u;
487 }
488 inline void Schema::clear_engine() {
489  if (engine_ != NULL) engine_->::drizzled::message::Engine::Clear();
490  clear_has_engine();
491 }
492 inline const ::drizzled::message::Engine& Schema::engine() const {
493  return engine_ != NULL ? *engine_ : *default_instance_->engine_;
494 }
495 inline ::drizzled::message::Engine* Schema::mutable_engine() {
496  set_has_engine();
497  if (engine_ == NULL) engine_ = new ::drizzled::message::Engine;
498  return engine_;
499 }
500 inline ::drizzled::message::Engine* Schema::release_engine() {
501  clear_has_engine();
502  ::drizzled::message::Engine* temp = engine_;
503  engine_ = NULL;
504  return temp;
505 }
506 inline void Schema::set_allocated_engine(::drizzled::message::Engine* engine) {
507  delete engine_;
508  engine_ = engine;
509  if (engine) {
510  set_has_engine();
511  } else {
512  clear_has_engine();
513  }
514 }
515 
516 // optional string catalog = 4;
517 inline bool Schema::has_catalog() const {
518  return (_has_bits_[0] & 0x00000008u) != 0;
519 }
520 inline void Schema::set_has_catalog() {
521  _has_bits_[0] |= 0x00000008u;
522 }
523 inline void Schema::clear_has_catalog() {
524  _has_bits_[0] &= ~0x00000008u;
525 }
526 inline void Schema::clear_catalog() {
527  if (catalog_ != &::google::protobuf::internal::kEmptyString) {
528  catalog_->clear();
529  }
530  clear_has_catalog();
531 }
532 inline const ::std::string& Schema::catalog() const {
533  return *catalog_;
534 }
535 inline void Schema::set_catalog(const ::std::string& value) {
536  set_has_catalog();
537  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
538  catalog_ = new ::std::string;
539  }
540  catalog_->assign(value);
541 }
542 inline void Schema::set_catalog(const char* value) {
543  set_has_catalog();
544  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
545  catalog_ = new ::std::string;
546  }
547  catalog_->assign(value);
548 }
549 inline void Schema::set_catalog(const char* value, size_t size) {
550  set_has_catalog();
551  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
552  catalog_ = new ::std::string;
553  }
554  catalog_->assign(reinterpret_cast<const char*>(value), size);
555 }
556 inline ::std::string* Schema::mutable_catalog() {
557  set_has_catalog();
558  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
559  catalog_ = new ::std::string;
560  }
561  return catalog_;
562 }
563 inline ::std::string* Schema::release_catalog() {
564  clear_has_catalog();
565  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
566  return NULL;
567  } else {
568  ::std::string* temp = catalog_;
569  catalog_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
570  return temp;
571  }
572 }
573 inline void Schema::set_allocated_catalog(::std::string* catalog) {
574  if (catalog_ != &::google::protobuf::internal::kEmptyString) {
575  delete catalog_;
576  }
577  if (catalog) {
578  set_has_catalog();
579  catalog_ = catalog;
580  } else {
581  clear_has_catalog();
582  catalog_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
583  }
584 }
585 
586 // required uint64 creation_timestamp = 11 [default = 0];
587 inline bool Schema::has_creation_timestamp() const {
588  return (_has_bits_[0] & 0x00000010u) != 0;
589 }
590 inline void Schema::set_has_creation_timestamp() {
591  _has_bits_[0] |= 0x00000010u;
592 }
593 inline void Schema::clear_has_creation_timestamp() {
594  _has_bits_[0] &= ~0x00000010u;
595 }
596 inline void Schema::clear_creation_timestamp() {
597  creation_timestamp_ = GOOGLE_ULONGLONG(0);
598  clear_has_creation_timestamp();
599 }
600 inline ::google::protobuf::uint64 Schema::creation_timestamp() const {
601  return creation_timestamp_;
602 }
603 inline void Schema::set_creation_timestamp(::google::protobuf::uint64 value) {
604  set_has_creation_timestamp();
605  creation_timestamp_ = value;
606 }
607 
608 // required uint64 update_timestamp = 12 [default = 0];
609 inline bool Schema::has_update_timestamp() const {
610  return (_has_bits_[0] & 0x00000020u) != 0;
611 }
612 inline void Schema::set_has_update_timestamp() {
613  _has_bits_[0] |= 0x00000020u;
614 }
615 inline void Schema::clear_has_update_timestamp() {
616  _has_bits_[0] &= ~0x00000020u;
617 }
618 inline void Schema::clear_update_timestamp() {
619  update_timestamp_ = GOOGLE_ULONGLONG(0);
620  clear_has_update_timestamp();
621 }
622 inline ::google::protobuf::uint64 Schema::update_timestamp() const {
623  return update_timestamp_;
624 }
625 inline void Schema::set_update_timestamp(::google::protobuf::uint64 value) {
626  set_has_update_timestamp();
627  update_timestamp_ = value;
628 }
629 
630 // optional string uuid = 13;
631 inline bool Schema::has_uuid() const {
632  return (_has_bits_[0] & 0x00000040u) != 0;
633 }
634 inline void Schema::set_has_uuid() {
635  _has_bits_[0] |= 0x00000040u;
636 }
637 inline void Schema::clear_has_uuid() {
638  _has_bits_[0] &= ~0x00000040u;
639 }
640 inline void Schema::clear_uuid() {
641  if (uuid_ != &::google::protobuf::internal::kEmptyString) {
642  uuid_->clear();
643  }
644  clear_has_uuid();
645 }
646 inline const ::std::string& Schema::uuid() const {
647  return *uuid_;
648 }
649 inline void Schema::set_uuid(const ::std::string& value) {
650  set_has_uuid();
651  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
652  uuid_ = new ::std::string;
653  }
654  uuid_->assign(value);
655 }
656 inline void Schema::set_uuid(const char* value) {
657  set_has_uuid();
658  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
659  uuid_ = new ::std::string;
660  }
661  uuid_->assign(value);
662 }
663 inline void Schema::set_uuid(const char* value, size_t size) {
664  set_has_uuid();
665  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
666  uuid_ = new ::std::string;
667  }
668  uuid_->assign(reinterpret_cast<const char*>(value), size);
669 }
670 inline ::std::string* Schema::mutable_uuid() {
671  set_has_uuid();
672  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
673  uuid_ = new ::std::string;
674  }
675  return uuid_;
676 }
677 inline ::std::string* Schema::release_uuid() {
678  clear_has_uuid();
679  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
680  return NULL;
681  } else {
682  ::std::string* temp = uuid_;
683  uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
684  return temp;
685  }
686 }
687 inline void Schema::set_allocated_uuid(::std::string* uuid) {
688  if (uuid_ != &::google::protobuf::internal::kEmptyString) {
689  delete uuid_;
690  }
691  if (uuid) {
692  set_has_uuid();
693  uuid_ = uuid;
694  } else {
695  clear_has_uuid();
696  uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
697  }
698 }
699 
700 // optional uint64 version = 14;
701 inline bool Schema::has_version() const {
702  return (_has_bits_[0] & 0x00000080u) != 0;
703 }
704 inline void Schema::set_has_version() {
705  _has_bits_[0] |= 0x00000080u;
706 }
707 inline void Schema::clear_has_version() {
708  _has_bits_[0] &= ~0x00000080u;
709 }
710 inline void Schema::clear_version() {
711  version_ = GOOGLE_ULONGLONG(0);
712  clear_has_version();
713 }
714 inline ::google::protobuf::uint64 Schema::version() const {
715  return version_;
716 }
717 inline void Schema::set_version(::google::protobuf::uint64 value) {
718  set_has_version();
719  version_ = value;
720 }
721 
722 // optional .drizzled.message.Schema.Options options = 15;
723 inline bool Schema::has_options() const {
724  return (_has_bits_[0] & 0x00000100u) != 0;
725 }
726 inline void Schema::set_has_options() {
727  _has_bits_[0] |= 0x00000100u;
728 }
729 inline void Schema::clear_has_options() {
730  _has_bits_[0] &= ~0x00000100u;
731 }
732 inline void Schema::clear_options() {
733  if (options_ != NULL) options_->::drizzled::message::Schema_Options::Clear();
734  clear_has_options();
735 }
736 inline const ::drizzled::message::Schema_Options& Schema::options() const {
737  return options_ != NULL ? *options_ : *default_instance_->options_;
738 }
739 inline ::drizzled::message::Schema_Options* Schema::mutable_options() {
740  set_has_options();
741  if (options_ == NULL) options_ = new ::drizzled::message::Schema_Options;
742  return options_;
743 }
744 inline ::drizzled::message::Schema_Options* Schema::release_options() {
745  clear_has_options();
746  ::drizzled::message::Schema_Options* temp = options_;
747  options_ = NULL;
748  return temp;
749 }
750 inline void Schema::set_allocated_options(::drizzled::message::Schema_Options* options) {
751  delete options_;
752  options_ = options;
753  if (options) {
754  set_has_options();
755  } else {
756  clear_has_options();
757  }
758 }
759 
760 // optional .drizzled.message.ReplicationOptions replication_options = 16;
761 inline bool Schema::has_replication_options() const {
762  return (_has_bits_[0] & 0x00000200u) != 0;
763 }
764 inline void Schema::set_has_replication_options() {
765  _has_bits_[0] |= 0x00000200u;
766 }
767 inline void Schema::clear_has_replication_options() {
768  _has_bits_[0] &= ~0x00000200u;
769 }
770 inline void Schema::clear_replication_options() {
771  if (replication_options_ != NULL) replication_options_->::drizzled::message::ReplicationOptions::Clear();
772  clear_has_replication_options();
773 }
774 inline const ::drizzled::message::ReplicationOptions& Schema::replication_options() const {
775  return replication_options_ != NULL ? *replication_options_ : *default_instance_->replication_options_;
776 }
777 inline ::drizzled::message::ReplicationOptions* Schema::mutable_replication_options() {
778  set_has_replication_options();
779  if (replication_options_ == NULL) replication_options_ = new ::drizzled::message::ReplicationOptions;
780  return replication_options_;
781 }
782 inline ::drizzled::message::ReplicationOptions* Schema::release_replication_options() {
783  clear_has_replication_options();
784  ::drizzled::message::ReplicationOptions* temp = replication_options_;
785  replication_options_ = NULL;
786  return temp;
787 }
788 inline void Schema::set_allocated_replication_options(::drizzled::message::ReplicationOptions* replication_options) {
789  delete replication_options_;
790  replication_options_ = replication_options;
791  if (replication_options) {
792  set_has_replication_options();
793  } else {
794  clear_has_replication_options();
795  }
796 }
797 
798 // optional .drizzled.message.Access access = 17;
799 inline bool Schema::has_access() const {
800  return (_has_bits_[0] & 0x00000400u) != 0;
801 }
802 inline void Schema::set_has_access() {
803  _has_bits_[0] |= 0x00000400u;
804 }
805 inline void Schema::clear_has_access() {
806  _has_bits_[0] &= ~0x00000400u;
807 }
808 inline void Schema::clear_access() {
809  if (access_ != NULL) access_->::drizzled::message::Access::Clear();
810  clear_has_access();
811 }
812 inline const ::drizzled::message::Access& Schema::access() const {
813  return access_ != NULL ? *access_ : *default_instance_->access_;
814 }
815 inline ::drizzled::message::Access* Schema::mutable_access() {
816  set_has_access();
817  if (access_ == NULL) access_ = new ::drizzled::message::Access;
818  return access_;
819 }
820 inline ::drizzled::message::Access* Schema::release_access() {
821  clear_has_access();
822  ::drizzled::message::Access* temp = access_;
823  access_ = NULL;
824  return temp;
825 }
826 inline void Schema::set_allocated_access(::drizzled::message::Access* access) {
827  delete access_;
828  access_ = access;
829  if (access) {
830  set_has_access();
831  } else {
832  clear_has_access();
833  }
834 }
835 
836 
837 // @@protoc_insertion_point(namespace_scope)
838 
839 } // namespace message
840 } // namespace drizzled
841 
842 #ifndef SWIG
843 namespace google {
844 namespace protobuf {
845 
846 
847 } // namespace google
848 } // namespace protobuf
849 #endif // SWIG
850 
851 // @@protoc_insertion_point(global_scope)
852 
853 #endif // PROTOBUF_schema_2eproto__INCLUDED
Definition: schema.h:30