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