00001
00002
00003 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
00004 #include "engine.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
00015
00016 namespace drizzled {
00017 namespace message {
00018
00019 namespace {
00020
00021 const ::google::protobuf::Descriptor* Engine_descriptor_ = NULL;
00022 const ::google::protobuf::internal::GeneratedMessageReflection*
00023 Engine_reflection_ = NULL;
00024 const ::google::protobuf::Descriptor* Engine_Option_descriptor_ = NULL;
00025 const ::google::protobuf::internal::GeneratedMessageReflection*
00026 Engine_Option_reflection_ = NULL;
00027
00028 }
00029
00030
00031 void protobuf_AssignDesc_engine_2eproto() {
00032 protobuf_AddDesc_engine_2eproto();
00033 const ::google::protobuf::FileDescriptor* file =
00034 ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
00035 "engine.proto");
00036 GOOGLE_CHECK(file != NULL);
00037 Engine_descriptor_ = file->message_type(0);
00038 static const int Engine_offsets_[2] = {
00039 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine, name_),
00040 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine, options_),
00041 };
00042 Engine_reflection_ =
00043 new ::google::protobuf::internal::GeneratedMessageReflection(
00044 Engine_descriptor_,
00045 Engine::default_instance_,
00046 Engine_offsets_,
00047 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine, _has_bits_[0]),
00048 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine, _unknown_fields_),
00049 -1,
00050 ::google::protobuf::DescriptorPool::generated_pool(),
00051 ::google::protobuf::MessageFactory::generated_factory(),
00052 sizeof(Engine));
00053 Engine_Option_descriptor_ = Engine_descriptor_->nested_type(0);
00054 static const int Engine_Option_offsets_[2] = {
00055 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine_Option, name_),
00056 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine_Option, state_),
00057 };
00058 Engine_Option_reflection_ =
00059 new ::google::protobuf::internal::GeneratedMessageReflection(
00060 Engine_Option_descriptor_,
00061 Engine_Option::default_instance_,
00062 Engine_Option_offsets_,
00063 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine_Option, _has_bits_[0]),
00064 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Engine_Option, _unknown_fields_),
00065 -1,
00066 ::google::protobuf::DescriptorPool::generated_pool(),
00067 ::google::protobuf::MessageFactory::generated_factory(),
00068 sizeof(Engine_Option));
00069 }
00070
00071 namespace {
00072
00073 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
00074 inline void protobuf_AssignDescriptorsOnce() {
00075 ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
00076 &protobuf_AssignDesc_engine_2eproto);
00077 }
00078
00079 void protobuf_RegisterTypes(const ::std::string&) {
00080 protobuf_AssignDescriptorsOnce();
00081 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00082 Engine_descriptor_, &Engine::default_instance());
00083 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00084 Engine_Option_descriptor_, &Engine_Option::default_instance());
00085 }
00086
00087 }
00088
00089 void protobuf_ShutdownFile_engine_2eproto() {
00090 delete Engine::default_instance_;
00091 delete Engine_reflection_;
00092 delete Engine_Option::default_instance_;
00093 delete Engine_Option_reflection_;
00094 }
00095
00096 void protobuf_AddDesc_engine_2eproto() {
00097 static bool already_here = false;
00098 if (already_here) return;
00099 already_here = true;
00100 GOOGLE_PROTOBUF_VERIFY_VERSION;
00101
00102 ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
00103 "\n\014engine.proto\022\020drizzled.message\"o\n\006Engi"
00104 "ne\022\014\n\004name\030\001 \002(\t\0220\n\007options\030\002 \003(\0132\037.driz"
00105 "zled.message.Engine.Option\032%\n\006Option\022\014\n\004"
00106 "name\030\001 \002(\t\022\r\n\005state\030\002 \001(\tB\'\n\024org.drizzle"
00107 ".messagesB\rEngineMessageH\001", 186);
00108 ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
00109 "engine.proto", &protobuf_RegisterTypes);
00110 Engine::default_instance_ = new Engine();
00111 Engine_Option::default_instance_ = new Engine_Option();
00112 Engine::default_instance_->InitAsDefaultInstance();
00113 Engine_Option::default_instance_->InitAsDefaultInstance();
00114 ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_engine_2eproto);
00115 }
00116
00117
00118 struct StaticDescriptorInitializer_engine_2eproto {
00119 StaticDescriptorInitializer_engine_2eproto() {
00120 protobuf_AddDesc_engine_2eproto();
00121 }
00122 } static_descriptor_initializer_engine_2eproto_;
00123
00124
00125
00126
00127 #ifndef _MSC_VER
00128 const int Engine_Option::kNameFieldNumber;
00129 const int Engine_Option::kStateFieldNumber;
00130 #endif // !_MSC_VER
00131
00132 Engine_Option::Engine_Option()
00133 : ::google::protobuf::Message() {
00134 SharedCtor();
00135 }
00136
00137 void Engine_Option::InitAsDefaultInstance() {
00138 }
00139
00140 Engine_Option::Engine_Option(const Engine_Option& from)
00141 : ::google::protobuf::Message() {
00142 SharedCtor();
00143 MergeFrom(from);
00144 }
00145
00146 void Engine_Option::SharedCtor() {
00147 _cached_size_ = 0;
00148 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
00149 state_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
00150 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00151 }
00152
00153 Engine_Option::~Engine_Option() {
00154 SharedDtor();
00155 }
00156
00157 void Engine_Option::SharedDtor() {
00158 if (name_ != &::google::protobuf::internal::kEmptyString) {
00159 delete name_;
00160 }
00161 if (state_ != &::google::protobuf::internal::kEmptyString) {
00162 delete state_;
00163 }
00164 if (this != default_instance_) {
00165 }
00166 }
00167
00168 void Engine_Option::SetCachedSize(int size) const {
00169 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00170 _cached_size_ = size;
00171 GOOGLE_SAFE_CONCURRENT_WRITES_END();
00172 }
00173 const ::google::protobuf::Descriptor* Engine_Option::descriptor() {
00174 protobuf_AssignDescriptorsOnce();
00175 return Engine_Option_descriptor_;
00176 }
00177
00178 const Engine_Option& Engine_Option::default_instance() {
00179 if (default_instance_ == NULL) protobuf_AddDesc_engine_2eproto(); return *default_instance_;
00180 }
00181
00182 Engine_Option* Engine_Option::default_instance_ = NULL;
00183
00184 Engine_Option* Engine_Option::New() const {
00185 return new Engine_Option;
00186 }
00187
00188 void Engine_Option::Clear() {
00189 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00190 if (has_name()) {
00191 if (name_ != &::google::protobuf::internal::kEmptyString) {
00192 name_->clear();
00193 }
00194 }
00195 if (has_state()) {
00196 if (state_ != &::google::protobuf::internal::kEmptyString) {
00197 state_->clear();
00198 }
00199 }
00200 }
00201 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00202 mutable_unknown_fields()->Clear();
00203 }
00204
00205 bool Engine_Option::MergePartialFromCodedStream(
00206 ::google::protobuf::io::CodedInputStream* input) {
00207 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
00208 ::google::protobuf::uint32 tag;
00209 while ((tag = input->ReadTag()) != 0) {
00210 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
00211
00212 case 1: {
00213 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00214 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00215 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00216 input, this->mutable_name()));
00217 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00218 this->name().data(), this->name().length(),
00219 ::google::protobuf::internal::WireFormat::PARSE);
00220 } else {
00221 goto handle_uninterpreted;
00222 }
00223 if (input->ExpectTag(18)) goto parse_state;
00224 break;
00225 }
00226
00227
00228 case 2: {
00229 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00230 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00231 parse_state:
00232 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00233 input, this->mutable_state()));
00234 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00235 this->state().data(), this->state().length(),
00236 ::google::protobuf::internal::WireFormat::PARSE);
00237 } else {
00238 goto handle_uninterpreted;
00239 }
00240 if (input->ExpectAtEnd()) return true;
00241 break;
00242 }
00243
00244 default: {
00245 handle_uninterpreted:
00246 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00247 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
00248 return true;
00249 }
00250 DO_(::google::protobuf::internal::WireFormat::SkipField(
00251 input, tag, mutable_unknown_fields()));
00252 break;
00253 }
00254 }
00255 }
00256 return true;
00257 #undef DO_
00258 }
00259
00260 void Engine_Option::SerializeWithCachedSizes(
00261 ::google::protobuf::io::CodedOutputStream* output) const {
00262
00263 if (has_name()) {
00264 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00265 this->name().data(), this->name().length(),
00266 ::google::protobuf::internal::WireFormat::SERIALIZE);
00267 ::google::protobuf::internal::WireFormatLite::WriteString(
00268 1, this->name(), output);
00269 }
00270
00271
00272 if (has_state()) {
00273 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00274 this->state().data(), this->state().length(),
00275 ::google::protobuf::internal::WireFormat::SERIALIZE);
00276 ::google::protobuf::internal::WireFormatLite::WriteString(
00277 2, this->state(), output);
00278 }
00279
00280 if (!unknown_fields().empty()) {
00281 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
00282 unknown_fields(), output);
00283 }
00284 }
00285
00286 ::google::protobuf::uint8* Engine_Option::SerializeWithCachedSizesToArray(
00287 ::google::protobuf::uint8* target) const {
00288
00289 if (has_name()) {
00290 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00291 this->name().data(), this->name().length(),
00292 ::google::protobuf::internal::WireFormat::SERIALIZE);
00293 target =
00294 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00295 1, this->name(), target);
00296 }
00297
00298
00299 if (has_state()) {
00300 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00301 this->state().data(), this->state().length(),
00302 ::google::protobuf::internal::WireFormat::SERIALIZE);
00303 target =
00304 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00305 2, this->state(), target);
00306 }
00307
00308 if (!unknown_fields().empty()) {
00309 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
00310 unknown_fields(), target);
00311 }
00312 return target;
00313 }
00314
00315 int Engine_Option::ByteSize() const {
00316 int total_size = 0;
00317
00318 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00319
00320 if (has_name()) {
00321 total_size += 1 +
00322 ::google::protobuf::internal::WireFormatLite::StringSize(
00323 this->name());
00324 }
00325
00326
00327 if (has_state()) {
00328 total_size += 1 +
00329 ::google::protobuf::internal::WireFormatLite::StringSize(
00330 this->state());
00331 }
00332
00333 }
00334 if (!unknown_fields().empty()) {
00335 total_size +=
00336 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
00337 unknown_fields());
00338 }
00339 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00340 _cached_size_ = total_size;
00341 GOOGLE_SAFE_CONCURRENT_WRITES_END();
00342 return total_size;
00343 }
00344
00345 void Engine_Option::MergeFrom(const ::google::protobuf::Message& from) {
00346 GOOGLE_CHECK_NE(&from, this);
00347 const Engine_Option* source =
00348 ::google::protobuf::internal::dynamic_cast_if_available<const Engine_Option*>(
00349 &from);
00350 if (source == NULL) {
00351 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
00352 } else {
00353 MergeFrom(*source);
00354 }
00355 }
00356
00357 void Engine_Option::MergeFrom(const Engine_Option& from) {
00358 GOOGLE_CHECK_NE(&from, this);
00359 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00360 if (from.has_name()) {
00361 set_name(from.name());
00362 }
00363 if (from.has_state()) {
00364 set_state(from.state());
00365 }
00366 }
00367 mutable_unknown_fields()->MergeFrom(from.unknown_fields());
00368 }
00369
00370 void Engine_Option::CopyFrom(const ::google::protobuf::Message& from) {
00371 if (&from == this) return;
00372 Clear();
00373 MergeFrom(from);
00374 }
00375
00376 void Engine_Option::CopyFrom(const Engine_Option& from) {
00377 if (&from == this) return;
00378 Clear();
00379 MergeFrom(from);
00380 }
00381
00382 bool Engine_Option::IsInitialized() const {
00383 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
00384
00385 return true;
00386 }
00387
00388 void Engine_Option::Swap(Engine_Option* other) {
00389 if (other != this) {
00390 std::swap(name_, other->name_);
00391 std::swap(state_, other->state_);
00392 std::swap(_has_bits_[0], other->_has_bits_[0]);
00393 _unknown_fields_.Swap(&other->_unknown_fields_);
00394 std::swap(_cached_size_, other->_cached_size_);
00395 }
00396 }
00397
00398 ::google::protobuf::Metadata Engine_Option::GetMetadata() const {
00399 protobuf_AssignDescriptorsOnce();
00400 ::google::protobuf::Metadata metadata;
00401 metadata.descriptor = Engine_Option_descriptor_;
00402 metadata.reflection = Engine_Option_reflection_;
00403 return metadata;
00404 }
00405
00406
00407
00408
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*>(&::google::protobuf::internal::kEmptyString);
00431 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00432 }
00433
00434 Engine::~Engine() {
00435 SharedDtor();
00436 }
00437
00438 void Engine::SharedDtor() {
00439 if (name_ != &::google::protobuf::internal::kEmptyString) {
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_name()) {
00469 if (name_ != &::google::protobuf::internal::kEmptyString) {
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_name()) {
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_name()) {
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_name()) {
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