00001
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
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 }
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 }
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
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
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
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
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
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
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
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
00319 if (has_name()) {
00320 total_size += 1 +
00321 ::google::protobuf::internal::WireFormatLite::StringSize(
00322 this->name());
00323 }
00324
00325
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
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
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
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
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
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
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
00586 if (has_name()) {
00587 total_size += 1 +
00588 ::google::protobuf::internal::WireFormatLite::StringSize(
00589 this->name());
00590 }
00591
00592 }
00593
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
00676
00677 }
00678 }
00679
00680