Drizzled Public API Documentation

engine.pb.cc

00001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
00002 
00003 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
00004 #include "engine.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* Engine_descriptor_ = NULL;
00019 const ::google::protobuf::internal::GeneratedMessageReflection*
00020   Engine_reflection_ = NULL;
00021 const ::google::protobuf::Descriptor* Engine_Option_descriptor_ = NULL;
00022 const ::google::protobuf::internal::GeneratedMessageReflection*
00023   Engine_Option_reflection_ = NULL;
00024 
00025 }  // namespace
00026 
00027 
00028 void protobuf_AssignDesc_engine_2eproto() {
00029   protobuf_AddDesc_engine_2eproto();
00030   const ::google::protobuf::FileDescriptor* file =
00031     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
00032       "engine.proto");
00033   GOOGLE_CHECK(file != NULL);
00034   Engine_descriptor_ = file->message_type(0);
00035   static const int Engine_offsets_[2] = {
00036     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine, name_),
00037     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine, options_),
00038   };
00039   Engine_reflection_ =
00040     new ::google::protobuf::internal::GeneratedMessageReflection(
00041       Engine_descriptor_,
00042       Engine::default_instance_,
00043       Engine_offsets_,
00044       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine, _has_bits_[0]),
00045       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine, _unknown_fields_),
00046       -1,
00047       ::google::protobuf::DescriptorPool::generated_pool(),
00048       ::google::protobuf::MessageFactory::generated_factory(),
00049       sizeof(Engine));
00050   Engine_Option_descriptor_ = Engine_descriptor_->nested_type(0);
00051   static const int Engine_Option_offsets_[2] = {
00052     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine_Option, name_),
00053     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine_Option, state_),
00054   };
00055   Engine_Option_reflection_ =
00056     new ::google::protobuf::internal::GeneratedMessageReflection(
00057       Engine_Option_descriptor_,
00058       Engine_Option::default_instance_,
00059       Engine_Option_offsets_,
00060       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine_Option, _has_bits_[0]),
00061       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine_Option, _unknown_fields_),
00062       -1,
00063       ::google::protobuf::DescriptorPool::generated_pool(),
00064       ::google::protobuf::MessageFactory::generated_factory(),
00065       sizeof(Engine_Option));
00066 }
00067 
00068 namespace {
00069 
00070 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
00071 inline void protobuf_AssignDescriptorsOnce() {
00072   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
00073                  &protobuf_AssignDesc_engine_2eproto);
00074 }
00075 
00076 void protobuf_RegisterTypes(const ::std::string&) {
00077   protobuf_AssignDescriptorsOnce();
00078   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00079     Engine_descriptor_, &Engine::default_instance());
00080   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00081     Engine_Option_descriptor_, &Engine_Option::default_instance());
00082 }
00083 
00084 }  // namespace
00085 
00086 void protobuf_ShutdownFile_engine_2eproto() {
00087   delete Engine::default_instance_;
00088   delete Engine_reflection_;
00089   delete Engine_Option::default_instance_;
00090   delete Engine_Option_reflection_;
00091 }
00092 
00093 void protobuf_AddDesc_engine_2eproto() {
00094   static bool already_here = false;
00095   if (already_here) return;
00096   already_here = true;
00097   GOOGLE_PROTOBUF_VERIFY_VERSION;
00098 
00099   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
00100     "\n\014engine.proto\022\020drizzled.message\"o\n\006Engi"
00101     "ne\022\014\n\004name\030\001 \002(\t\0220\n\007options\030\002 \003(\0132\037.driz"
00102     "zled.message.Engine.Option\032%\n\006Option\022\014\n\004"
00103     "name\030\001 \002(\t\022\r\n\005state\030\002 \001(\tB\'\n\024org.drizzle"
00104     ".messagesB\rEngineMessageH\001", 186);
00105   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
00106     "engine.proto", &protobuf_RegisterTypes);
00107   Engine::default_instance_ = new Engine();
00108   Engine_Option::default_instance_ = new Engine_Option();
00109   Engine::default_instance_->InitAsDefaultInstance();
00110   Engine_Option::default_instance_->InitAsDefaultInstance();
00111   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_engine_2eproto);
00112 }
00113 
00114 // Force AddDescriptors() to be called at static initialization time.
00115 struct StaticDescriptorInitializer_engine_2eproto {
00116   StaticDescriptorInitializer_engine_2eproto() {
00117     protobuf_AddDesc_engine_2eproto();
00118   }
00119 } static_descriptor_initializer_engine_2eproto_;
00120 
00121 
00122 // ===================================================================
00123 
00124 const ::std::string Engine_Option::_default_name_;
00125 const ::std::string Engine_Option::_default_state_;
00126 #ifndef _MSC_VER
00127 const int Engine_Option::kNameFieldNumber;
00128 const int Engine_Option::kStateFieldNumber;
00129 #endif  // !_MSC_VER
00130 
00131 Engine_Option::Engine_Option()
00132   : ::google::protobuf::Message() {
00133   SharedCtor();
00134 }
00135 
00136 void Engine_Option::InitAsDefaultInstance() {
00137 }
00138 
00139 Engine_Option::Engine_Option(const Engine_Option& from)
00140   : ::google::protobuf::Message() {
00141   SharedCtor();
00142   MergeFrom(from);
00143 }
00144 
00145 void Engine_Option::SharedCtor() {
00146   _cached_size_ = 0;
00147   name_ = const_cast< ::std::string*>(&_default_name_);
00148   state_ = const_cast< ::std::string*>(&_default_state_);
00149   ::memset(_has_bits_, 0, sizeof(_has_bits_));
00150 }
00151 
00152 Engine_Option::~Engine_Option() {
00153   SharedDtor();
00154 }
00155 
00156 void Engine_Option::SharedDtor() {
00157   if (name_ != &_default_name_) {
00158     delete name_;
00159   }
00160   if (state_ != &_default_state_) {
00161     delete state_;
00162   }
00163   if (this != default_instance_) {
00164   }
00165 }
00166 
00167 void Engine_Option::SetCachedSize(int size) const {
00168   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00169   _cached_size_ = size;
00170   GOOGLE_SAFE_CONCURRENT_WRITES_END();
00171 }
00172 const ::google::protobuf::Descriptor* Engine_Option::descriptor() {
00173   protobuf_AssignDescriptorsOnce();
00174   return Engine_Option_descriptor_;
00175 }
00176 
00177 const Engine_Option& Engine_Option::default_instance() {
00178   if (default_instance_ == NULL) protobuf_AddDesc_engine_2eproto();  return *default_instance_;
00179 }
00180 
00181 Engine_Option* Engine_Option::default_instance_ = NULL;
00182 
00183 Engine_Option* Engine_Option::New() const {
00184   return new Engine_Option;
00185 }
00186 
00187 void Engine_Option::Clear() {
00188   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00189     if (_has_bit(0)) {
00190       if (name_ != &_default_name_) {
00191         name_->clear();
00192       }
00193     }
00194     if (_has_bit(1)) {
00195       if (state_ != &_default_state_) {
00196         state_->clear();
00197       }
00198     }
00199   }
00200   ::memset(_has_bits_, 0, sizeof(_has_bits_));
00201   mutable_unknown_fields()->Clear();
00202 }
00203 
00204 bool Engine_Option::MergePartialFromCodedStream(
00205     ::google::protobuf::io::CodedInputStream* input) {
00206 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
00207   ::google::protobuf::uint32 tag;
00208   while ((tag = input->ReadTag()) != 0) {
00209     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
00210       // required string name = 1;
00211       case 1: {
00212         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00213             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00214           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00215                 input, this->mutable_name()));
00216           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00217             this->name().data(), this->name().length(),
00218             ::google::protobuf::internal::WireFormat::PARSE);
00219         } else {
00220           goto handle_uninterpreted;
00221         }
00222         if (input->ExpectTag(18)) goto parse_state;
00223         break;
00224       }
00225       
00226       // optional string state = 2;
00227       case 2: {
00228         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00229             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00230          parse_state:
00231           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00232                 input, this->mutable_state()));
00233           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00234             this->state().data(), this->state().length(),
00235             ::google::protobuf::internal::WireFormat::PARSE);
00236         } else {
00237           goto handle_uninterpreted;
00238         }
00239         if (input->ExpectAtEnd()) return true;
00240         break;
00241       }
00242       
00243       default: {
00244       handle_uninterpreted:
00245         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00246             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
00247           return true;
00248         }
00249         DO_(::google::protobuf::internal::WireFormat::SkipField(
00250               input, tag, mutable_unknown_fields()));
00251         break;
00252       }
00253     }
00254   }
00255   return true;
00256 #undef DO_
00257 }
00258 
00259 void Engine_Option::SerializeWithCachedSizes(
00260     ::google::protobuf::io::CodedOutputStream* output) const {
00261   // required string name = 1;
00262   if (_has_bit(0)) {
00263     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00264       this->name().data(), this->name().length(),
00265       ::google::protobuf::internal::WireFormat::SERIALIZE);
00266     ::google::protobuf::internal::WireFormatLite::WriteString(
00267       1, this->name(), output);
00268   }
00269   
00270   // optional string state = 2;
00271   if (_has_bit(1)) {
00272     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00273       this->state().data(), this->state().length(),
00274       ::google::protobuf::internal::WireFormat::SERIALIZE);
00275     ::google::protobuf::internal::WireFormatLite::WriteString(
00276       2, this->state(), output);
00277   }
00278   
00279   if (!unknown_fields().empty()) {
00280     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
00281         unknown_fields(), output);
00282   }
00283 }
00284 
00285 ::google::protobuf::uint8* Engine_Option::SerializeWithCachedSizesToArray(
00286     ::google::protobuf::uint8* target) const {
00287   // required string name = 1;
00288   if (_has_bit(0)) {
00289     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00290       this->name().data(), this->name().length(),
00291       ::google::protobuf::internal::WireFormat::SERIALIZE);
00292     target =
00293       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00294         1, this->name(), target);
00295   }
00296   
00297   // optional string state = 2;
00298   if (_has_bit(1)) {
00299     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00300       this->state().data(), this->state().length(),
00301       ::google::protobuf::internal::WireFormat::SERIALIZE);
00302     target =
00303       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00304         2, this->state(), target);
00305   }
00306   
00307   if (!unknown_fields().empty()) {
00308     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
00309         unknown_fields(), target);
00310   }
00311   return target;
00312 }
00313 
00314 int Engine_Option::ByteSize() const {
00315   int total_size = 0;
00316   
00317   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00318     // required string name = 1;
00319     if (has_name()) {
00320       total_size += 1 +
00321         ::google::protobuf::internal::WireFormatLite::StringSize(
00322           this->name());
00323     }
00324     
00325     // optional string state = 2;
00326     if (has_state()) {
00327       total_size += 1 +
00328         ::google::protobuf::internal::WireFormatLite::StringSize(
00329           this->state());
00330     }
00331     
00332   }
00333   if (!unknown_fields().empty()) {
00334     total_size +=
00335       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
00336         unknown_fields());
00337   }
00338   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00339   _cached_size_ = total_size;
00340   GOOGLE_SAFE_CONCURRENT_WRITES_END();
00341   return total_size;
00342 }
00343 
00344 void Engine_Option::MergeFrom(const ::google::protobuf::Message& from) {
00345   GOOGLE_CHECK_NE(&from, this);
00346   const Engine_Option* source =
00347     ::google::protobuf::internal::dynamic_cast_if_available<const Engine_Option*>(
00348       &from);
00349   if (source == NULL) {
00350     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
00351   } else {
00352     MergeFrom(*source);
00353   }
00354 }
00355 
00356 void Engine_Option::MergeFrom(const Engine_Option& from) {
00357   GOOGLE_CHECK_NE(&from, this);
00358   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00359     if (from._has_bit(0)) {
00360       set_name(from.name());
00361     }
00362     if (from._has_bit(1)) {
00363       set_state(from.state());
00364     }
00365   }
00366   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
00367 }
00368 
00369 void Engine_Option::CopyFrom(const ::google::protobuf::Message& from) {
00370   if (&from == this) return;
00371   Clear();
00372   MergeFrom(from);
00373 }
00374 
00375 void Engine_Option::CopyFrom(const Engine_Option& from) {
00376   if (&from == this) return;
00377   Clear();
00378   MergeFrom(from);
00379 }
00380 
00381 bool Engine_Option::IsInitialized() const {
00382   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
00383   
00384   return true;
00385 }
00386 
00387 void Engine_Option::Swap(Engine_Option* other) {
00388   if (other != this) {
00389     std::swap(name_, other->name_);
00390     std::swap(state_, other->state_);
00391     std::swap(_has_bits_[0], other->_has_bits_[0]);
00392     _unknown_fields_.Swap(&other->_unknown_fields_);
00393     std::swap(_cached_size_, other->_cached_size_);
00394   }
00395 }
00396 
00397 ::google::protobuf::Metadata Engine_Option::GetMetadata() const {
00398   protobuf_AssignDescriptorsOnce();
00399   ::google::protobuf::Metadata metadata;
00400   metadata.descriptor = Engine_Option_descriptor_;
00401   metadata.reflection = Engine_Option_reflection_;
00402   return metadata;
00403 }
00404 
00405 
00406 // -------------------------------------------------------------------
00407 
00408 const ::std::string Engine::_default_name_;
00409 #ifndef _MSC_VER
00410 const int Engine::kNameFieldNumber;
00411 const int Engine::kOptionsFieldNumber;
00412 #endif  // !_MSC_VER
00413 
00414 Engine::Engine()
00415   : ::google::protobuf::Message() {
00416   SharedCtor();
00417 }
00418 
00419 void Engine::InitAsDefaultInstance() {
00420 }
00421 
00422 Engine::Engine(const Engine& from)
00423   : ::google::protobuf::Message() {
00424   SharedCtor();
00425   MergeFrom(from);
00426 }
00427 
00428 void Engine::SharedCtor() {
00429   _cached_size_ = 0;
00430   name_ = const_cast< ::std::string*>(&_default_name_);
00431   ::memset(_has_bits_, 0, sizeof(_has_bits_));
00432 }
00433 
00434 Engine::~Engine() {
00435   SharedDtor();
00436 }
00437 
00438 void Engine::SharedDtor() {
00439   if (name_ != &_default_name_) {
00440     delete name_;
00441   }
00442   if (this != default_instance_) {
00443   }
00444 }
00445 
00446 void Engine::SetCachedSize(int size) const {
00447   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00448   _cached_size_ = size;
00449   GOOGLE_SAFE_CONCURRENT_WRITES_END();
00450 }
00451 const ::google::protobuf::Descriptor* Engine::descriptor() {
00452   protobuf_AssignDescriptorsOnce();
00453   return Engine_descriptor_;
00454 }
00455 
00456 const Engine& Engine::default_instance() {
00457   if (default_instance_ == NULL) protobuf_AddDesc_engine_2eproto();  return *default_instance_;
00458 }
00459 
00460 Engine* Engine::default_instance_ = NULL;
00461 
00462 Engine* Engine::New() const {
00463   return new Engine;
00464 }
00465 
00466 void Engine::Clear() {
00467   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00468     if (_has_bit(0)) {
00469       if (name_ != &_default_name_) {
00470         name_->clear();
00471       }
00472     }
00473   }
00474   options_.Clear();
00475   ::memset(_has_bits_, 0, sizeof(_has_bits_));
00476   mutable_unknown_fields()->Clear();
00477 }
00478 
00479 bool Engine::MergePartialFromCodedStream(
00480     ::google::protobuf::io::CodedInputStream* input) {
00481 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
00482   ::google::protobuf::uint32 tag;
00483   while ((tag = input->ReadTag()) != 0) {
00484     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
00485       // required string name = 1;
00486       case 1: {
00487         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00488             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00489           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00490                 input, this->mutable_name()));
00491           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00492             this->name().data(), this->name().length(),
00493             ::google::protobuf::internal::WireFormat::PARSE);
00494         } else {
00495           goto handle_uninterpreted;
00496         }
00497         if (input->ExpectTag(18)) goto parse_options;
00498         break;
00499       }
00500       
00501       // repeated .drizzled.message.Engine.Option options = 2;
00502       case 2: {
00503         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00504             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00505          parse_options:
00506           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
00507                 input, add_options()));
00508         } else {
00509           goto handle_uninterpreted;
00510         }
00511         if (input->ExpectTag(18)) goto parse_options;
00512         if (input->ExpectAtEnd()) return true;
00513         break;
00514       }
00515       
00516       default: {
00517       handle_uninterpreted:
00518         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00519             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
00520           return true;
00521         }
00522         DO_(::google::protobuf::internal::WireFormat::SkipField(
00523               input, tag, mutable_unknown_fields()));
00524         break;
00525       }
00526     }
00527   }
00528   return true;
00529 #undef DO_
00530 }
00531 
00532 void Engine::SerializeWithCachedSizes(
00533     ::google::protobuf::io::CodedOutputStream* output) const {
00534   // required string name = 1;
00535   if (_has_bit(0)) {
00536     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00537       this->name().data(), this->name().length(),
00538       ::google::protobuf::internal::WireFormat::SERIALIZE);
00539     ::google::protobuf::internal::WireFormatLite::WriteString(
00540       1, this->name(), output);
00541   }
00542   
00543   // repeated .drizzled.message.Engine.Option options = 2;
00544   for (int i = 0; i < this->options_size(); i++) {
00545     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
00546       2, this->options(i), output);
00547   }
00548   
00549   if (!unknown_fields().empty()) {
00550     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
00551         unknown_fields(), output);
00552   }
00553 }
00554 
00555 ::google::protobuf::uint8* Engine::SerializeWithCachedSizesToArray(
00556     ::google::protobuf::uint8* target) const {
00557   // required string name = 1;
00558   if (_has_bit(0)) {
00559     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00560       this->name().data(), this->name().length(),
00561       ::google::protobuf::internal::WireFormat::SERIALIZE);
00562     target =
00563       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00564         1, this->name(), target);
00565   }
00566   
00567   // repeated .drizzled.message.Engine.Option options = 2;
00568   for (int i = 0; i < this->options_size(); i++) {
00569     target = ::google::protobuf::internal::WireFormatLite::
00570       WriteMessageNoVirtualToArray(
00571         2, this->options(i), target);
00572   }
00573   
00574   if (!unknown_fields().empty()) {
00575     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
00576         unknown_fields(), target);
00577   }
00578   return target;
00579 }
00580 
00581 int Engine::ByteSize() const {
00582   int total_size = 0;
00583   
00584   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00585     // required string name = 1;
00586     if (has_name()) {
00587       total_size += 1 +
00588         ::google::protobuf::internal::WireFormatLite::StringSize(
00589           this->name());
00590     }
00591     
00592   }
00593   // repeated .drizzled.message.Engine.Option options = 2;
00594   total_size += 1 * this->options_size();
00595   for (int i = 0; i < this->options_size(); i++) {
00596     total_size +=
00597       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
00598         this->options(i));
00599   }
00600   
00601   if (!unknown_fields().empty()) {
00602     total_size +=
00603       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
00604         unknown_fields());
00605   }
00606   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00607   _cached_size_ = total_size;
00608   GOOGLE_SAFE_CONCURRENT_WRITES_END();
00609   return total_size;
00610 }
00611 
00612 void Engine::MergeFrom(const ::google::protobuf::Message& from) {
00613   GOOGLE_CHECK_NE(&from, this);
00614   const Engine* source =
00615     ::google::protobuf::internal::dynamic_cast_if_available<const Engine*>(
00616       &from);
00617   if (source == NULL) {
00618     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
00619   } else {
00620     MergeFrom(*source);
00621   }
00622 }
00623 
00624 void Engine::MergeFrom(const Engine& from) {
00625   GOOGLE_CHECK_NE(&from, this);
00626   options_.MergeFrom(from.options_);
00627   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00628     if (from._has_bit(0)) {
00629       set_name(from.name());
00630     }
00631   }
00632   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
00633 }
00634 
00635 void Engine::CopyFrom(const ::google::protobuf::Message& from) {
00636   if (&from == this) return;
00637   Clear();
00638   MergeFrom(from);
00639 }
00640 
00641 void Engine::CopyFrom(const Engine& from) {
00642   if (&from == this) return;
00643   Clear();
00644   MergeFrom(from);
00645 }
00646 
00647 bool Engine::IsInitialized() const {
00648   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
00649   
00650   for (int i = 0; i < options_size(); i++) {
00651     if (!this->options(i).IsInitialized()) return false;
00652   }
00653   return true;
00654 }
00655 
00656 void Engine::Swap(Engine* other) {
00657   if (other != this) {
00658     std::swap(name_, other->name_);
00659     options_.Swap(&other->options_);
00660     std::swap(_has_bits_[0], other->_has_bits_[0]);
00661     _unknown_fields_.Swap(&other->_unknown_fields_);
00662     std::swap(_cached_size_, other->_cached_size_);
00663   }
00664 }
00665 
00666 ::google::protobuf::Metadata Engine::GetMetadata() const {
00667   protobuf_AssignDescriptorsOnce();
00668   ::google::protobuf::Metadata metadata;
00669   metadata.descriptor = Engine_descriptor_;
00670   metadata.reflection = Engine_reflection_;
00671   return metadata;
00672 }
00673 
00674 
00675 // @@protoc_insertion_point(namespace_scope)
00676 
00677 }  // namespace message
00678 }  // namespace drizzled
00679 
00680 // @@protoc_insertion_point(global_scope)