| // Generated by the protocol buffer compiler. DO NOT EDIT! |
| // source: GeneralRPC.proto |
| |
| #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION |
| #include "GeneralRPC.pb.h" |
| |
| #include <algorithm> |
| |
| #include <google/protobuf/stubs/common.h> |
| #include <google/protobuf/stubs/once.h> |
| #include <google/protobuf/io/coded_stream.h> |
| #include <google/protobuf/wire_format_lite_inl.h> |
| #include <google/protobuf/descriptor.h> |
| #include <google/protobuf/generated_message_reflection.h> |
| #include <google/protobuf/reflection_ops.h> |
| #include <google/protobuf/wire_format.h> |
| // @@protoc_insertion_point(includes) |
| |
| namespace exec { |
| namespace rpc { |
| |
| namespace { |
| |
| const ::google::protobuf::Descriptor* Ack_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| Ack_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* RpcHeader_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| RpcHeader_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* CompleteRpcMessage_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| CompleteRpcMessage_reflection_ = NULL; |
| const ::google::protobuf::EnumDescriptor* RpcMode_descriptor_ = NULL; |
| |
| } // namespace |
| |
| |
| void protobuf_AssignDesc_GeneralRPC_2eproto() { |
| protobuf_AddDesc_GeneralRPC_2eproto(); |
| const ::google::protobuf::FileDescriptor* file = |
| ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( |
| "GeneralRPC.proto"); |
| GOOGLE_CHECK(file != NULL); |
| Ack_descriptor_ = file->message_type(0); |
| static const int Ack_offsets_[1] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ack, ok_), |
| }; |
| Ack_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| Ack_descriptor_, |
| Ack::default_instance_, |
| Ack_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ack, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ack, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(Ack)); |
| RpcHeader_descriptor_ = file->message_type(1); |
| static const int RpcHeader_offsets_[3] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcHeader, mode_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcHeader, coordination_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcHeader, rpc_type_), |
| }; |
| RpcHeader_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| RpcHeader_descriptor_, |
| RpcHeader::default_instance_, |
| RpcHeader_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcHeader, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcHeader, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(RpcHeader)); |
| CompleteRpcMessage_descriptor_ = file->message_type(2); |
| static const int CompleteRpcMessage_offsets_[3] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CompleteRpcMessage, header_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CompleteRpcMessage, protobuf_body_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CompleteRpcMessage, raw_body_), |
| }; |
| CompleteRpcMessage_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| CompleteRpcMessage_descriptor_, |
| CompleteRpcMessage::default_instance_, |
| CompleteRpcMessage_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CompleteRpcMessage, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CompleteRpcMessage, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(CompleteRpcMessage)); |
| RpcMode_descriptor_ = file->enum_type(0); |
| } |
| |
| namespace { |
| |
| GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); |
| inline void protobuf_AssignDescriptorsOnce() { |
| ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, |
| &protobuf_AssignDesc_GeneralRPC_2eproto); |
| } |
| |
| void protobuf_RegisterTypes(const ::std::string&) { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| Ack_descriptor_, &Ack::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| RpcHeader_descriptor_, &RpcHeader::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| CompleteRpcMessage_descriptor_, &CompleteRpcMessage::default_instance()); |
| } |
| |
| } // namespace |
| |
| void protobuf_ShutdownFile_GeneralRPC_2eproto() { |
| delete Ack::default_instance_; |
| delete Ack_reflection_; |
| delete RpcHeader::default_instance_; |
| delete RpcHeader_reflection_; |
| delete CompleteRpcMessage::default_instance_; |
| delete CompleteRpcMessage_reflection_; |
| } |
| |
| void protobuf_AddDesc_GeneralRPC_2eproto() { |
| static bool already_here = false; |
| if (already_here) return; |
| already_here = true; |
| GOOGLE_PROTOBUF_VERIFY_VERSION; |
| |
| ::exec::protobuf_AddDesc_Coordination_2eproto(); |
| ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( |
| "\n\020GeneralRPC.proto\022\010exec.rpc\032\022Coordinati" |
| "on.proto\"\021\n\003Ack\022\n\n\002ok\030\001 \001(\010\"W\n\tRpcHeader" |
| "\022\037\n\004mode\030\001 \001(\0162\021.exec.rpc.RpcMode\022\027\n\017coo" |
| "rdination_id\030\002 \001(\005\022\020\n\010rpc_type\030\003 \001(\005\"b\n\022" |
| "CompleteRpcMessage\022#\n\006header\030\001 \001(\0132\023.exe" |
| "c.rpc.RpcHeader\022\025\n\rprotobuf_body\030\002 \001(\014\022\020" |
| "\n\010raw_body\030\003 \001(\014*N\n\007RpcMode\022\013\n\007REQUEST\020\000" |
| "\022\014\n\010RESPONSE\020\001\022\024\n\020RESPONSE_FAILURE\020\002\022\010\n\004" |
| "PING\020\003\022\010\n\004PONG\020\004B1\n\033org.apache.drill.exe" |
| "c.protoB\020GeneralRPCProtosH\001", 387); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( |
| "GeneralRPC.proto", &protobuf_RegisterTypes); |
| Ack::default_instance_ = new Ack(); |
| RpcHeader::default_instance_ = new RpcHeader(); |
| CompleteRpcMessage::default_instance_ = new CompleteRpcMessage(); |
| Ack::default_instance_->InitAsDefaultInstance(); |
| RpcHeader::default_instance_->InitAsDefaultInstance(); |
| CompleteRpcMessage::default_instance_->InitAsDefaultInstance(); |
| ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_GeneralRPC_2eproto); |
| } |
| |
| // Force AddDescriptors() to be called at static initialization time. |
| struct StaticDescriptorInitializer_GeneralRPC_2eproto { |
| StaticDescriptorInitializer_GeneralRPC_2eproto() { |
| protobuf_AddDesc_GeneralRPC_2eproto(); |
| } |
| } static_descriptor_initializer_GeneralRPC_2eproto_; |
| const ::google::protobuf::EnumDescriptor* RpcMode_descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return RpcMode_descriptor_; |
| } |
| bool RpcMode_IsValid(int value) { |
| switch(value) { |
| case 0: |
| case 1: |
| case 2: |
| case 3: |
| case 4: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int Ack::kOkFieldNumber; |
| #endif // !_MSC_VER |
| |
| Ack::Ack() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void Ack::InitAsDefaultInstance() { |
| } |
| |
| Ack::Ack(const Ack& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void Ack::SharedCtor() { |
| _cached_size_ = 0; |
| ok_ = false; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| Ack::~Ack() { |
| SharedDtor(); |
| } |
| |
| void Ack::SharedDtor() { |
| if (this != default_instance_) { |
| } |
| } |
| |
| void Ack::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* Ack::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return Ack_descriptor_; |
| } |
| |
| const Ack& Ack::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_GeneralRPC_2eproto(); |
| return *default_instance_; |
| } |
| |
| Ack* Ack::default_instance_ = NULL; |
| |
| Ack* Ack::New() const { |
| return new Ack; |
| } |
| |
| void Ack::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| ok_ = false; |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool Ack::MergePartialFromCodedStream( |
| ::google::protobuf::io::CodedInputStream* input) { |
| #define DO_(EXPRESSION) if (!(EXPRESSION)) return false |
| ::google::protobuf::uint32 tag; |
| while ((tag = input->ReadTag()) != 0) { |
| switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { |
| // optional bool ok = 1; |
| case 1: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( |
| input, &ok_))); |
| set_has_ok(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectAtEnd()) return true; |
| break; |
| } |
| |
| default: { |
| handle_uninterpreted: |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { |
| return true; |
| } |
| DO_(::google::protobuf::internal::WireFormat::SkipField( |
| input, tag, mutable_unknown_fields())); |
| break; |
| } |
| } |
| } |
| return true; |
| #undef DO_ |
| } |
| |
| void Ack::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional bool ok = 1; |
| if (has_ok()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->ok(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* Ack::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional bool ok = 1; |
| if (has_ok()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->ok(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int Ack::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional bool ok = 1; |
| if (has_ok()) { |
| total_size += 1 + 1; |
| } |
| |
| } |
| if (!unknown_fields().empty()) { |
| total_size += |
| ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( |
| unknown_fields()); |
| } |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = total_size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| return total_size; |
| } |
| |
| void Ack::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const Ack* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const Ack*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void Ack::MergeFrom(const Ack& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_ok()) { |
| set_ok(from.ok()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void Ack::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void Ack::CopyFrom(const Ack& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool Ack::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void Ack::Swap(Ack* other) { |
| if (other != this) { |
| std::swap(ok_, other->ok_); |
| std::swap(_has_bits_[0], other->_has_bits_[0]); |
| _unknown_fields_.Swap(&other->_unknown_fields_); |
| std::swap(_cached_size_, other->_cached_size_); |
| } |
| } |
| |
| ::google::protobuf::Metadata Ack::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = Ack_descriptor_; |
| metadata.reflection = Ack_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int RpcHeader::kModeFieldNumber; |
| const int RpcHeader::kCoordinationIdFieldNumber; |
| const int RpcHeader::kRpcTypeFieldNumber; |
| #endif // !_MSC_VER |
| |
| RpcHeader::RpcHeader() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void RpcHeader::InitAsDefaultInstance() { |
| } |
| |
| RpcHeader::RpcHeader(const RpcHeader& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void RpcHeader::SharedCtor() { |
| _cached_size_ = 0; |
| mode_ = 0; |
| coordination_id_ = 0; |
| rpc_type_ = 0; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| RpcHeader::~RpcHeader() { |
| SharedDtor(); |
| } |
| |
| void RpcHeader::SharedDtor() { |
| if (this != default_instance_) { |
| } |
| } |
| |
| void RpcHeader::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* RpcHeader::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return RpcHeader_descriptor_; |
| } |
| |
| const RpcHeader& RpcHeader::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_GeneralRPC_2eproto(); |
| return *default_instance_; |
| } |
| |
| RpcHeader* RpcHeader::default_instance_ = NULL; |
| |
| RpcHeader* RpcHeader::New() const { |
| return new RpcHeader; |
| } |
| |
| void RpcHeader::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| mode_ = 0; |
| coordination_id_ = 0; |
| rpc_type_ = 0; |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool RpcHeader::MergePartialFromCodedStream( |
| ::google::protobuf::io::CodedInputStream* input) { |
| #define DO_(EXPRESSION) if (!(EXPRESSION)) return false |
| ::google::protobuf::uint32 tag; |
| while ((tag = input->ReadTag()) != 0) { |
| switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { |
| // optional .exec.rpc.RpcMode mode = 1; |
| case 1: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| int value; |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( |
| input, &value))); |
| if (::exec::rpc::RpcMode_IsValid(value)) { |
| set_mode(static_cast< ::exec::rpc::RpcMode >(value)); |
| } else { |
| mutable_unknown_fields()->AddVarint(1, value); |
| } |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(16)) goto parse_coordination_id; |
| break; |
| } |
| |
| // optional int32 coordination_id = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_coordination_id: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &coordination_id_))); |
| set_has_coordination_id(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(24)) goto parse_rpc_type; |
| break; |
| } |
| |
| // optional int32 rpc_type = 3; |
| case 3: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_rpc_type: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &rpc_type_))); |
| set_has_rpc_type(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectAtEnd()) return true; |
| break; |
| } |
| |
| default: { |
| handle_uninterpreted: |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { |
| return true; |
| } |
| DO_(::google::protobuf::internal::WireFormat::SkipField( |
| input, tag, mutable_unknown_fields())); |
| break; |
| } |
| } |
| } |
| return true; |
| #undef DO_ |
| } |
| |
| void RpcHeader::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional .exec.rpc.RpcMode mode = 1; |
| if (has_mode()) { |
| ::google::protobuf::internal::WireFormatLite::WriteEnum( |
| 1, this->mode(), output); |
| } |
| |
| // optional int32 coordination_id = 2; |
| if (has_coordination_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->coordination_id(), output); |
| } |
| |
| // optional int32 rpc_type = 3; |
| if (has_rpc_type()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->rpc_type(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* RpcHeader::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional .exec.rpc.RpcMode mode = 1; |
| if (has_mode()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( |
| 1, this->mode(), target); |
| } |
| |
| // optional int32 coordination_id = 2; |
| if (has_coordination_id()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->coordination_id(), target); |
| } |
| |
| // optional int32 rpc_type = 3; |
| if (has_rpc_type()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->rpc_type(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int RpcHeader::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional .exec.rpc.RpcMode mode = 1; |
| if (has_mode()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::EnumSize(this->mode()); |
| } |
| |
| // optional int32 coordination_id = 2; |
| if (has_coordination_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->coordination_id()); |
| } |
| |
| // optional int32 rpc_type = 3; |
| if (has_rpc_type()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->rpc_type()); |
| } |
| |
| } |
| if (!unknown_fields().empty()) { |
| total_size += |
| ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( |
| unknown_fields()); |
| } |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = total_size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| return total_size; |
| } |
| |
| void RpcHeader::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const RpcHeader* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const RpcHeader*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void RpcHeader::MergeFrom(const RpcHeader& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_mode()) { |
| set_mode(from.mode()); |
| } |
| if (from.has_coordination_id()) { |
| set_coordination_id(from.coordination_id()); |
| } |
| if (from.has_rpc_type()) { |
| set_rpc_type(from.rpc_type()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void RpcHeader::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void RpcHeader::CopyFrom(const RpcHeader& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool RpcHeader::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void RpcHeader::Swap(RpcHeader* other) { |
| if (other != this) { |
| std::swap(mode_, other->mode_); |
| std::swap(coordination_id_, other->coordination_id_); |
| std::swap(rpc_type_, other->rpc_type_); |
| std::swap(_has_bits_[0], other->_has_bits_[0]); |
| _unknown_fields_.Swap(&other->_unknown_fields_); |
| std::swap(_cached_size_, other->_cached_size_); |
| } |
| } |
| |
| ::google::protobuf::Metadata RpcHeader::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = RpcHeader_descriptor_; |
| metadata.reflection = RpcHeader_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int CompleteRpcMessage::kHeaderFieldNumber; |
| const int CompleteRpcMessage::kProtobufBodyFieldNumber; |
| const int CompleteRpcMessage::kRawBodyFieldNumber; |
| #endif // !_MSC_VER |
| |
| CompleteRpcMessage::CompleteRpcMessage() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void CompleteRpcMessage::InitAsDefaultInstance() { |
| header_ = const_cast< ::exec::rpc::RpcHeader*>(&::exec::rpc::RpcHeader::default_instance()); |
| } |
| |
| CompleteRpcMessage::CompleteRpcMessage(const CompleteRpcMessage& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void CompleteRpcMessage::SharedCtor() { |
| _cached_size_ = 0; |
| header_ = NULL; |
| protobuf_body_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); |
| raw_body_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| CompleteRpcMessage::~CompleteRpcMessage() { |
| SharedDtor(); |
| } |
| |
| void CompleteRpcMessage::SharedDtor() { |
| if (protobuf_body_ != &::google::protobuf::internal::kEmptyString) { |
| delete protobuf_body_; |
| } |
| if (raw_body_ != &::google::protobuf::internal::kEmptyString) { |
| delete raw_body_; |
| } |
| if (this != default_instance_) { |
| delete header_; |
| } |
| } |
| |
| void CompleteRpcMessage::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* CompleteRpcMessage::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return CompleteRpcMessage_descriptor_; |
| } |
| |
| const CompleteRpcMessage& CompleteRpcMessage::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_GeneralRPC_2eproto(); |
| return *default_instance_; |
| } |
| |
| CompleteRpcMessage* CompleteRpcMessage::default_instance_ = NULL; |
| |
| CompleteRpcMessage* CompleteRpcMessage::New() const { |
| return new CompleteRpcMessage; |
| } |
| |
| void CompleteRpcMessage::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (has_header()) { |
| if (header_ != NULL) header_->::exec::rpc::RpcHeader::Clear(); |
| } |
| if (has_protobuf_body()) { |
| if (protobuf_body_ != &::google::protobuf::internal::kEmptyString) { |
| protobuf_body_->clear(); |
| } |
| } |
| if (has_raw_body()) { |
| if (raw_body_ != &::google::protobuf::internal::kEmptyString) { |
| raw_body_->clear(); |
| } |
| } |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool CompleteRpcMessage::MergePartialFromCodedStream( |
| ::google::protobuf::io::CodedInputStream* input) { |
| #define DO_(EXPRESSION) if (!(EXPRESSION)) return false |
| ::google::protobuf::uint32 tag; |
| while ((tag = input->ReadTag()) != 0) { |
| switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { |
| // optional .exec.rpc.RpcHeader header = 1; |
| case 1: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_header())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(18)) goto parse_protobuf_body; |
| break; |
| } |
| |
| // optional bytes protobuf_body = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_protobuf_body: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( |
| input, this->mutable_protobuf_body())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(26)) goto parse_raw_body; |
| break; |
| } |
| |
| // optional bytes raw_body = 3; |
| case 3: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_raw_body: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( |
| input, this->mutable_raw_body())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectAtEnd()) return true; |
| break; |
| } |
| |
| default: { |
| handle_uninterpreted: |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { |
| return true; |
| } |
| DO_(::google::protobuf::internal::WireFormat::SkipField( |
| input, tag, mutable_unknown_fields())); |
| break; |
| } |
| } |
| } |
| return true; |
| #undef DO_ |
| } |
| |
| void CompleteRpcMessage::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional .exec.rpc.RpcHeader header = 1; |
| if (has_header()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->header(), output); |
| } |
| |
| // optional bytes protobuf_body = 2; |
| if (has_protobuf_body()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBytes( |
| 2, this->protobuf_body(), output); |
| } |
| |
| // optional bytes raw_body = 3; |
| if (has_raw_body()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBytes( |
| 3, this->raw_body(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* CompleteRpcMessage::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional .exec.rpc.RpcHeader header = 1; |
| if (has_header()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->header(), target); |
| } |
| |
| // optional bytes protobuf_body = 2; |
| if (has_protobuf_body()) { |
| target = |
| ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( |
| 2, this->protobuf_body(), target); |
| } |
| |
| // optional bytes raw_body = 3; |
| if (has_raw_body()) { |
| target = |
| ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( |
| 3, this->raw_body(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int CompleteRpcMessage::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional .exec.rpc.RpcHeader header = 1; |
| if (has_header()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->header()); |
| } |
| |
| // optional bytes protobuf_body = 2; |
| if (has_protobuf_body()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::BytesSize( |
| this->protobuf_body()); |
| } |
| |
| // optional bytes raw_body = 3; |
| if (has_raw_body()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::BytesSize( |
| this->raw_body()); |
| } |
| |
| } |
| if (!unknown_fields().empty()) { |
| total_size += |
| ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( |
| unknown_fields()); |
| } |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = total_size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| return total_size; |
| } |
| |
| void CompleteRpcMessage::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const CompleteRpcMessage* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const CompleteRpcMessage*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void CompleteRpcMessage::MergeFrom(const CompleteRpcMessage& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_header()) { |
| mutable_header()->::exec::rpc::RpcHeader::MergeFrom(from.header()); |
| } |
| if (from.has_protobuf_body()) { |
| set_protobuf_body(from.protobuf_body()); |
| } |
| if (from.has_raw_body()) { |
| set_raw_body(from.raw_body()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void CompleteRpcMessage::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void CompleteRpcMessage::CopyFrom(const CompleteRpcMessage& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool CompleteRpcMessage::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void CompleteRpcMessage::Swap(CompleteRpcMessage* other) { |
| if (other != this) { |
| std::swap(header_, other->header_); |
| std::swap(protobuf_body_, other->protobuf_body_); |
| std::swap(raw_body_, other->raw_body_); |
| std::swap(_has_bits_[0], other->_has_bits_[0]); |
| _unknown_fields_.Swap(&other->_unknown_fields_); |
| std::swap(_cached_size_, other->_cached_size_); |
| } |
| } |
| |
| ::google::protobuf::Metadata CompleteRpcMessage::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = CompleteRpcMessage_descriptor_; |
| metadata.reflection = CompleteRpcMessage_reflection_; |
| return metadata; |
| } |
| |
| |
| // @@protoc_insertion_point(namespace_scope) |
| |
| } // namespace rpc |
| } // namespace exec |
| |
| // @@protoc_insertion_point(global_scope) |