| // Generated by the protocol buffer compiler. DO NOT EDIT! |
| // source: BitData.proto |
| |
| #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION |
| #include "BitData.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 bit { |
| namespace data { |
| |
| namespace { |
| |
| const ::google::protobuf::Descriptor* BitClientHandshake_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| BitClientHandshake_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* BitServerHandshake_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| BitServerHandshake_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* FragmentRecordBatch_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| FragmentRecordBatch_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* RuntimeFilterBDef_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| RuntimeFilterBDef_reflection_ = NULL; |
| const ::google::protobuf::EnumDescriptor* RpcType_descriptor_ = NULL; |
| |
| } // namespace |
| |
| |
| void protobuf_AssignDesc_BitData_2eproto() { |
| protobuf_AddDesc_BitData_2eproto(); |
| const ::google::protobuf::FileDescriptor* file = |
| ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( |
| "BitData.proto"); |
| GOOGLE_CHECK(file != NULL); |
| BitClientHandshake_descriptor_ = file->message_type(0); |
| static const int BitClientHandshake_offsets_[2] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitClientHandshake, rpc_version_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitClientHandshake, channel_), |
| }; |
| BitClientHandshake_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| BitClientHandshake_descriptor_, |
| BitClientHandshake::default_instance_, |
| BitClientHandshake_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitClientHandshake, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitClientHandshake, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(BitClientHandshake)); |
| BitServerHandshake_descriptor_ = file->message_type(1); |
| static const int BitServerHandshake_offsets_[2] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitServerHandshake, rpc_version_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitServerHandshake, authenticationmechanisms_), |
| }; |
| BitServerHandshake_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| BitServerHandshake_descriptor_, |
| BitServerHandshake::default_instance_, |
| BitServerHandshake_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitServerHandshake, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitServerHandshake, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(BitServerHandshake)); |
| FragmentRecordBatch_descriptor_ = file->message_type(2); |
| static const int FragmentRecordBatch_offsets_[7] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, query_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, receiving_major_fragment_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, receiving_minor_fragment_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, sending_major_fragment_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, sending_minor_fragment_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, def_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, islastbatch_), |
| }; |
| FragmentRecordBatch_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| FragmentRecordBatch_descriptor_, |
| FragmentRecordBatch::default_instance_, |
| FragmentRecordBatch_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentRecordBatch, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(FragmentRecordBatch)); |
| RuntimeFilterBDef_descriptor_ = file->message_type(3); |
| static const int RuntimeFilterBDef_offsets_[8] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, query_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, major_fragment_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, minor_fragment_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, to_foreman_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, bloom_filter_size_in_bytes_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, probe_fields_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, hj_op_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, rf_identifier_), |
| }; |
| RuntimeFilterBDef_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| RuntimeFilterBDef_descriptor_, |
| RuntimeFilterBDef::default_instance_, |
| RuntimeFilterBDef_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RuntimeFilterBDef, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(RuntimeFilterBDef)); |
| RpcType_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_BitData_2eproto); |
| } |
| |
| void protobuf_RegisterTypes(const ::std::string&) { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| BitClientHandshake_descriptor_, &BitClientHandshake::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| BitServerHandshake_descriptor_, &BitServerHandshake::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| FragmentRecordBatch_descriptor_, &FragmentRecordBatch::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| RuntimeFilterBDef_descriptor_, &RuntimeFilterBDef::default_instance()); |
| } |
| |
| } // namespace |
| |
| void protobuf_ShutdownFile_BitData_2eproto() { |
| delete BitClientHandshake::default_instance_; |
| delete BitClientHandshake_reflection_; |
| delete BitServerHandshake::default_instance_; |
| delete BitServerHandshake_reflection_; |
| delete FragmentRecordBatch::default_instance_; |
| delete FragmentRecordBatch_reflection_; |
| delete RuntimeFilterBDef::default_instance_; |
| delete RuntimeFilterBDef_reflection_; |
| } |
| |
| void protobuf_AddDesc_BitData_2eproto() { |
| static bool already_here = false; |
| if (already_here) return; |
| already_here = true; |
| GOOGLE_PROTOBUF_VERIFY_VERSION; |
| |
| ::exec::bit::protobuf_AddDesc_ExecutionProtos_2eproto(); |
| ::exec::protobuf_AddDesc_Coordination_2eproto(); |
| ::exec::shared::protobuf_AddDesc_UserBitShared_2eproto(); |
| ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( |
| "\n\rBitData.proto\022\rexec.bit.data\032\025Executio" |
| "nProtos.proto\032\022Coordination.proto\032\023UserB" |
| "itShared.proto\"]\n\022BitClientHandshake\022\023\n\013" |
| "rpc_version\030\001 \001(\005\0222\n\007channel\030\002 \001(\0162\027.exe" |
| "c.shared.RpcChannel:\010BIT_DATA\"K\n\022BitServ" |
| "erHandshake\022\023\n\013rpc_version\030\001 \001(\005\022 \n\030auth" |
| "enticationMechanisms\030\002 \003(\t\"\214\002\n\023FragmentR" |
| "ecordBatch\022&\n\010query_id\030\001 \001(\0132\024.exec.shar" |
| "ed.QueryId\022#\n\033receiving_major_fragment_i" |
| "d\030\002 \001(\005\022#\n\033receiving_minor_fragment_id\030\003" |
| " \003(\005\022!\n\031sending_major_fragment_id\030\004 \001(\005\022" |
| "!\n\031sending_minor_fragment_id\030\005 \001(\005\022(\n\003de" |
| "f\030\006 \001(\0132\033.exec.shared.RecordBatchDef\022\023\n\013" |
| "isLastBatch\030\007 \001(\010\"\350\001\n\021RuntimeFilterBDef\022" |
| "&\n\010query_id\030\001 \001(\0132\024.exec.shared.QueryId\022" |
| "\031\n\021major_fragment_id\030\002 \001(\005\022\031\n\021minor_frag" |
| "ment_id\030\003 \001(\005\022\022\n\nto_foreman\030\004 \001(\010\022\"\n\032blo" |
| "om_filter_size_in_bytes\030\005 \003(\005\022\024\n\014probe_f" |
| "ields\030\006 \003(\t\022\020\n\010hj_op_id\030\007 \001(\005\022\025\n\rrf_iden" |
| "tifier\030\010 \001(\003*n\n\007RpcType\022\r\n\tHANDSHAKE\020\000\022\007" |
| "\n\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\024\n\020REQ_RECORD_BATCH" |
| "\020\003\022\020\n\014SASL_MESSAGE\020\004\022\026\n\022REQ_RUNTIME_FILT" |
| "ER\020\005B(\n\033org.apache.drill.exec.protoB\007Bit" |
| "DataH\001", 926); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( |
| "BitData.proto", &protobuf_RegisterTypes); |
| BitClientHandshake::default_instance_ = new BitClientHandshake(); |
| BitServerHandshake::default_instance_ = new BitServerHandshake(); |
| FragmentRecordBatch::default_instance_ = new FragmentRecordBatch(); |
| RuntimeFilterBDef::default_instance_ = new RuntimeFilterBDef(); |
| BitClientHandshake::default_instance_->InitAsDefaultInstance(); |
| BitServerHandshake::default_instance_->InitAsDefaultInstance(); |
| FragmentRecordBatch::default_instance_->InitAsDefaultInstance(); |
| RuntimeFilterBDef::default_instance_->InitAsDefaultInstance(); |
| ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_BitData_2eproto); |
| } |
| |
| // Force AddDescriptors() to be called at static initialization time. |
| struct StaticDescriptorInitializer_BitData_2eproto { |
| StaticDescriptorInitializer_BitData_2eproto() { |
| protobuf_AddDesc_BitData_2eproto(); |
| } |
| } static_descriptor_initializer_BitData_2eproto_; |
| const ::google::protobuf::EnumDescriptor* RpcType_descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return RpcType_descriptor_; |
| } |
| bool RpcType_IsValid(int value) { |
| switch(value) { |
| case 0: |
| case 1: |
| case 2: |
| case 3: |
| case 4: |
| case 5: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int BitClientHandshake::kRpcVersionFieldNumber; |
| const int BitClientHandshake::kChannelFieldNumber; |
| #endif // !_MSC_VER |
| |
| BitClientHandshake::BitClientHandshake() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void BitClientHandshake::InitAsDefaultInstance() { |
| } |
| |
| BitClientHandshake::BitClientHandshake(const BitClientHandshake& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void BitClientHandshake::SharedCtor() { |
| _cached_size_ = 0; |
| rpc_version_ = 0; |
| channel_ = 1; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| BitClientHandshake::~BitClientHandshake() { |
| SharedDtor(); |
| } |
| |
| void BitClientHandshake::SharedDtor() { |
| if (this != default_instance_) { |
| } |
| } |
| |
| void BitClientHandshake::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* BitClientHandshake::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return BitClientHandshake_descriptor_; |
| } |
| |
| const BitClientHandshake& BitClientHandshake::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitData_2eproto(); |
| return *default_instance_; |
| } |
| |
| BitClientHandshake* BitClientHandshake::default_instance_ = NULL; |
| |
| BitClientHandshake* BitClientHandshake::New() const { |
| return new BitClientHandshake; |
| } |
| |
| void BitClientHandshake::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| rpc_version_ = 0; |
| channel_ = 1; |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool BitClientHandshake::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 int32 rpc_version = 1; |
| case 1: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &rpc_version_))); |
| set_has_rpc_version(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(16)) goto parse_channel; |
| break; |
| } |
| |
| // optional .exec.shared.RpcChannel channel = 2 [default = BIT_DATA]; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_channel: |
| int value; |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( |
| input, &value))); |
| if (::exec::shared::RpcChannel_IsValid(value)) { |
| set_channel(static_cast< ::exec::shared::RpcChannel >(value)); |
| } else { |
| mutable_unknown_fields()->AddVarint(2, value); |
| } |
| } 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 BitClientHandshake::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional int32 rpc_version = 1; |
| if (has_rpc_version()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->rpc_version(), output); |
| } |
| |
| // optional .exec.shared.RpcChannel channel = 2 [default = BIT_DATA]; |
| if (has_channel()) { |
| ::google::protobuf::internal::WireFormatLite::WriteEnum( |
| 2, this->channel(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* BitClientHandshake::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional int32 rpc_version = 1; |
| if (has_rpc_version()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->rpc_version(), target); |
| } |
| |
| // optional .exec.shared.RpcChannel channel = 2 [default = BIT_DATA]; |
| if (has_channel()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( |
| 2, this->channel(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int BitClientHandshake::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional int32 rpc_version = 1; |
| if (has_rpc_version()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->rpc_version()); |
| } |
| |
| // optional .exec.shared.RpcChannel channel = 2 [default = BIT_DATA]; |
| if (has_channel()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::EnumSize(this->channel()); |
| } |
| |
| } |
| 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 BitClientHandshake::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const BitClientHandshake* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const BitClientHandshake*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void BitClientHandshake::MergeFrom(const BitClientHandshake& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_rpc_version()) { |
| set_rpc_version(from.rpc_version()); |
| } |
| if (from.has_channel()) { |
| set_channel(from.channel()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void BitClientHandshake::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void BitClientHandshake::CopyFrom(const BitClientHandshake& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool BitClientHandshake::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void BitClientHandshake::Swap(BitClientHandshake* other) { |
| if (other != this) { |
| std::swap(rpc_version_, other->rpc_version_); |
| std::swap(channel_, other->channel_); |
| 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 BitClientHandshake::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = BitClientHandshake_descriptor_; |
| metadata.reflection = BitClientHandshake_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int BitServerHandshake::kRpcVersionFieldNumber; |
| const int BitServerHandshake::kAuthenticationMechanismsFieldNumber; |
| #endif // !_MSC_VER |
| |
| BitServerHandshake::BitServerHandshake() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void BitServerHandshake::InitAsDefaultInstance() { |
| } |
| |
| BitServerHandshake::BitServerHandshake(const BitServerHandshake& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void BitServerHandshake::SharedCtor() { |
| _cached_size_ = 0; |
| rpc_version_ = 0; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| BitServerHandshake::~BitServerHandshake() { |
| SharedDtor(); |
| } |
| |
| void BitServerHandshake::SharedDtor() { |
| if (this != default_instance_) { |
| } |
| } |
| |
| void BitServerHandshake::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* BitServerHandshake::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return BitServerHandshake_descriptor_; |
| } |
| |
| const BitServerHandshake& BitServerHandshake::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitData_2eproto(); |
| return *default_instance_; |
| } |
| |
| BitServerHandshake* BitServerHandshake::default_instance_ = NULL; |
| |
| BitServerHandshake* BitServerHandshake::New() const { |
| return new BitServerHandshake; |
| } |
| |
| void BitServerHandshake::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| rpc_version_ = 0; |
| } |
| authenticationmechanisms_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool BitServerHandshake::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 int32 rpc_version = 1; |
| case 1: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &rpc_version_))); |
| set_has_rpc_version(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(18)) goto parse_authenticationMechanisms; |
| break; |
| } |
| |
| // repeated string authenticationMechanisms = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_authenticationMechanisms: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadString( |
| input, this->add_authenticationmechanisms())); |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->authenticationmechanisms(this->authenticationmechanisms_size() - 1).data(), |
| this->authenticationmechanisms(this->authenticationmechanisms_size() - 1).length(), |
| ::google::protobuf::internal::WireFormat::PARSE); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(18)) goto parse_authenticationMechanisms; |
| 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 BitServerHandshake::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional int32 rpc_version = 1; |
| if (has_rpc_version()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->rpc_version(), output); |
| } |
| |
| // repeated string authenticationMechanisms = 2; |
| for (int i = 0; i < this->authenticationmechanisms_size(); i++) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->authenticationmechanisms(i).data(), this->authenticationmechanisms(i).length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| ::google::protobuf::internal::WireFormatLite::WriteString( |
| 2, this->authenticationmechanisms(i), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* BitServerHandshake::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional int32 rpc_version = 1; |
| if (has_rpc_version()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->rpc_version(), target); |
| } |
| |
| // repeated string authenticationMechanisms = 2; |
| for (int i = 0; i < this->authenticationmechanisms_size(); i++) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->authenticationmechanisms(i).data(), this->authenticationmechanisms(i).length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteStringToArray(2, this->authenticationmechanisms(i), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int BitServerHandshake::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional int32 rpc_version = 1; |
| if (has_rpc_version()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->rpc_version()); |
| } |
| |
| } |
| // repeated string authenticationMechanisms = 2; |
| total_size += 1 * this->authenticationmechanisms_size(); |
| for (int i = 0; i < this->authenticationmechanisms_size(); i++) { |
| total_size += ::google::protobuf::internal::WireFormatLite::StringSize( |
| this->authenticationmechanisms(i)); |
| } |
| |
| 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 BitServerHandshake::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const BitServerHandshake* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const BitServerHandshake*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void BitServerHandshake::MergeFrom(const BitServerHandshake& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| authenticationmechanisms_.MergeFrom(from.authenticationmechanisms_); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_rpc_version()) { |
| set_rpc_version(from.rpc_version()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void BitServerHandshake::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void BitServerHandshake::CopyFrom(const BitServerHandshake& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool BitServerHandshake::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void BitServerHandshake::Swap(BitServerHandshake* other) { |
| if (other != this) { |
| std::swap(rpc_version_, other->rpc_version_); |
| authenticationmechanisms_.Swap(&other->authenticationmechanisms_); |
| 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 BitServerHandshake::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = BitServerHandshake_descriptor_; |
| metadata.reflection = BitServerHandshake_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int FragmentRecordBatch::kQueryIdFieldNumber; |
| const int FragmentRecordBatch::kReceivingMajorFragmentIdFieldNumber; |
| const int FragmentRecordBatch::kReceivingMinorFragmentIdFieldNumber; |
| const int FragmentRecordBatch::kSendingMajorFragmentIdFieldNumber; |
| const int FragmentRecordBatch::kSendingMinorFragmentIdFieldNumber; |
| const int FragmentRecordBatch::kDefFieldNumber; |
| const int FragmentRecordBatch::kIsLastBatchFieldNumber; |
| #endif // !_MSC_VER |
| |
| FragmentRecordBatch::FragmentRecordBatch() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void FragmentRecordBatch::InitAsDefaultInstance() { |
| query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance()); |
| def_ = const_cast< ::exec::shared::RecordBatchDef*>(&::exec::shared::RecordBatchDef::default_instance()); |
| } |
| |
| FragmentRecordBatch::FragmentRecordBatch(const FragmentRecordBatch& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void FragmentRecordBatch::SharedCtor() { |
| _cached_size_ = 0; |
| query_id_ = NULL; |
| receiving_major_fragment_id_ = 0; |
| sending_major_fragment_id_ = 0; |
| sending_minor_fragment_id_ = 0; |
| def_ = NULL; |
| islastbatch_ = false; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| FragmentRecordBatch::~FragmentRecordBatch() { |
| SharedDtor(); |
| } |
| |
| void FragmentRecordBatch::SharedDtor() { |
| if (this != default_instance_) { |
| delete query_id_; |
| delete def_; |
| } |
| } |
| |
| void FragmentRecordBatch::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* FragmentRecordBatch::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return FragmentRecordBatch_descriptor_; |
| } |
| |
| const FragmentRecordBatch& FragmentRecordBatch::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitData_2eproto(); |
| return *default_instance_; |
| } |
| |
| FragmentRecordBatch* FragmentRecordBatch::default_instance_ = NULL; |
| |
| FragmentRecordBatch* FragmentRecordBatch::New() const { |
| return new FragmentRecordBatch; |
| } |
| |
| void FragmentRecordBatch::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (has_query_id()) { |
| if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear(); |
| } |
| receiving_major_fragment_id_ = 0; |
| sending_major_fragment_id_ = 0; |
| sending_minor_fragment_id_ = 0; |
| if (has_def()) { |
| if (def_ != NULL) def_->::exec::shared::RecordBatchDef::Clear(); |
| } |
| islastbatch_ = false; |
| } |
| receiving_minor_fragment_id_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool FragmentRecordBatch::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.shared.QueryId query_id = 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_query_id())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(16)) goto parse_receiving_major_fragment_id; |
| break; |
| } |
| |
| // optional int32 receiving_major_fragment_id = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_receiving_major_fragment_id: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &receiving_major_fragment_id_))); |
| set_has_receiving_major_fragment_id(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(24)) goto parse_receiving_minor_fragment_id; |
| break; |
| } |
| |
| // repeated int32 receiving_minor_fragment_id = 3; |
| case 3: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_receiving_minor_fragment_id: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| 1, 24, input, this->mutable_receiving_minor_fragment_id()))); |
| } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) |
| == ::google::protobuf::internal::WireFormatLite:: |
| WIRETYPE_LENGTH_DELIMITED) { |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, this->mutable_receiving_minor_fragment_id()))); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(24)) goto parse_receiving_minor_fragment_id; |
| if (input->ExpectTag(32)) goto parse_sending_major_fragment_id; |
| break; |
| } |
| |
| // optional int32 sending_major_fragment_id = 4; |
| case 4: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_sending_major_fragment_id: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &sending_major_fragment_id_))); |
| set_has_sending_major_fragment_id(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(40)) goto parse_sending_minor_fragment_id; |
| break; |
| } |
| |
| // optional int32 sending_minor_fragment_id = 5; |
| case 5: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_sending_minor_fragment_id: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &sending_minor_fragment_id_))); |
| set_has_sending_minor_fragment_id(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(50)) goto parse_def; |
| break; |
| } |
| |
| // optional .exec.shared.RecordBatchDef def = 6; |
| case 6: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_def: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_def())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(56)) goto parse_isLastBatch; |
| break; |
| } |
| |
| // optional bool isLastBatch = 7; |
| case 7: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_isLastBatch: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( |
| input, &islastbatch_))); |
| set_has_islastbatch(); |
| } 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 FragmentRecordBatch::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional .exec.shared.QueryId query_id = 1; |
| if (has_query_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->query_id(), output); |
| } |
| |
| // optional int32 receiving_major_fragment_id = 2; |
| if (has_receiving_major_fragment_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->receiving_major_fragment_id(), output); |
| } |
| |
| // repeated int32 receiving_minor_fragment_id = 3; |
| for (int i = 0; i < this->receiving_minor_fragment_id_size(); i++) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32( |
| 3, this->receiving_minor_fragment_id(i), output); |
| } |
| |
| // optional int32 sending_major_fragment_id = 4; |
| if (has_sending_major_fragment_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->sending_major_fragment_id(), output); |
| } |
| |
| // optional int32 sending_minor_fragment_id = 5; |
| if (has_sending_minor_fragment_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->sending_minor_fragment_id(), output); |
| } |
| |
| // optional .exec.shared.RecordBatchDef def = 6; |
| if (has_def()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 6, this->def(), output); |
| } |
| |
| // optional bool isLastBatch = 7; |
| if (has_islastbatch()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->islastbatch(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* FragmentRecordBatch::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional .exec.shared.QueryId query_id = 1; |
| if (has_query_id()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->query_id(), target); |
| } |
| |
| // optional int32 receiving_major_fragment_id = 2; |
| if (has_receiving_major_fragment_id()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->receiving_major_fragment_id(), target); |
| } |
| |
| // repeated int32 receiving_minor_fragment_id = 3; |
| for (int i = 0; i < this->receiving_minor_fragment_id_size(); i++) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteInt32ToArray(3, this->receiving_minor_fragment_id(i), target); |
| } |
| |
| // optional int32 sending_major_fragment_id = 4; |
| if (has_sending_major_fragment_id()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->sending_major_fragment_id(), target); |
| } |
| |
| // optional int32 sending_minor_fragment_id = 5; |
| if (has_sending_minor_fragment_id()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->sending_minor_fragment_id(), target); |
| } |
| |
| // optional .exec.shared.RecordBatchDef def = 6; |
| if (has_def()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 6, this->def(), target); |
| } |
| |
| // optional bool isLastBatch = 7; |
| if (has_islastbatch()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->islastbatch(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int FragmentRecordBatch::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional .exec.shared.QueryId query_id = 1; |
| if (has_query_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->query_id()); |
| } |
| |
| // optional int32 receiving_major_fragment_id = 2; |
| if (has_receiving_major_fragment_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->receiving_major_fragment_id()); |
| } |
| |
| // optional int32 sending_major_fragment_id = 4; |
| if (has_sending_major_fragment_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->sending_major_fragment_id()); |
| } |
| |
| // optional int32 sending_minor_fragment_id = 5; |
| if (has_sending_minor_fragment_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->sending_minor_fragment_id()); |
| } |
| |
| // optional .exec.shared.RecordBatchDef def = 6; |
| if (has_def()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->def()); |
| } |
| |
| // optional bool isLastBatch = 7; |
| if (has_islastbatch()) { |
| total_size += 1 + 1; |
| } |
| |
| } |
| // repeated int32 receiving_minor_fragment_id = 3; |
| { |
| int data_size = 0; |
| for (int i = 0; i < this->receiving_minor_fragment_id_size(); i++) { |
| data_size += ::google::protobuf::internal::WireFormatLite:: |
| Int32Size(this->receiving_minor_fragment_id(i)); |
| } |
| total_size += 1 * this->receiving_minor_fragment_id_size() + data_size; |
| } |
| |
| 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 FragmentRecordBatch::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const FragmentRecordBatch* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const FragmentRecordBatch*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void FragmentRecordBatch::MergeFrom(const FragmentRecordBatch& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| receiving_minor_fragment_id_.MergeFrom(from.receiving_minor_fragment_id_); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_query_id()) { |
| mutable_query_id()->::exec::shared::QueryId::MergeFrom(from.query_id()); |
| } |
| if (from.has_receiving_major_fragment_id()) { |
| set_receiving_major_fragment_id(from.receiving_major_fragment_id()); |
| } |
| if (from.has_sending_major_fragment_id()) { |
| set_sending_major_fragment_id(from.sending_major_fragment_id()); |
| } |
| if (from.has_sending_minor_fragment_id()) { |
| set_sending_minor_fragment_id(from.sending_minor_fragment_id()); |
| } |
| if (from.has_def()) { |
| mutable_def()->::exec::shared::RecordBatchDef::MergeFrom(from.def()); |
| } |
| if (from.has_islastbatch()) { |
| set_islastbatch(from.islastbatch()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void FragmentRecordBatch::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void FragmentRecordBatch::CopyFrom(const FragmentRecordBatch& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool FragmentRecordBatch::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void FragmentRecordBatch::Swap(FragmentRecordBatch* other) { |
| if (other != this) { |
| std::swap(query_id_, other->query_id_); |
| std::swap(receiving_major_fragment_id_, other->receiving_major_fragment_id_); |
| receiving_minor_fragment_id_.Swap(&other->receiving_minor_fragment_id_); |
| std::swap(sending_major_fragment_id_, other->sending_major_fragment_id_); |
| std::swap(sending_minor_fragment_id_, other->sending_minor_fragment_id_); |
| std::swap(def_, other->def_); |
| std::swap(islastbatch_, other->islastbatch_); |
| 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 FragmentRecordBatch::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = FragmentRecordBatch_descriptor_; |
| metadata.reflection = FragmentRecordBatch_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int RuntimeFilterBDef::kQueryIdFieldNumber; |
| const int RuntimeFilterBDef::kMajorFragmentIdFieldNumber; |
| const int RuntimeFilterBDef::kMinorFragmentIdFieldNumber; |
| const int RuntimeFilterBDef::kToForemanFieldNumber; |
| const int RuntimeFilterBDef::kBloomFilterSizeInBytesFieldNumber; |
| const int RuntimeFilterBDef::kProbeFieldsFieldNumber; |
| const int RuntimeFilterBDef::kHjOpIdFieldNumber; |
| const int RuntimeFilterBDef::kRfIdentifierFieldNumber; |
| #endif // !_MSC_VER |
| |
| RuntimeFilterBDef::RuntimeFilterBDef() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void RuntimeFilterBDef::InitAsDefaultInstance() { |
| query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance()); |
| } |
| |
| RuntimeFilterBDef::RuntimeFilterBDef(const RuntimeFilterBDef& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void RuntimeFilterBDef::SharedCtor() { |
| _cached_size_ = 0; |
| query_id_ = NULL; |
| major_fragment_id_ = 0; |
| minor_fragment_id_ = 0; |
| to_foreman_ = false; |
| hj_op_id_ = 0; |
| rf_identifier_ = GOOGLE_LONGLONG(0); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| RuntimeFilterBDef::~RuntimeFilterBDef() { |
| SharedDtor(); |
| } |
| |
| void RuntimeFilterBDef::SharedDtor() { |
| if (this != default_instance_) { |
| delete query_id_; |
| } |
| } |
| |
| void RuntimeFilterBDef::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* RuntimeFilterBDef::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return RuntimeFilterBDef_descriptor_; |
| } |
| |
| const RuntimeFilterBDef& RuntimeFilterBDef::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitData_2eproto(); |
| return *default_instance_; |
| } |
| |
| RuntimeFilterBDef* RuntimeFilterBDef::default_instance_ = NULL; |
| |
| RuntimeFilterBDef* RuntimeFilterBDef::New() const { |
| return new RuntimeFilterBDef; |
| } |
| |
| void RuntimeFilterBDef::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (has_query_id()) { |
| if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear(); |
| } |
| major_fragment_id_ = 0; |
| minor_fragment_id_ = 0; |
| to_foreman_ = false; |
| hj_op_id_ = 0; |
| rf_identifier_ = GOOGLE_LONGLONG(0); |
| } |
| bloom_filter_size_in_bytes_.Clear(); |
| probe_fields_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool RuntimeFilterBDef::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.shared.QueryId query_id = 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_query_id())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(16)) goto parse_major_fragment_id; |
| break; |
| } |
| |
| // optional int32 major_fragment_id = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_major_fragment_id: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &major_fragment_id_))); |
| set_has_major_fragment_id(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(24)) goto parse_minor_fragment_id; |
| break; |
| } |
| |
| // optional int32 minor_fragment_id = 3; |
| case 3: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_minor_fragment_id: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &minor_fragment_id_))); |
| set_has_minor_fragment_id(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(32)) goto parse_to_foreman; |
| break; |
| } |
| |
| // optional bool to_foreman = 4; |
| case 4: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_to_foreman: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( |
| input, &to_foreman_))); |
| set_has_to_foreman(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(40)) goto parse_bloom_filter_size_in_bytes; |
| break; |
| } |
| |
| // repeated int32 bloom_filter_size_in_bytes = 5; |
| case 5: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_bloom_filter_size_in_bytes: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| 1, 40, input, this->mutable_bloom_filter_size_in_bytes()))); |
| } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) |
| == ::google::protobuf::internal::WireFormatLite:: |
| WIRETYPE_LENGTH_DELIMITED) { |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, this->mutable_bloom_filter_size_in_bytes()))); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(40)) goto parse_bloom_filter_size_in_bytes; |
| if (input->ExpectTag(50)) goto parse_probe_fields; |
| break; |
| } |
| |
| // repeated string probe_fields = 6; |
| case 6: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_probe_fields: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadString( |
| input, this->add_probe_fields())); |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->probe_fields(this->probe_fields_size() - 1).data(), |
| this->probe_fields(this->probe_fields_size() - 1).length(), |
| ::google::protobuf::internal::WireFormat::PARSE); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(50)) goto parse_probe_fields; |
| if (input->ExpectTag(56)) goto parse_hj_op_id; |
| break; |
| } |
| |
| // optional int32 hj_op_id = 7; |
| case 7: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_hj_op_id: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &hj_op_id_))); |
| set_has_hj_op_id(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(64)) goto parse_rf_identifier; |
| break; |
| } |
| |
| // optional int64 rf_identifier = 8; |
| case 8: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_rf_identifier: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( |
| input, &rf_identifier_))); |
| set_has_rf_identifier(); |
| } 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 RuntimeFilterBDef::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional .exec.shared.QueryId query_id = 1; |
| if (has_query_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->query_id(), output); |
| } |
| |
| // optional int32 major_fragment_id = 2; |
| if (has_major_fragment_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->major_fragment_id(), output); |
| } |
| |
| // optional int32 minor_fragment_id = 3; |
| if (has_minor_fragment_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->minor_fragment_id(), output); |
| } |
| |
| // optional bool to_foreman = 4; |
| if (has_to_foreman()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->to_foreman(), output); |
| } |
| |
| // repeated int32 bloom_filter_size_in_bytes = 5; |
| for (int i = 0; i < this->bloom_filter_size_in_bytes_size(); i++) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32( |
| 5, this->bloom_filter_size_in_bytes(i), output); |
| } |
| |
| // repeated string probe_fields = 6; |
| for (int i = 0; i < this->probe_fields_size(); i++) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->probe_fields(i).data(), this->probe_fields(i).length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| ::google::protobuf::internal::WireFormatLite::WriteString( |
| 6, this->probe_fields(i), output); |
| } |
| |
| // optional int32 hj_op_id = 7; |
| if (has_hj_op_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->hj_op_id(), output); |
| } |
| |
| // optional int64 rf_identifier = 8; |
| if (has_rf_identifier()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt64(8, this->rf_identifier(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* RuntimeFilterBDef::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional .exec.shared.QueryId query_id = 1; |
| if (has_query_id()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->query_id(), target); |
| } |
| |
| // optional int32 major_fragment_id = 2; |
| if (has_major_fragment_id()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->major_fragment_id(), target); |
| } |
| |
| // optional int32 minor_fragment_id = 3; |
| if (has_minor_fragment_id()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->minor_fragment_id(), target); |
| } |
| |
| // optional bool to_foreman = 4; |
| if (has_to_foreman()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->to_foreman(), target); |
| } |
| |
| // repeated int32 bloom_filter_size_in_bytes = 5; |
| for (int i = 0; i < this->bloom_filter_size_in_bytes_size(); i++) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteInt32ToArray(5, this->bloom_filter_size_in_bytes(i), target); |
| } |
| |
| // repeated string probe_fields = 6; |
| for (int i = 0; i < this->probe_fields_size(); i++) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->probe_fields(i).data(), this->probe_fields(i).length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteStringToArray(6, this->probe_fields(i), target); |
| } |
| |
| // optional int32 hj_op_id = 7; |
| if (has_hj_op_id()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->hj_op_id(), target); |
| } |
| |
| // optional int64 rf_identifier = 8; |
| if (has_rf_identifier()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(8, this->rf_identifier(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int RuntimeFilterBDef::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional .exec.shared.QueryId query_id = 1; |
| if (has_query_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->query_id()); |
| } |
| |
| // optional int32 major_fragment_id = 2; |
| if (has_major_fragment_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->major_fragment_id()); |
| } |
| |
| // optional int32 minor_fragment_id = 3; |
| if (has_minor_fragment_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->minor_fragment_id()); |
| } |
| |
| // optional bool to_foreman = 4; |
| if (has_to_foreman()) { |
| total_size += 1 + 1; |
| } |
| |
| // optional int32 hj_op_id = 7; |
| if (has_hj_op_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->hj_op_id()); |
| } |
| |
| // optional int64 rf_identifier = 8; |
| if (has_rf_identifier()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int64Size( |
| this->rf_identifier()); |
| } |
| |
| } |
| // repeated int32 bloom_filter_size_in_bytes = 5; |
| { |
| int data_size = 0; |
| for (int i = 0; i < this->bloom_filter_size_in_bytes_size(); i++) { |
| data_size += ::google::protobuf::internal::WireFormatLite:: |
| Int32Size(this->bloom_filter_size_in_bytes(i)); |
| } |
| total_size += 1 * this->bloom_filter_size_in_bytes_size() + data_size; |
| } |
| |
| // repeated string probe_fields = 6; |
| total_size += 1 * this->probe_fields_size(); |
| for (int i = 0; i < this->probe_fields_size(); i++) { |
| total_size += ::google::protobuf::internal::WireFormatLite::StringSize( |
| this->probe_fields(i)); |
| } |
| |
| 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 RuntimeFilterBDef::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const RuntimeFilterBDef* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const RuntimeFilterBDef*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void RuntimeFilterBDef::MergeFrom(const RuntimeFilterBDef& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| bloom_filter_size_in_bytes_.MergeFrom(from.bloom_filter_size_in_bytes_); |
| probe_fields_.MergeFrom(from.probe_fields_); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_query_id()) { |
| mutable_query_id()->::exec::shared::QueryId::MergeFrom(from.query_id()); |
| } |
| if (from.has_major_fragment_id()) { |
| set_major_fragment_id(from.major_fragment_id()); |
| } |
| if (from.has_minor_fragment_id()) { |
| set_minor_fragment_id(from.minor_fragment_id()); |
| } |
| if (from.has_to_foreman()) { |
| set_to_foreman(from.to_foreman()); |
| } |
| if (from.has_hj_op_id()) { |
| set_hj_op_id(from.hj_op_id()); |
| } |
| if (from.has_rf_identifier()) { |
| set_rf_identifier(from.rf_identifier()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void RuntimeFilterBDef::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void RuntimeFilterBDef::CopyFrom(const RuntimeFilterBDef& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool RuntimeFilterBDef::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void RuntimeFilterBDef::Swap(RuntimeFilterBDef* other) { |
| if (other != this) { |
| std::swap(query_id_, other->query_id_); |
| std::swap(major_fragment_id_, other->major_fragment_id_); |
| std::swap(minor_fragment_id_, other->minor_fragment_id_); |
| std::swap(to_foreman_, other->to_foreman_); |
| bloom_filter_size_in_bytes_.Swap(&other->bloom_filter_size_in_bytes_); |
| probe_fields_.Swap(&other->probe_fields_); |
| std::swap(hj_op_id_, other->hj_op_id_); |
| std::swap(rf_identifier_, other->rf_identifier_); |
| 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 RuntimeFilterBDef::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = RuntimeFilterBDef_descriptor_; |
| metadata.reflection = RuntimeFilterBDef_reflection_; |
| return metadata; |
| } |
| |
| |
| // @@protoc_insertion_point(namespace_scope) |
| |
| } // namespace data |
| } // namespace bit |
| } // namespace exec |
| |
| // @@protoc_insertion_point(global_scope) |