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