Drizzled Public API Documentation

replication_options.pb.cc
00001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
00002 
00003 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
00004 #include "replication_options.pb.h"
00005 
00006 #include <algorithm>
00007 
00008 #include <google/protobuf/stubs/once.h>
00009 #include <google/protobuf/io/coded_stream.h>
00010 #include <google/protobuf/wire_format_lite_inl.h>
00011 #include <google/protobuf/descriptor.h>
00012 #include <google/protobuf/reflection_ops.h>
00013 #include <google/protobuf/wire_format.h>
00014 // @@protoc_insertion_point(includes)
00015 
00016 namespace drizzled {
00017 namespace message {
00018 
00019 namespace {
00020 
00021 const ::google::protobuf::Descriptor* ReplicationOptions_descriptor_ = NULL;
00022 const ::google::protobuf::internal::GeneratedMessageReflection*
00023   ReplicationOptions_reflection_ = NULL;
00024 
00025 }  // namespace
00026 
00027 
00028 void protobuf_AssignDesc_replication_5foptions_2eproto() {
00029   protobuf_AddDesc_replication_5foptions_2eproto();
00030   const ::google::protobuf::FileDescriptor* file =
00031     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
00032       "replication_options.proto");
00033   GOOGLE_CHECK(file != NULL);
00034   ReplicationOptions_descriptor_ = file->message_type(0);
00035   static const int ReplicationOptions_offsets_[1] = {
00036     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicationOptions, is_replicated_),
00037   };
00038   ReplicationOptions_reflection_ =
00039     new ::google::protobuf::internal::GeneratedMessageReflection(
00040       ReplicationOptions_descriptor_,
00041       ReplicationOptions::default_instance_,
00042       ReplicationOptions_offsets_,
00043       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicationOptions, _has_bits_[0]),
00044       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicationOptions, _unknown_fields_),
00045       -1,
00046       ::google::protobuf::DescriptorPool::generated_pool(),
00047       ::google::protobuf::MessageFactory::generated_factory(),
00048       sizeof(ReplicationOptions));
00049 }
00050 
00051 namespace {
00052 
00053 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
00054 inline void protobuf_AssignDescriptorsOnce() {
00055   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
00056                  &protobuf_AssignDesc_replication_5foptions_2eproto);
00057 }
00058 
00059 void protobuf_RegisterTypes(const ::std::string&) {
00060   protobuf_AssignDescriptorsOnce();
00061   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00062     ReplicationOptions_descriptor_, &ReplicationOptions::default_instance());
00063 }
00064 
00065 }  // namespace
00066 
00067 void protobuf_ShutdownFile_replication_5foptions_2eproto() {
00068   delete ReplicationOptions::default_instance_;
00069   delete ReplicationOptions_reflection_;
00070 }
00071 
00072 void protobuf_AddDesc_replication_5foptions_2eproto() {
00073   static bool already_here = false;
00074   if (already_here) return;
00075   already_here = true;
00076   GOOGLE_PROTOBUF_VERIFY_VERSION;
00077 
00078   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
00079     "\n\031replication_options.proto\022\020drizzled.me"
00080     "ssage\"+\n\022ReplicationOptions\022\025\n\ris_replic"
00081     "ated\030\002 \001(\010B%\n\024org.drizzle.messagesB\013Repl"
00082     "icationH\001", 129);
00083   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
00084     "replication_options.proto", &protobuf_RegisterTypes);
00085   ReplicationOptions::default_instance_ = new ReplicationOptions();
00086   ReplicationOptions::default_instance_->InitAsDefaultInstance();
00087   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_replication_5foptions_2eproto);
00088 }
00089 
00090 // Force AddDescriptors() to be called at static initialization time.
00091 struct StaticDescriptorInitializer_replication_5foptions_2eproto {
00092   StaticDescriptorInitializer_replication_5foptions_2eproto() {
00093     protobuf_AddDesc_replication_5foptions_2eproto();
00094   }
00095 } static_descriptor_initializer_replication_5foptions_2eproto_;
00096 
00097 
00098 // ===================================================================
00099 
00100 #ifndef _MSC_VER
00101 const int ReplicationOptions::kIsReplicatedFieldNumber;
00102 #endif  // !_MSC_VER
00103 
00104 ReplicationOptions::ReplicationOptions()
00105   : ::google::protobuf::Message() {
00106   SharedCtor();
00107 }
00108 
00109 void ReplicationOptions::InitAsDefaultInstance() {
00110 }
00111 
00112 ReplicationOptions::ReplicationOptions(const ReplicationOptions& from)
00113   : ::google::protobuf::Message() {
00114   SharedCtor();
00115   MergeFrom(from);
00116 }
00117 
00118 void ReplicationOptions::SharedCtor() {
00119   _cached_size_ = 0;
00120   is_replicated_ = false;
00121   ::memset(_has_bits_, 0, sizeof(_has_bits_));
00122 }
00123 
00124 ReplicationOptions::~ReplicationOptions() {
00125   SharedDtor();
00126 }
00127 
00128 void ReplicationOptions::SharedDtor() {
00129   if (this != default_instance_) {
00130   }
00131 }
00132 
00133 void ReplicationOptions::SetCachedSize(int size) const {
00134   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00135   _cached_size_ = size;
00136   GOOGLE_SAFE_CONCURRENT_WRITES_END();
00137 }
00138 const ::google::protobuf::Descriptor* ReplicationOptions::descriptor() {
00139   protobuf_AssignDescriptorsOnce();
00140   return ReplicationOptions_descriptor_;
00141 }
00142 
00143 const ReplicationOptions& ReplicationOptions::default_instance() {
00144   if (default_instance_ == NULL) protobuf_AddDesc_replication_5foptions_2eproto();  return *default_instance_;
00145 }
00146 
00147 ReplicationOptions* ReplicationOptions::default_instance_ = NULL;
00148 
00149 ReplicationOptions* ReplicationOptions::New() const {
00150   return new ReplicationOptions;
00151 }
00152 
00153 void ReplicationOptions::Clear() {
00154   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00155     is_replicated_ = false;
00156   }
00157   ::memset(_has_bits_, 0, sizeof(_has_bits_));
00158   mutable_unknown_fields()->Clear();
00159 }
00160 
00161 bool ReplicationOptions::MergePartialFromCodedStream(
00162     ::google::protobuf::io::CodedInputStream* input) {
00163 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
00164   ::google::protobuf::uint32 tag;
00165   while ((tag = input->ReadTag()) != 0) {
00166     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
00167       // optional bool is_replicated = 2;
00168       case 2: {
00169         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00170             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
00171           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
00172                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
00173                  input, &is_replicated_)));
00174           set_has_is_replicated();
00175         } else {
00176           goto handle_uninterpreted;
00177         }
00178         if (input->ExpectAtEnd()) return true;
00179         break;
00180       }
00181       
00182       default: {
00183       handle_uninterpreted:
00184         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00185             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
00186           return true;
00187         }
00188         DO_(::google::protobuf::internal::WireFormat::SkipField(
00189               input, tag, mutable_unknown_fields()));
00190         break;
00191       }
00192     }
00193   }
00194   return true;
00195 #undef DO_
00196 }
00197 
00198 void ReplicationOptions::SerializeWithCachedSizes(
00199     ::google::protobuf::io::CodedOutputStream* output) const {
00200   // optional bool is_replicated = 2;
00201   if (has_is_replicated()) {
00202     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->is_replicated(), output);
00203   }
00204   
00205   if (!unknown_fields().empty()) {
00206     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
00207         unknown_fields(), output);
00208   }
00209 }
00210 
00211 ::google::protobuf::uint8* ReplicationOptions::SerializeWithCachedSizesToArray(
00212     ::google::protobuf::uint8* target) const {
00213   // optional bool is_replicated = 2;
00214   if (has_is_replicated()) {
00215     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->is_replicated(), target);
00216   }
00217   
00218   if (!unknown_fields().empty()) {
00219     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
00220         unknown_fields(), target);
00221   }
00222   return target;
00223 }
00224 
00225 int ReplicationOptions::ByteSize() const {
00226   int total_size = 0;
00227   
00228   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00229     // optional bool is_replicated = 2;
00230     if (has_is_replicated()) {
00231       total_size += 1 + 1;
00232     }
00233     
00234   }
00235   if (!unknown_fields().empty()) {
00236     total_size +=
00237       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
00238         unknown_fields());
00239   }
00240   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00241   _cached_size_ = total_size;
00242   GOOGLE_SAFE_CONCURRENT_WRITES_END();
00243   return total_size;
00244 }
00245 
00246 void ReplicationOptions::MergeFrom(const ::google::protobuf::Message& from) {
00247   GOOGLE_CHECK_NE(&from, this);
00248   const ReplicationOptions* source =
00249     ::google::protobuf::internal::dynamic_cast_if_available<const ReplicationOptions*>(
00250       &from);
00251   if (source == NULL) {
00252     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
00253   } else {
00254     MergeFrom(*source);
00255   }
00256 }
00257 
00258 void ReplicationOptions::MergeFrom(const ReplicationOptions& from) {
00259   GOOGLE_CHECK_NE(&from, this);
00260   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00261     if (from.has_is_replicated()) {
00262       set_is_replicated(from.is_replicated());
00263     }
00264   }
00265   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
00266 }
00267 
00268 void ReplicationOptions::CopyFrom(const ::google::protobuf::Message& from) {
00269   if (&from == this) return;
00270   Clear();
00271   MergeFrom(from);
00272 }
00273 
00274 void ReplicationOptions::CopyFrom(const ReplicationOptions& from) {
00275   if (&from == this) return;
00276   Clear();
00277   MergeFrom(from);
00278 }
00279 
00280 bool ReplicationOptions::IsInitialized() const {
00281   
00282   return true;
00283 }
00284 
00285 void ReplicationOptions::Swap(ReplicationOptions* other) {
00286   if (other != this) {
00287     std::swap(is_replicated_, other->is_replicated_);
00288     std::swap(_has_bits_[0], other->_has_bits_[0]);
00289     _unknown_fields_.Swap(&other->_unknown_fields_);
00290     std::swap(_cached_size_, other->_cached_size_);
00291   }
00292 }
00293 
00294 ::google::protobuf::Metadata ReplicationOptions::GetMetadata() const {
00295   protobuf_AssignDescriptorsOnce();
00296   ::google::protobuf::Metadata metadata;
00297   metadata.descriptor = ReplicationOptions_descriptor_;
00298   metadata.reflection = ReplicationOptions_reflection_;
00299   return metadata;
00300 }
00301 
00302 
00303 // @@protoc_insertion_point(namespace_scope)
00304 
00305 }  // namespace message
00306 }  // namespace drizzled
00307 
00308 // @@protoc_insertion_point(global_scope)