| // Generated by the protocol buffer compiler. DO NOT EDIT! |
| // source: BitControl.proto |
| |
| #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION |
| #include "BitControl.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 control { |
| |
| namespace { |
| |
| const ::google::protobuf::Descriptor* BitControlHandshake_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| BitControlHandshake_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* BitStatus_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| BitStatus_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* FragmentStatus_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| FragmentStatus_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* InitializeFragments_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| InitializeFragments_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* CustomMessage_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| CustomMessage_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* PlanFragment_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| PlanFragment_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* Collector_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| Collector_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* QueryContextInformation_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| QueryContextInformation_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* WorkQueueStatus_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| WorkQueueStatus_reflection_ = NULL; |
| const ::google::protobuf::Descriptor* FinishedReceiver_descriptor_ = NULL; |
| const ::google::protobuf::internal::GeneratedMessageReflection* |
| FinishedReceiver_reflection_ = NULL; |
| const ::google::protobuf::EnumDescriptor* RpcType_descriptor_ = NULL; |
| |
| } // namespace |
| |
| |
| void protobuf_AssignDesc_BitControl_2eproto() { |
| protobuf_AddDesc_BitControl_2eproto(); |
| const ::google::protobuf::FileDescriptor* file = |
| ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( |
| "BitControl.proto"); |
| GOOGLE_CHECK(file != NULL); |
| BitControlHandshake_descriptor_ = file->message_type(0); |
| static const int BitControlHandshake_offsets_[4] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitControlHandshake, rpc_version_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitControlHandshake, channel_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitControlHandshake, endpoint_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitControlHandshake, authenticationmechanisms_), |
| }; |
| BitControlHandshake_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| BitControlHandshake_descriptor_, |
| BitControlHandshake::default_instance_, |
| BitControlHandshake_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitControlHandshake, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitControlHandshake, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(BitControlHandshake)); |
| BitStatus_descriptor_ = file->message_type(1); |
| static const int BitStatus_offsets_[1] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitStatus, fragment_status_), |
| }; |
| BitStatus_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| BitStatus_descriptor_, |
| BitStatus::default_instance_, |
| BitStatus_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitStatus, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitStatus, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(BitStatus)); |
| FragmentStatus_descriptor_ = file->message_type(2); |
| static const int FragmentStatus_offsets_[2] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentStatus, profile_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentStatus, handle_), |
| }; |
| FragmentStatus_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| FragmentStatus_descriptor_, |
| FragmentStatus::default_instance_, |
| FragmentStatus_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentStatus, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentStatus, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(FragmentStatus)); |
| InitializeFragments_descriptor_ = file->message_type(3); |
| static const int InitializeFragments_offsets_[1] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InitializeFragments, fragment_), |
| }; |
| InitializeFragments_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| InitializeFragments_descriptor_, |
| InitializeFragments::default_instance_, |
| InitializeFragments_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InitializeFragments, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InitializeFragments, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(InitializeFragments)); |
| CustomMessage_descriptor_ = file->message_type(4); |
| static const int CustomMessage_offsets_[2] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CustomMessage, type_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CustomMessage, message_), |
| }; |
| CustomMessage_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| CustomMessage_descriptor_, |
| CustomMessage::default_instance_, |
| CustomMessage_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CustomMessage, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CustomMessage, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(CustomMessage)); |
| PlanFragment_descriptor_ = file->message_type(5); |
| static const int PlanFragment_offsets_[15] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, handle_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, network_cost_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, cpu_cost_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, disk_cost_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, memory_cost_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, fragment_json_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, leaf_fragment_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, assignment_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, foreman_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, mem_initial_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, mem_max_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, credentials_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, options_json_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, context_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, collector_), |
| }; |
| PlanFragment_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| PlanFragment_descriptor_, |
| PlanFragment::default_instance_, |
| PlanFragment_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlanFragment, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(PlanFragment)); |
| Collector_descriptor_ = file->message_type(6); |
| static const int Collector_offsets_[4] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Collector, opposite_major_fragment_id_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Collector, incoming_minor_fragment_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Collector, supports_out_of_order_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Collector, is_spooling_), |
| }; |
| Collector_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| Collector_descriptor_, |
| Collector::default_instance_, |
| Collector_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Collector, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Collector, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(Collector)); |
| QueryContextInformation_descriptor_ = file->message_type(7); |
| static const int QueryContextInformation_offsets_[4] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryContextInformation, query_start_time_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryContextInformation, time_zone_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryContextInformation, default_schema_name_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryContextInformation, session_id_), |
| }; |
| QueryContextInformation_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| QueryContextInformation_descriptor_, |
| QueryContextInformation::default_instance_, |
| QueryContextInformation_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryContextInformation, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryContextInformation, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(QueryContextInformation)); |
| WorkQueueStatus_descriptor_ = file->message_type(8); |
| static const int WorkQueueStatus_offsets_[3] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WorkQueueStatus, endpoint_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WorkQueueStatus, queue_length_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WorkQueueStatus, report_time_), |
| }; |
| WorkQueueStatus_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| WorkQueueStatus_descriptor_, |
| WorkQueueStatus::default_instance_, |
| WorkQueueStatus_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WorkQueueStatus, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WorkQueueStatus, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(WorkQueueStatus)); |
| FinishedReceiver_descriptor_ = file->message_type(9); |
| static const int FinishedReceiver_offsets_[2] = { |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FinishedReceiver, receiver_), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FinishedReceiver, sender_), |
| }; |
| FinishedReceiver_reflection_ = |
| new ::google::protobuf::internal::GeneratedMessageReflection( |
| FinishedReceiver_descriptor_, |
| FinishedReceiver::default_instance_, |
| FinishedReceiver_offsets_, |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FinishedReceiver, _has_bits_[0]), |
| GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FinishedReceiver, _unknown_fields_), |
| -1, |
| ::google::protobuf::DescriptorPool::generated_pool(), |
| ::google::protobuf::MessageFactory::generated_factory(), |
| sizeof(FinishedReceiver)); |
| 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_BitControl_2eproto); |
| } |
| |
| void protobuf_RegisterTypes(const ::std::string&) { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| BitControlHandshake_descriptor_, &BitControlHandshake::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| BitStatus_descriptor_, &BitStatus::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| FragmentStatus_descriptor_, &FragmentStatus::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| InitializeFragments_descriptor_, &InitializeFragments::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| CustomMessage_descriptor_, &CustomMessage::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| PlanFragment_descriptor_, &PlanFragment::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| Collector_descriptor_, &Collector::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| QueryContextInformation_descriptor_, &QueryContextInformation::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| WorkQueueStatus_descriptor_, &WorkQueueStatus::default_instance()); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( |
| FinishedReceiver_descriptor_, &FinishedReceiver::default_instance()); |
| } |
| |
| } // namespace |
| |
| void protobuf_ShutdownFile_BitControl_2eproto() { |
| delete BitControlHandshake::default_instance_; |
| delete BitControlHandshake_reflection_; |
| delete BitStatus::default_instance_; |
| delete BitStatus_reflection_; |
| delete FragmentStatus::default_instance_; |
| delete FragmentStatus_reflection_; |
| delete InitializeFragments::default_instance_; |
| delete InitializeFragments_reflection_; |
| delete CustomMessage::default_instance_; |
| delete CustomMessage_reflection_; |
| delete PlanFragment::default_instance_; |
| delete PlanFragment_reflection_; |
| delete Collector::default_instance_; |
| delete Collector_reflection_; |
| delete QueryContextInformation::default_instance_; |
| delete QueryContextInformation_reflection_; |
| delete WorkQueueStatus::default_instance_; |
| delete WorkQueueStatus_reflection_; |
| delete FinishedReceiver::default_instance_; |
| delete FinishedReceiver_reflection_; |
| } |
| |
| void protobuf_AddDesc_BitControl_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\020BitControl.proto\022\020exec.bit.control\032\025Ex" |
| "ecutionProtos.proto\032\022Coordination.proto\032" |
| "\023UserBitShared.proto\"\255\001\n\023BitControlHands" |
| "hake\022\023\n\013rpc_version\030\001 \001(\005\0225\n\007channel\030\002 \001" |
| "(\0162\027.exec.shared.RpcChannel:\013BIT_CONTROL" |
| "\022(\n\010endpoint\030\003 \001(\0132\026.exec.DrillbitEndpoi" |
| "nt\022 \n\030authenticationMechanisms\030\004 \003(\t\"F\n\t" |
| "BitStatus\0229\n\017fragment_status\030\001 \003(\0132 .exe" |
| "c.bit.control.FragmentStatus\"n\n\016Fragment" |
| "Status\0222\n\007profile\030\001 \001(\0132!.exec.shared.Mi" |
| "norFragmentProfile\022(\n\006handle\030\002 \001(\0132\030.exe" |
| "c.bit.FragmentHandle\"G\n\023InitializeFragme" |
| "nts\0220\n\010fragment\030\001 \003(\0132\036.exec.bit.control" |
| ".PlanFragment\".\n\rCustomMessage\022\014\n\004type\030\001" |
| " \001(\005\022\017\n\007message\030\002 \001(\014\"\374\003\n\014PlanFragment\022(" |
| "\n\006handle\030\001 \001(\0132\030.exec.bit.FragmentHandle" |
| "\022\024\n\014network_cost\030\004 \001(\002\022\020\n\010cpu_cost\030\005 \001(\002" |
| "\022\021\n\tdisk_cost\030\006 \001(\002\022\023\n\013memory_cost\030\007 \001(\002" |
| "\022\025\n\rfragment_json\030\010 \001(\t\022\025\n\rleaf_fragment" |
| "\030\t \001(\010\022*\n\nassignment\030\n \001(\0132\026.exec.Drillb" |
| "itEndpoint\022\'\n\007foreman\030\013 \001(\0132\026.exec.Drill" |
| "bitEndpoint\022\035\n\013mem_initial\030\014 \001(\003:\010200000" |
| "00\022\033\n\007mem_max\030\r \001(\003:\n2000000000\0221\n\013crede" |
| "ntials\030\016 \001(\0132\034.exec.shared.UserCredentia" |
| "ls\022\024\n\014options_json\030\017 \001(\t\022:\n\007context\030\020 \001(" |
| "\0132).exec.bit.control.QueryContextInforma" |
| "tion\022.\n\tcollector\030\021 \003(\0132\033.exec.bit.contr" |
| "ol.Collector\"\210\001\n\tCollector\022\"\n\032opposite_m" |
| "ajor_fragment_id\030\001 \001(\005\022#\n\027incoming_minor" |
| "_fragment\030\002 \003(\005B\002\020\001\022\035\n\025supports_out_of_o" |
| "rder\030\003 \001(\010\022\023\n\013is_spooling\030\004 \001(\010\"w\n\027Query" |
| "ContextInformation\022\030\n\020query_start_time\030\001" |
| " \001(\003\022\021\n\ttime_zone\030\002 \001(\005\022\033\n\023default_schem" |
| "a_name\030\003 \001(\t\022\022\n\nsession_id\030\004 \001(\t\"f\n\017Work" |
| "QueueStatus\022(\n\010endpoint\030\001 \001(\0132\026.exec.Dri" |
| "llbitEndpoint\022\024\n\014queue_length\030\002 \001(\005\022\023\n\013r" |
| "eport_time\030\003 \001(\003\"h\n\020FinishedReceiver\022*\n\010" |
| "receiver\030\001 \001(\0132\030.exec.bit.FragmentHandle" |
| "\022(\n\006sender\030\002 \001(\0132\030.exec.bit.FragmentHand" |
| "le*\206\003\n\007RpcType\022\r\n\tHANDSHAKE\020\000\022\007\n\003ACK\020\001\022\013" |
| "\n\007GOODBYE\020\002\022\034\n\030REQ_INITIALIZE_FRAGMENTS\020" |
| "\003\022\027\n\023REQ_CANCEL_FRAGMENT\020\006\022\031\n\025REQ_RECEIV" |
| "ER_FINISHED\020\007\022\027\n\023REQ_FRAGMENT_STATUS\020\010\022\022" |
| "\n\016REQ_BIT_STATUS\020\t\022\024\n\020REQ_QUERY_STATUS\020\n" |
| "\022\024\n\020REQ_QUERY_CANCEL\020\017\022\030\n\024REQ_UNPAUSE_FR" |
| "AGMENT\020\020\022\016\n\nREQ_CUSTOM\020\021\022\030\n\024RESP_FRAGMEN" |
| "T_HANDLE\020\013\022\030\n\024RESP_FRAGMENT_STATUS\020\014\022\023\n\017" |
| "RESP_BIT_STATUS\020\r\022\025\n\021RESP_QUERY_STATUS\020\016" |
| "\022\017\n\013RESP_CUSTOM\020\022\022\020\n\014SASL_MESSAGE\020\023B+\n\033o" |
| "rg.apache.drill.exec.protoB\nBitControlH\001", 2000); |
| ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( |
| "BitControl.proto", &protobuf_RegisterTypes); |
| BitControlHandshake::default_instance_ = new BitControlHandshake(); |
| BitStatus::default_instance_ = new BitStatus(); |
| FragmentStatus::default_instance_ = new FragmentStatus(); |
| InitializeFragments::default_instance_ = new InitializeFragments(); |
| CustomMessage::default_instance_ = new CustomMessage(); |
| PlanFragment::default_instance_ = new PlanFragment(); |
| Collector::default_instance_ = new Collector(); |
| QueryContextInformation::default_instance_ = new QueryContextInformation(); |
| WorkQueueStatus::default_instance_ = new WorkQueueStatus(); |
| FinishedReceiver::default_instance_ = new FinishedReceiver(); |
| BitControlHandshake::default_instance_->InitAsDefaultInstance(); |
| BitStatus::default_instance_->InitAsDefaultInstance(); |
| FragmentStatus::default_instance_->InitAsDefaultInstance(); |
| InitializeFragments::default_instance_->InitAsDefaultInstance(); |
| CustomMessage::default_instance_->InitAsDefaultInstance(); |
| PlanFragment::default_instance_->InitAsDefaultInstance(); |
| Collector::default_instance_->InitAsDefaultInstance(); |
| QueryContextInformation::default_instance_->InitAsDefaultInstance(); |
| WorkQueueStatus::default_instance_->InitAsDefaultInstance(); |
| FinishedReceiver::default_instance_->InitAsDefaultInstance(); |
| ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_BitControl_2eproto); |
| } |
| |
| // Force AddDescriptors() to be called at static initialization time. |
| struct StaticDescriptorInitializer_BitControl_2eproto { |
| StaticDescriptorInitializer_BitControl_2eproto() { |
| protobuf_AddDesc_BitControl_2eproto(); |
| } |
| } static_descriptor_initializer_BitControl_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 6: |
| case 7: |
| case 8: |
| case 9: |
| case 10: |
| case 11: |
| case 12: |
| case 13: |
| case 14: |
| case 15: |
| case 16: |
| case 17: |
| case 18: |
| case 19: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int BitControlHandshake::kRpcVersionFieldNumber; |
| const int BitControlHandshake::kChannelFieldNumber; |
| const int BitControlHandshake::kEndpointFieldNumber; |
| const int BitControlHandshake::kAuthenticationMechanismsFieldNumber; |
| #endif // !_MSC_VER |
| |
| BitControlHandshake::BitControlHandshake() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void BitControlHandshake::InitAsDefaultInstance() { |
| endpoint_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance()); |
| } |
| |
| BitControlHandshake::BitControlHandshake(const BitControlHandshake& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void BitControlHandshake::SharedCtor() { |
| _cached_size_ = 0; |
| rpc_version_ = 0; |
| channel_ = 0; |
| endpoint_ = NULL; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| BitControlHandshake::~BitControlHandshake() { |
| SharedDtor(); |
| } |
| |
| void BitControlHandshake::SharedDtor() { |
| if (this != default_instance_) { |
| delete endpoint_; |
| } |
| } |
| |
| void BitControlHandshake::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* BitControlHandshake::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return BitControlHandshake_descriptor_; |
| } |
| |
| const BitControlHandshake& BitControlHandshake::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| BitControlHandshake* BitControlHandshake::default_instance_ = NULL; |
| |
| BitControlHandshake* BitControlHandshake::New() const { |
| return new BitControlHandshake; |
| } |
| |
| void BitControlHandshake::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| rpc_version_ = 0; |
| channel_ = 0; |
| if (has_endpoint()) { |
| if (endpoint_ != NULL) endpoint_->::exec::DrillbitEndpoint::Clear(); |
| } |
| } |
| authenticationmechanisms_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool BitControlHandshake::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_CONTROL]; |
| 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->ExpectTag(26)) goto parse_endpoint; |
| break; |
| } |
| |
| // optional .exec.DrillbitEndpoint endpoint = 3; |
| case 3: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_endpoint: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_endpoint())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(34)) goto parse_authenticationMechanisms; |
| break; |
| } |
| |
| // repeated string authenticationMechanisms = 4; |
| case 4: { |
| 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(34)) 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 BitControlHandshake::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_CONTROL]; |
| if (has_channel()) { |
| ::google::protobuf::internal::WireFormatLite::WriteEnum( |
| 2, this->channel(), output); |
| } |
| |
| // optional .exec.DrillbitEndpoint endpoint = 3; |
| if (has_endpoint()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 3, this->endpoint(), output); |
| } |
| |
| // repeated string authenticationMechanisms = 4; |
| 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( |
| 4, this->authenticationmechanisms(i), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* BitControlHandshake::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_CONTROL]; |
| if (has_channel()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( |
| 2, this->channel(), target); |
| } |
| |
| // optional .exec.DrillbitEndpoint endpoint = 3; |
| if (has_endpoint()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 3, this->endpoint(), target); |
| } |
| |
| // repeated string authenticationMechanisms = 4; |
| 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(4, this->authenticationmechanisms(i), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int BitControlHandshake::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_CONTROL]; |
| if (has_channel()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::EnumSize(this->channel()); |
| } |
| |
| // optional .exec.DrillbitEndpoint endpoint = 3; |
| if (has_endpoint()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->endpoint()); |
| } |
| |
| } |
| // repeated string authenticationMechanisms = 4; |
| 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 BitControlHandshake::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const BitControlHandshake* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const BitControlHandshake*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void BitControlHandshake::MergeFrom(const BitControlHandshake& 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()); |
| } |
| if (from.has_channel()) { |
| set_channel(from.channel()); |
| } |
| if (from.has_endpoint()) { |
| mutable_endpoint()->::exec::DrillbitEndpoint::MergeFrom(from.endpoint()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void BitControlHandshake::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void BitControlHandshake::CopyFrom(const BitControlHandshake& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool BitControlHandshake::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void BitControlHandshake::Swap(BitControlHandshake* other) { |
| if (other != this) { |
| std::swap(rpc_version_, other->rpc_version_); |
| std::swap(channel_, other->channel_); |
| std::swap(endpoint_, other->endpoint_); |
| 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 BitControlHandshake::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = BitControlHandshake_descriptor_; |
| metadata.reflection = BitControlHandshake_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int BitStatus::kFragmentStatusFieldNumber; |
| #endif // !_MSC_VER |
| |
| BitStatus::BitStatus() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void BitStatus::InitAsDefaultInstance() { |
| } |
| |
| BitStatus::BitStatus(const BitStatus& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void BitStatus::SharedCtor() { |
| _cached_size_ = 0; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| BitStatus::~BitStatus() { |
| SharedDtor(); |
| } |
| |
| void BitStatus::SharedDtor() { |
| if (this != default_instance_) { |
| } |
| } |
| |
| void BitStatus::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* BitStatus::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return BitStatus_descriptor_; |
| } |
| |
| const BitStatus& BitStatus::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| BitStatus* BitStatus::default_instance_ = NULL; |
| |
| BitStatus* BitStatus::New() const { |
| return new BitStatus; |
| } |
| |
| void BitStatus::Clear() { |
| fragment_status_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool BitStatus::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)) { |
| // repeated .exec.bit.control.FragmentStatus fragment_status = 1; |
| case 1: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_fragment_status: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, add_fragment_status())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(10)) goto parse_fragment_status; |
| 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 BitStatus::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // repeated .exec.bit.control.FragmentStatus fragment_status = 1; |
| for (int i = 0; i < this->fragment_status_size(); i++) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->fragment_status(i), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* BitStatus::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // repeated .exec.bit.control.FragmentStatus fragment_status = 1; |
| for (int i = 0; i < this->fragment_status_size(); i++) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->fragment_status(i), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int BitStatus::ByteSize() const { |
| int total_size = 0; |
| |
| // repeated .exec.bit.control.FragmentStatus fragment_status = 1; |
| total_size += 1 * this->fragment_status_size(); |
| for (int i = 0; i < this->fragment_status_size(); i++) { |
| total_size += |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->fragment_status(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 BitStatus::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const BitStatus* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const BitStatus*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void BitStatus::MergeFrom(const BitStatus& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| fragment_status_.MergeFrom(from.fragment_status_); |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void BitStatus::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void BitStatus::CopyFrom(const BitStatus& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool BitStatus::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void BitStatus::Swap(BitStatus* other) { |
| if (other != this) { |
| fragment_status_.Swap(&other->fragment_status_); |
| 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 BitStatus::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = BitStatus_descriptor_; |
| metadata.reflection = BitStatus_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int FragmentStatus::kProfileFieldNumber; |
| const int FragmentStatus::kHandleFieldNumber; |
| #endif // !_MSC_VER |
| |
| FragmentStatus::FragmentStatus() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void FragmentStatus::InitAsDefaultInstance() { |
| profile_ = const_cast< ::exec::shared::MinorFragmentProfile*>(&::exec::shared::MinorFragmentProfile::default_instance()); |
| handle_ = const_cast< ::exec::bit::FragmentHandle*>(&::exec::bit::FragmentHandle::default_instance()); |
| } |
| |
| FragmentStatus::FragmentStatus(const FragmentStatus& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void FragmentStatus::SharedCtor() { |
| _cached_size_ = 0; |
| profile_ = NULL; |
| handle_ = NULL; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| FragmentStatus::~FragmentStatus() { |
| SharedDtor(); |
| } |
| |
| void FragmentStatus::SharedDtor() { |
| if (this != default_instance_) { |
| delete profile_; |
| delete handle_; |
| } |
| } |
| |
| void FragmentStatus::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* FragmentStatus::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return FragmentStatus_descriptor_; |
| } |
| |
| const FragmentStatus& FragmentStatus::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| FragmentStatus* FragmentStatus::default_instance_ = NULL; |
| |
| FragmentStatus* FragmentStatus::New() const { |
| return new FragmentStatus; |
| } |
| |
| void FragmentStatus::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (has_profile()) { |
| if (profile_ != NULL) profile_->::exec::shared::MinorFragmentProfile::Clear(); |
| } |
| if (has_handle()) { |
| if (handle_ != NULL) handle_->::exec::bit::FragmentHandle::Clear(); |
| } |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool FragmentStatus::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.MinorFragmentProfile profile = 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_profile())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(18)) goto parse_handle; |
| break; |
| } |
| |
| // optional .exec.bit.FragmentHandle handle = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_handle: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_handle())); |
| } 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 FragmentStatus::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional .exec.shared.MinorFragmentProfile profile = 1; |
| if (has_profile()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->profile(), output); |
| } |
| |
| // optional .exec.bit.FragmentHandle handle = 2; |
| if (has_handle()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 2, this->handle(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* FragmentStatus::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional .exec.shared.MinorFragmentProfile profile = 1; |
| if (has_profile()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->profile(), target); |
| } |
| |
| // optional .exec.bit.FragmentHandle handle = 2; |
| if (has_handle()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 2, this->handle(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int FragmentStatus::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional .exec.shared.MinorFragmentProfile profile = 1; |
| if (has_profile()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->profile()); |
| } |
| |
| // optional .exec.bit.FragmentHandle handle = 2; |
| if (has_handle()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->handle()); |
| } |
| |
| } |
| 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 FragmentStatus::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const FragmentStatus* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const FragmentStatus*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void FragmentStatus::MergeFrom(const FragmentStatus& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_profile()) { |
| mutable_profile()->::exec::shared::MinorFragmentProfile::MergeFrom(from.profile()); |
| } |
| if (from.has_handle()) { |
| mutable_handle()->::exec::bit::FragmentHandle::MergeFrom(from.handle()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void FragmentStatus::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void FragmentStatus::CopyFrom(const FragmentStatus& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool FragmentStatus::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void FragmentStatus::Swap(FragmentStatus* other) { |
| if (other != this) { |
| std::swap(profile_, other->profile_); |
| std::swap(handle_, other->handle_); |
| 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 FragmentStatus::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = FragmentStatus_descriptor_; |
| metadata.reflection = FragmentStatus_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int InitializeFragments::kFragmentFieldNumber; |
| #endif // !_MSC_VER |
| |
| InitializeFragments::InitializeFragments() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void InitializeFragments::InitAsDefaultInstance() { |
| } |
| |
| InitializeFragments::InitializeFragments(const InitializeFragments& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void InitializeFragments::SharedCtor() { |
| _cached_size_ = 0; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| InitializeFragments::~InitializeFragments() { |
| SharedDtor(); |
| } |
| |
| void InitializeFragments::SharedDtor() { |
| if (this != default_instance_) { |
| } |
| } |
| |
| void InitializeFragments::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* InitializeFragments::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return InitializeFragments_descriptor_; |
| } |
| |
| const InitializeFragments& InitializeFragments::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| InitializeFragments* InitializeFragments::default_instance_ = NULL; |
| |
| InitializeFragments* InitializeFragments::New() const { |
| return new InitializeFragments; |
| } |
| |
| void InitializeFragments::Clear() { |
| fragment_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool InitializeFragments::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)) { |
| // repeated .exec.bit.control.PlanFragment fragment = 1; |
| case 1: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_fragment: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, add_fragment())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(10)) goto parse_fragment; |
| 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 InitializeFragments::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // repeated .exec.bit.control.PlanFragment fragment = 1; |
| for (int i = 0; i < this->fragment_size(); i++) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->fragment(i), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* InitializeFragments::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // repeated .exec.bit.control.PlanFragment fragment = 1; |
| for (int i = 0; i < this->fragment_size(); i++) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->fragment(i), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int InitializeFragments::ByteSize() const { |
| int total_size = 0; |
| |
| // repeated .exec.bit.control.PlanFragment fragment = 1; |
| total_size += 1 * this->fragment_size(); |
| for (int i = 0; i < this->fragment_size(); i++) { |
| total_size += |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->fragment(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 InitializeFragments::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const InitializeFragments* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const InitializeFragments*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void InitializeFragments::MergeFrom(const InitializeFragments& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| fragment_.MergeFrom(from.fragment_); |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void InitializeFragments::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void InitializeFragments::CopyFrom(const InitializeFragments& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool InitializeFragments::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void InitializeFragments::Swap(InitializeFragments* other) { |
| if (other != this) { |
| fragment_.Swap(&other->fragment_); |
| 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 InitializeFragments::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = InitializeFragments_descriptor_; |
| metadata.reflection = InitializeFragments_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int CustomMessage::kTypeFieldNumber; |
| const int CustomMessage::kMessageFieldNumber; |
| #endif // !_MSC_VER |
| |
| CustomMessage::CustomMessage() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void CustomMessage::InitAsDefaultInstance() { |
| } |
| |
| CustomMessage::CustomMessage(const CustomMessage& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void CustomMessage::SharedCtor() { |
| _cached_size_ = 0; |
| type_ = 0; |
| message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| CustomMessage::~CustomMessage() { |
| SharedDtor(); |
| } |
| |
| void CustomMessage::SharedDtor() { |
| if (message_ != &::google::protobuf::internal::kEmptyString) { |
| delete message_; |
| } |
| if (this != default_instance_) { |
| } |
| } |
| |
| void CustomMessage::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* CustomMessage::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return CustomMessage_descriptor_; |
| } |
| |
| const CustomMessage& CustomMessage::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| CustomMessage* CustomMessage::default_instance_ = NULL; |
| |
| CustomMessage* CustomMessage::New() const { |
| return new CustomMessage; |
| } |
| |
| void CustomMessage::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| type_ = 0; |
| if (has_message()) { |
| if (message_ != &::google::protobuf::internal::kEmptyString) { |
| message_->clear(); |
| } |
| } |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool CustomMessage::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 type = 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, &type_))); |
| set_has_type(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(18)) goto parse_message; |
| break; |
| } |
| |
| // optional bytes message = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_message: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( |
| input, this->mutable_message())); |
| } 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 CustomMessage::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional int32 type = 1; |
| if (has_type()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type(), output); |
| } |
| |
| // optional bytes message = 2; |
| if (has_message()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBytes( |
| 2, this->message(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* CustomMessage::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional int32 type = 1; |
| if (has_type()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->type(), target); |
| } |
| |
| // optional bytes message = 2; |
| if (has_message()) { |
| target = |
| ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( |
| 2, this->message(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int CustomMessage::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional int32 type = 1; |
| if (has_type()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->type()); |
| } |
| |
| // optional bytes message = 2; |
| if (has_message()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::BytesSize( |
| this->message()); |
| } |
| |
| } |
| 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 CustomMessage::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const CustomMessage* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const CustomMessage*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void CustomMessage::MergeFrom(const CustomMessage& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_type()) { |
| set_type(from.type()); |
| } |
| if (from.has_message()) { |
| set_message(from.message()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void CustomMessage::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void CustomMessage::CopyFrom(const CustomMessage& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool CustomMessage::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void CustomMessage::Swap(CustomMessage* other) { |
| if (other != this) { |
| std::swap(type_, other->type_); |
| std::swap(message_, other->message_); |
| 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 CustomMessage::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = CustomMessage_descriptor_; |
| metadata.reflection = CustomMessage_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int PlanFragment::kHandleFieldNumber; |
| const int PlanFragment::kNetworkCostFieldNumber; |
| const int PlanFragment::kCpuCostFieldNumber; |
| const int PlanFragment::kDiskCostFieldNumber; |
| const int PlanFragment::kMemoryCostFieldNumber; |
| const int PlanFragment::kFragmentJsonFieldNumber; |
| const int PlanFragment::kLeafFragmentFieldNumber; |
| const int PlanFragment::kAssignmentFieldNumber; |
| const int PlanFragment::kForemanFieldNumber; |
| const int PlanFragment::kMemInitialFieldNumber; |
| const int PlanFragment::kMemMaxFieldNumber; |
| const int PlanFragment::kCredentialsFieldNumber; |
| const int PlanFragment::kOptionsJsonFieldNumber; |
| const int PlanFragment::kContextFieldNumber; |
| const int PlanFragment::kCollectorFieldNumber; |
| #endif // !_MSC_VER |
| |
| PlanFragment::PlanFragment() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void PlanFragment::InitAsDefaultInstance() { |
| handle_ = const_cast< ::exec::bit::FragmentHandle*>(&::exec::bit::FragmentHandle::default_instance()); |
| assignment_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance()); |
| foreman_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance()); |
| credentials_ = const_cast< ::exec::shared::UserCredentials*>(&::exec::shared::UserCredentials::default_instance()); |
| context_ = const_cast< ::exec::bit::control::QueryContextInformation*>(&::exec::bit::control::QueryContextInformation::default_instance()); |
| } |
| |
| PlanFragment::PlanFragment(const PlanFragment& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void PlanFragment::SharedCtor() { |
| _cached_size_ = 0; |
| handle_ = NULL; |
| network_cost_ = 0; |
| cpu_cost_ = 0; |
| disk_cost_ = 0; |
| memory_cost_ = 0; |
| fragment_json_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); |
| leaf_fragment_ = false; |
| assignment_ = NULL; |
| foreman_ = NULL; |
| mem_initial_ = GOOGLE_LONGLONG(20000000); |
| mem_max_ = GOOGLE_LONGLONG(2000000000); |
| credentials_ = NULL; |
| options_json_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); |
| context_ = NULL; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| PlanFragment::~PlanFragment() { |
| SharedDtor(); |
| } |
| |
| void PlanFragment::SharedDtor() { |
| if (fragment_json_ != &::google::protobuf::internal::kEmptyString) { |
| delete fragment_json_; |
| } |
| if (options_json_ != &::google::protobuf::internal::kEmptyString) { |
| delete options_json_; |
| } |
| if (this != default_instance_) { |
| delete handle_; |
| delete assignment_; |
| delete foreman_; |
| delete credentials_; |
| delete context_; |
| } |
| } |
| |
| void PlanFragment::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* PlanFragment::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return PlanFragment_descriptor_; |
| } |
| |
| const PlanFragment& PlanFragment::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| PlanFragment* PlanFragment::default_instance_ = NULL; |
| |
| PlanFragment* PlanFragment::New() const { |
| return new PlanFragment; |
| } |
| |
| void PlanFragment::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (has_handle()) { |
| if (handle_ != NULL) handle_->::exec::bit::FragmentHandle::Clear(); |
| } |
| network_cost_ = 0; |
| cpu_cost_ = 0; |
| disk_cost_ = 0; |
| memory_cost_ = 0; |
| if (has_fragment_json()) { |
| if (fragment_json_ != &::google::protobuf::internal::kEmptyString) { |
| fragment_json_->clear(); |
| } |
| } |
| leaf_fragment_ = false; |
| if (has_assignment()) { |
| if (assignment_ != NULL) assignment_->::exec::DrillbitEndpoint::Clear(); |
| } |
| } |
| if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { |
| if (has_foreman()) { |
| if (foreman_ != NULL) foreman_->::exec::DrillbitEndpoint::Clear(); |
| } |
| mem_initial_ = GOOGLE_LONGLONG(20000000); |
| mem_max_ = GOOGLE_LONGLONG(2000000000); |
| if (has_credentials()) { |
| if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear(); |
| } |
| if (has_options_json()) { |
| if (options_json_ != &::google::protobuf::internal::kEmptyString) { |
| options_json_->clear(); |
| } |
| } |
| if (has_context()) { |
| if (context_ != NULL) context_->::exec::bit::control::QueryContextInformation::Clear(); |
| } |
| } |
| collector_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool PlanFragment::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.bit.FragmentHandle handle = 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_handle())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(37)) goto parse_network_cost; |
| break; |
| } |
| |
| // optional float network_cost = 4; |
| case 4: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { |
| parse_network_cost: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( |
| input, &network_cost_))); |
| set_has_network_cost(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(45)) goto parse_cpu_cost; |
| break; |
| } |
| |
| // optional float cpu_cost = 5; |
| case 5: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { |
| parse_cpu_cost: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( |
| input, &cpu_cost_))); |
| set_has_cpu_cost(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(53)) goto parse_disk_cost; |
| break; |
| } |
| |
| // optional float disk_cost = 6; |
| case 6: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { |
| parse_disk_cost: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( |
| input, &disk_cost_))); |
| set_has_disk_cost(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(61)) goto parse_memory_cost; |
| break; |
| } |
| |
| // optional float memory_cost = 7; |
| case 7: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { |
| parse_memory_cost: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( |
| input, &memory_cost_))); |
| set_has_memory_cost(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(66)) goto parse_fragment_json; |
| break; |
| } |
| |
| // optional string fragment_json = 8; |
| case 8: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_fragment_json: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadString( |
| input, this->mutable_fragment_json())); |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->fragment_json().data(), this->fragment_json().length(), |
| ::google::protobuf::internal::WireFormat::PARSE); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(72)) goto parse_leaf_fragment; |
| break; |
| } |
| |
| // optional bool leaf_fragment = 9; |
| case 9: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_leaf_fragment: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( |
| input, &leaf_fragment_))); |
| set_has_leaf_fragment(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(82)) goto parse_assignment; |
| break; |
| } |
| |
| // optional .exec.DrillbitEndpoint assignment = 10; |
| case 10: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_assignment: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_assignment())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(90)) goto parse_foreman; |
| break; |
| } |
| |
| // optional .exec.DrillbitEndpoint foreman = 11; |
| case 11: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_foreman: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_foreman())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(96)) goto parse_mem_initial; |
| break; |
| } |
| |
| // optional int64 mem_initial = 12 [default = 20000000]; |
| case 12: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_mem_initial: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( |
| input, &mem_initial_))); |
| set_has_mem_initial(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(104)) goto parse_mem_max; |
| break; |
| } |
| |
| // optional int64 mem_max = 13 [default = 2000000000]; |
| case 13: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_mem_max: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( |
| input, &mem_max_))); |
| set_has_mem_max(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(114)) goto parse_credentials; |
| break; |
| } |
| |
| // optional .exec.shared.UserCredentials credentials = 14; |
| case 14: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_credentials: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_credentials())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(122)) goto parse_options_json; |
| break; |
| } |
| |
| // optional string options_json = 15; |
| case 15: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_options_json: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadString( |
| input, this->mutable_options_json())); |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->options_json().data(), this->options_json().length(), |
| ::google::protobuf::internal::WireFormat::PARSE); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(130)) goto parse_context; |
| break; |
| } |
| |
| // optional .exec.bit.control.QueryContextInformation context = 16; |
| case 16: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_context: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_context())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(138)) goto parse_collector; |
| break; |
| } |
| |
| // repeated .exec.bit.control.Collector collector = 17; |
| case 17: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_collector: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, add_collector())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(138)) goto parse_collector; |
| 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 PlanFragment::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional .exec.bit.FragmentHandle handle = 1; |
| if (has_handle()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->handle(), output); |
| } |
| |
| // optional float network_cost = 4; |
| if (has_network_cost()) { |
| ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->network_cost(), output); |
| } |
| |
| // optional float cpu_cost = 5; |
| if (has_cpu_cost()) { |
| ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->cpu_cost(), output); |
| } |
| |
| // optional float disk_cost = 6; |
| if (has_disk_cost()) { |
| ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->disk_cost(), output); |
| } |
| |
| // optional float memory_cost = 7; |
| if (has_memory_cost()) { |
| ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->memory_cost(), output); |
| } |
| |
| // optional string fragment_json = 8; |
| if (has_fragment_json()) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->fragment_json().data(), this->fragment_json().length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| ::google::protobuf::internal::WireFormatLite::WriteString( |
| 8, this->fragment_json(), output); |
| } |
| |
| // optional bool leaf_fragment = 9; |
| if (has_leaf_fragment()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->leaf_fragment(), output); |
| } |
| |
| // optional .exec.DrillbitEndpoint assignment = 10; |
| if (has_assignment()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 10, this->assignment(), output); |
| } |
| |
| // optional .exec.DrillbitEndpoint foreman = 11; |
| if (has_foreman()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 11, this->foreman(), output); |
| } |
| |
| // optional int64 mem_initial = 12 [default = 20000000]; |
| if (has_mem_initial()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt64(12, this->mem_initial(), output); |
| } |
| |
| // optional int64 mem_max = 13 [default = 2000000000]; |
| if (has_mem_max()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt64(13, this->mem_max(), output); |
| } |
| |
| // optional .exec.shared.UserCredentials credentials = 14; |
| if (has_credentials()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 14, this->credentials(), output); |
| } |
| |
| // optional string options_json = 15; |
| if (has_options_json()) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->options_json().data(), this->options_json().length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| ::google::protobuf::internal::WireFormatLite::WriteString( |
| 15, this->options_json(), output); |
| } |
| |
| // optional .exec.bit.control.QueryContextInformation context = 16; |
| if (has_context()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 16, this->context(), output); |
| } |
| |
| // repeated .exec.bit.control.Collector collector = 17; |
| for (int i = 0; i < this->collector_size(); i++) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 17, this->collector(i), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* PlanFragment::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional .exec.bit.FragmentHandle handle = 1; |
| if (has_handle()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->handle(), target); |
| } |
| |
| // optional float network_cost = 4; |
| if (has_network_cost()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->network_cost(), target); |
| } |
| |
| // optional float cpu_cost = 5; |
| if (has_cpu_cost()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->cpu_cost(), target); |
| } |
| |
| // optional float disk_cost = 6; |
| if (has_disk_cost()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->disk_cost(), target); |
| } |
| |
| // optional float memory_cost = 7; |
| if (has_memory_cost()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->memory_cost(), target); |
| } |
| |
| // optional string fragment_json = 8; |
| if (has_fragment_json()) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->fragment_json().data(), this->fragment_json().length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| target = |
| ::google::protobuf::internal::WireFormatLite::WriteStringToArray( |
| 8, this->fragment_json(), target); |
| } |
| |
| // optional bool leaf_fragment = 9; |
| if (has_leaf_fragment()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->leaf_fragment(), target); |
| } |
| |
| // optional .exec.DrillbitEndpoint assignment = 10; |
| if (has_assignment()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 10, this->assignment(), target); |
| } |
| |
| // optional .exec.DrillbitEndpoint foreman = 11; |
| if (has_foreman()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 11, this->foreman(), target); |
| } |
| |
| // optional int64 mem_initial = 12 [default = 20000000]; |
| if (has_mem_initial()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(12, this->mem_initial(), target); |
| } |
| |
| // optional int64 mem_max = 13 [default = 2000000000]; |
| if (has_mem_max()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(13, this->mem_max(), target); |
| } |
| |
| // optional .exec.shared.UserCredentials credentials = 14; |
| if (has_credentials()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 14, this->credentials(), target); |
| } |
| |
| // optional string options_json = 15; |
| if (has_options_json()) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->options_json().data(), this->options_json().length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| target = |
| ::google::protobuf::internal::WireFormatLite::WriteStringToArray( |
| 15, this->options_json(), target); |
| } |
| |
| // optional .exec.bit.control.QueryContextInformation context = 16; |
| if (has_context()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 16, this->context(), target); |
| } |
| |
| // repeated .exec.bit.control.Collector collector = 17; |
| for (int i = 0; i < this->collector_size(); i++) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 17, this->collector(i), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int PlanFragment::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional .exec.bit.FragmentHandle handle = 1; |
| if (has_handle()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->handle()); |
| } |
| |
| // optional float network_cost = 4; |
| if (has_network_cost()) { |
| total_size += 1 + 4; |
| } |
| |
| // optional float cpu_cost = 5; |
| if (has_cpu_cost()) { |
| total_size += 1 + 4; |
| } |
| |
| // optional float disk_cost = 6; |
| if (has_disk_cost()) { |
| total_size += 1 + 4; |
| } |
| |
| // optional float memory_cost = 7; |
| if (has_memory_cost()) { |
| total_size += 1 + 4; |
| } |
| |
| // optional string fragment_json = 8; |
| if (has_fragment_json()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::StringSize( |
| this->fragment_json()); |
| } |
| |
| // optional bool leaf_fragment = 9; |
| if (has_leaf_fragment()) { |
| total_size += 1 + 1; |
| } |
| |
| // optional .exec.DrillbitEndpoint assignment = 10; |
| if (has_assignment()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->assignment()); |
| } |
| |
| } |
| if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { |
| // optional .exec.DrillbitEndpoint foreman = 11; |
| if (has_foreman()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->foreman()); |
| } |
| |
| // optional int64 mem_initial = 12 [default = 20000000]; |
| if (has_mem_initial()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int64Size( |
| this->mem_initial()); |
| } |
| |
| // optional int64 mem_max = 13 [default = 2000000000]; |
| if (has_mem_max()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int64Size( |
| this->mem_max()); |
| } |
| |
| // optional .exec.shared.UserCredentials credentials = 14; |
| if (has_credentials()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->credentials()); |
| } |
| |
| // optional string options_json = 15; |
| if (has_options_json()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::StringSize( |
| this->options_json()); |
| } |
| |
| // optional .exec.bit.control.QueryContextInformation context = 16; |
| if (has_context()) { |
| total_size += 2 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->context()); |
| } |
| |
| } |
| // repeated .exec.bit.control.Collector collector = 17; |
| total_size += 2 * this->collector_size(); |
| for (int i = 0; i < this->collector_size(); i++) { |
| total_size += |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->collector(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 PlanFragment::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const PlanFragment* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const PlanFragment*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void PlanFragment::MergeFrom(const PlanFragment& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| collector_.MergeFrom(from.collector_); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_handle()) { |
| mutable_handle()->::exec::bit::FragmentHandle::MergeFrom(from.handle()); |
| } |
| if (from.has_network_cost()) { |
| set_network_cost(from.network_cost()); |
| } |
| if (from.has_cpu_cost()) { |
| set_cpu_cost(from.cpu_cost()); |
| } |
| if (from.has_disk_cost()) { |
| set_disk_cost(from.disk_cost()); |
| } |
| if (from.has_memory_cost()) { |
| set_memory_cost(from.memory_cost()); |
| } |
| if (from.has_fragment_json()) { |
| set_fragment_json(from.fragment_json()); |
| } |
| if (from.has_leaf_fragment()) { |
| set_leaf_fragment(from.leaf_fragment()); |
| } |
| if (from.has_assignment()) { |
| mutable_assignment()->::exec::DrillbitEndpoint::MergeFrom(from.assignment()); |
| } |
| } |
| if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { |
| if (from.has_foreman()) { |
| mutable_foreman()->::exec::DrillbitEndpoint::MergeFrom(from.foreman()); |
| } |
| if (from.has_mem_initial()) { |
| set_mem_initial(from.mem_initial()); |
| } |
| if (from.has_mem_max()) { |
| set_mem_max(from.mem_max()); |
| } |
| if (from.has_credentials()) { |
| mutable_credentials()->::exec::shared::UserCredentials::MergeFrom(from.credentials()); |
| } |
| if (from.has_options_json()) { |
| set_options_json(from.options_json()); |
| } |
| if (from.has_context()) { |
| mutable_context()->::exec::bit::control::QueryContextInformation::MergeFrom(from.context()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void PlanFragment::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void PlanFragment::CopyFrom(const PlanFragment& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool PlanFragment::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void PlanFragment::Swap(PlanFragment* other) { |
| if (other != this) { |
| std::swap(handle_, other->handle_); |
| std::swap(network_cost_, other->network_cost_); |
| std::swap(cpu_cost_, other->cpu_cost_); |
| std::swap(disk_cost_, other->disk_cost_); |
| std::swap(memory_cost_, other->memory_cost_); |
| std::swap(fragment_json_, other->fragment_json_); |
| std::swap(leaf_fragment_, other->leaf_fragment_); |
| std::swap(assignment_, other->assignment_); |
| std::swap(foreman_, other->foreman_); |
| std::swap(mem_initial_, other->mem_initial_); |
| std::swap(mem_max_, other->mem_max_); |
| std::swap(credentials_, other->credentials_); |
| std::swap(options_json_, other->options_json_); |
| std::swap(context_, other->context_); |
| collector_.Swap(&other->collector_); |
| 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 PlanFragment::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = PlanFragment_descriptor_; |
| metadata.reflection = PlanFragment_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int Collector::kOppositeMajorFragmentIdFieldNumber; |
| const int Collector::kIncomingMinorFragmentFieldNumber; |
| const int Collector::kSupportsOutOfOrderFieldNumber; |
| const int Collector::kIsSpoolingFieldNumber; |
| #endif // !_MSC_VER |
| |
| Collector::Collector() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void Collector::InitAsDefaultInstance() { |
| } |
| |
| Collector::Collector(const Collector& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void Collector::SharedCtor() { |
| _cached_size_ = 0; |
| opposite_major_fragment_id_ = 0; |
| supports_out_of_order_ = false; |
| is_spooling_ = false; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| Collector::~Collector() { |
| SharedDtor(); |
| } |
| |
| void Collector::SharedDtor() { |
| if (this != default_instance_) { |
| } |
| } |
| |
| void Collector::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* Collector::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return Collector_descriptor_; |
| } |
| |
| const Collector& Collector::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| Collector* Collector::default_instance_ = NULL; |
| |
| Collector* Collector::New() const { |
| return new Collector; |
| } |
| |
| void Collector::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| opposite_major_fragment_id_ = 0; |
| supports_out_of_order_ = false; |
| is_spooling_ = false; |
| } |
| incoming_minor_fragment_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool Collector::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 opposite_major_fragment_id = 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, &opposite_major_fragment_id_))); |
| set_has_opposite_major_fragment_id(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(18)) goto parse_incoming_minor_fragment; |
| break; |
| } |
| |
| // repeated int32 incoming_minor_fragment = 2 [packed = true]; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_incoming_minor_fragment: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, this->mutable_incoming_minor_fragment()))); |
| } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) |
| == ::google::protobuf::internal::WireFormatLite:: |
| WIRETYPE_VARINT) { |
| DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| 1, 18, input, this->mutable_incoming_minor_fragment()))); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(24)) goto parse_supports_out_of_order; |
| break; |
| } |
| |
| // optional bool supports_out_of_order = 3; |
| case 3: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_supports_out_of_order: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( |
| input, &supports_out_of_order_))); |
| set_has_supports_out_of_order(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(32)) goto parse_is_spooling; |
| break; |
| } |
| |
| // optional bool is_spooling = 4; |
| case 4: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_is_spooling: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( |
| input, &is_spooling_))); |
| set_has_is_spooling(); |
| } 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 Collector::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional int32 opposite_major_fragment_id = 1; |
| if (has_opposite_major_fragment_id()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->opposite_major_fragment_id(), output); |
| } |
| |
| // repeated int32 incoming_minor_fragment = 2 [packed = true]; |
| if (this->incoming_minor_fragment_size() > 0) { |
| ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); |
| output->WriteVarint32(_incoming_minor_fragment_cached_byte_size_); |
| } |
| for (int i = 0; i < this->incoming_minor_fragment_size(); i++) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag( |
| this->incoming_minor_fragment(i), output); |
| } |
| |
| // optional bool supports_out_of_order = 3; |
| if (has_supports_out_of_order()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->supports_out_of_order(), output); |
| } |
| |
| // optional bool is_spooling = 4; |
| if (has_is_spooling()) { |
| ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_spooling(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* Collector::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional int32 opposite_major_fragment_id = 1; |
| if (has_opposite_major_fragment_id()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->opposite_major_fragment_id(), target); |
| } |
| |
| // repeated int32 incoming_minor_fragment = 2 [packed = true]; |
| if (this->incoming_minor_fragment_size() > 0) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( |
| 2, |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, |
| target); |
| target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( |
| _incoming_minor_fragment_cached_byte_size_, target); |
| } |
| for (int i = 0; i < this->incoming_minor_fragment_size(); i++) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteInt32NoTagToArray(this->incoming_minor_fragment(i), target); |
| } |
| |
| // optional bool supports_out_of_order = 3; |
| if (has_supports_out_of_order()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->supports_out_of_order(), target); |
| } |
| |
| // optional bool is_spooling = 4; |
| if (has_is_spooling()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_spooling(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int Collector::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional int32 opposite_major_fragment_id = 1; |
| if (has_opposite_major_fragment_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->opposite_major_fragment_id()); |
| } |
| |
| // optional bool supports_out_of_order = 3; |
| if (has_supports_out_of_order()) { |
| total_size += 1 + 1; |
| } |
| |
| // optional bool is_spooling = 4; |
| if (has_is_spooling()) { |
| total_size += 1 + 1; |
| } |
| |
| } |
| // repeated int32 incoming_minor_fragment = 2 [packed = true]; |
| { |
| int data_size = 0; |
| for (int i = 0; i < this->incoming_minor_fragment_size(); i++) { |
| data_size += ::google::protobuf::internal::WireFormatLite:: |
| Int32Size(this->incoming_minor_fragment(i)); |
| } |
| if (data_size > 0) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); |
| } |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _incoming_minor_fragment_cached_byte_size_ = data_size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| total_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 Collector::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const Collector* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const Collector*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void Collector::MergeFrom(const Collector& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| incoming_minor_fragment_.MergeFrom(from.incoming_minor_fragment_); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_opposite_major_fragment_id()) { |
| set_opposite_major_fragment_id(from.opposite_major_fragment_id()); |
| } |
| if (from.has_supports_out_of_order()) { |
| set_supports_out_of_order(from.supports_out_of_order()); |
| } |
| if (from.has_is_spooling()) { |
| set_is_spooling(from.is_spooling()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void Collector::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void Collector::CopyFrom(const Collector& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool Collector::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void Collector::Swap(Collector* other) { |
| if (other != this) { |
| std::swap(opposite_major_fragment_id_, other->opposite_major_fragment_id_); |
| incoming_minor_fragment_.Swap(&other->incoming_minor_fragment_); |
| std::swap(supports_out_of_order_, other->supports_out_of_order_); |
| std::swap(is_spooling_, other->is_spooling_); |
| 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 Collector::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = Collector_descriptor_; |
| metadata.reflection = Collector_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int QueryContextInformation::kQueryStartTimeFieldNumber; |
| const int QueryContextInformation::kTimeZoneFieldNumber; |
| const int QueryContextInformation::kDefaultSchemaNameFieldNumber; |
| const int QueryContextInformation::kSessionIdFieldNumber; |
| #endif // !_MSC_VER |
| |
| QueryContextInformation::QueryContextInformation() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void QueryContextInformation::InitAsDefaultInstance() { |
| } |
| |
| QueryContextInformation::QueryContextInformation(const QueryContextInformation& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void QueryContextInformation::SharedCtor() { |
| _cached_size_ = 0; |
| query_start_time_ = GOOGLE_LONGLONG(0); |
| time_zone_ = 0; |
| default_schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); |
| session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| QueryContextInformation::~QueryContextInformation() { |
| SharedDtor(); |
| } |
| |
| void QueryContextInformation::SharedDtor() { |
| if (default_schema_name_ != &::google::protobuf::internal::kEmptyString) { |
| delete default_schema_name_; |
| } |
| if (session_id_ != &::google::protobuf::internal::kEmptyString) { |
| delete session_id_; |
| } |
| if (this != default_instance_) { |
| } |
| } |
| |
| void QueryContextInformation::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* QueryContextInformation::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return QueryContextInformation_descriptor_; |
| } |
| |
| const QueryContextInformation& QueryContextInformation::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| QueryContextInformation* QueryContextInformation::default_instance_ = NULL; |
| |
| QueryContextInformation* QueryContextInformation::New() const { |
| return new QueryContextInformation; |
| } |
| |
| void QueryContextInformation::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| query_start_time_ = GOOGLE_LONGLONG(0); |
| time_zone_ = 0; |
| if (has_default_schema_name()) { |
| if (default_schema_name_ != &::google::protobuf::internal::kEmptyString) { |
| default_schema_name_->clear(); |
| } |
| } |
| if (has_session_id()) { |
| if (session_id_ != &::google::protobuf::internal::kEmptyString) { |
| session_id_->clear(); |
| } |
| } |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool QueryContextInformation::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 int64 query_start_time = 1; |
| case 1: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( |
| input, &query_start_time_))); |
| set_has_query_start_time(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(16)) goto parse_time_zone; |
| break; |
| } |
| |
| // optional int32 time_zone = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_time_zone: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &time_zone_))); |
| set_has_time_zone(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(26)) goto parse_default_schema_name; |
| break; |
| } |
| |
| // optional string default_schema_name = 3; |
| case 3: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_default_schema_name: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadString( |
| input, this->mutable_default_schema_name())); |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->default_schema_name().data(), this->default_schema_name().length(), |
| ::google::protobuf::internal::WireFormat::PARSE); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(34)) goto parse_session_id; |
| break; |
| } |
| |
| // optional string session_id = 4; |
| case 4: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_session_id: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadString( |
| input, this->mutable_session_id())); |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->session_id().data(), this->session_id().length(), |
| ::google::protobuf::internal::WireFormat::PARSE); |
| } 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 QueryContextInformation::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional int64 query_start_time = 1; |
| if (has_query_start_time()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->query_start_time(), output); |
| } |
| |
| // optional int32 time_zone = 2; |
| if (has_time_zone()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->time_zone(), output); |
| } |
| |
| // optional string default_schema_name = 3; |
| if (has_default_schema_name()) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->default_schema_name().data(), this->default_schema_name().length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| ::google::protobuf::internal::WireFormatLite::WriteString( |
| 3, this->default_schema_name(), output); |
| } |
| |
| // optional string session_id = 4; |
| if (has_session_id()) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->session_id().data(), this->session_id().length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| ::google::protobuf::internal::WireFormatLite::WriteString( |
| 4, this->session_id(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* QueryContextInformation::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional int64 query_start_time = 1; |
| if (has_query_start_time()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->query_start_time(), target); |
| } |
| |
| // optional int32 time_zone = 2; |
| if (has_time_zone()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->time_zone(), target); |
| } |
| |
| // optional string default_schema_name = 3; |
| if (has_default_schema_name()) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->default_schema_name().data(), this->default_schema_name().length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| target = |
| ::google::protobuf::internal::WireFormatLite::WriteStringToArray( |
| 3, this->default_schema_name(), target); |
| } |
| |
| // optional string session_id = 4; |
| if (has_session_id()) { |
| ::google::protobuf::internal::WireFormat::VerifyUTF8String( |
| this->session_id().data(), this->session_id().length(), |
| ::google::protobuf::internal::WireFormat::SERIALIZE); |
| target = |
| ::google::protobuf::internal::WireFormatLite::WriteStringToArray( |
| 4, this->session_id(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int QueryContextInformation::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional int64 query_start_time = 1; |
| if (has_query_start_time()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int64Size( |
| this->query_start_time()); |
| } |
| |
| // optional int32 time_zone = 2; |
| if (has_time_zone()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->time_zone()); |
| } |
| |
| // optional string default_schema_name = 3; |
| if (has_default_schema_name()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::StringSize( |
| this->default_schema_name()); |
| } |
| |
| // optional string session_id = 4; |
| if (has_session_id()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::StringSize( |
| this->session_id()); |
| } |
| |
| } |
| 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 QueryContextInformation::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const QueryContextInformation* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const QueryContextInformation*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void QueryContextInformation::MergeFrom(const QueryContextInformation& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_query_start_time()) { |
| set_query_start_time(from.query_start_time()); |
| } |
| if (from.has_time_zone()) { |
| set_time_zone(from.time_zone()); |
| } |
| if (from.has_default_schema_name()) { |
| set_default_schema_name(from.default_schema_name()); |
| } |
| if (from.has_session_id()) { |
| set_session_id(from.session_id()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void QueryContextInformation::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void QueryContextInformation::CopyFrom(const QueryContextInformation& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool QueryContextInformation::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void QueryContextInformation::Swap(QueryContextInformation* other) { |
| if (other != this) { |
| std::swap(query_start_time_, other->query_start_time_); |
| std::swap(time_zone_, other->time_zone_); |
| std::swap(default_schema_name_, other->default_schema_name_); |
| std::swap(session_id_, other->session_id_); |
| 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 QueryContextInformation::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = QueryContextInformation_descriptor_; |
| metadata.reflection = QueryContextInformation_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int WorkQueueStatus::kEndpointFieldNumber; |
| const int WorkQueueStatus::kQueueLengthFieldNumber; |
| const int WorkQueueStatus::kReportTimeFieldNumber; |
| #endif // !_MSC_VER |
| |
| WorkQueueStatus::WorkQueueStatus() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void WorkQueueStatus::InitAsDefaultInstance() { |
| endpoint_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance()); |
| } |
| |
| WorkQueueStatus::WorkQueueStatus(const WorkQueueStatus& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void WorkQueueStatus::SharedCtor() { |
| _cached_size_ = 0; |
| endpoint_ = NULL; |
| queue_length_ = 0; |
| report_time_ = GOOGLE_LONGLONG(0); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| WorkQueueStatus::~WorkQueueStatus() { |
| SharedDtor(); |
| } |
| |
| void WorkQueueStatus::SharedDtor() { |
| if (this != default_instance_) { |
| delete endpoint_; |
| } |
| } |
| |
| void WorkQueueStatus::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* WorkQueueStatus::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return WorkQueueStatus_descriptor_; |
| } |
| |
| const WorkQueueStatus& WorkQueueStatus::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| WorkQueueStatus* WorkQueueStatus::default_instance_ = NULL; |
| |
| WorkQueueStatus* WorkQueueStatus::New() const { |
| return new WorkQueueStatus; |
| } |
| |
| void WorkQueueStatus::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (has_endpoint()) { |
| if (endpoint_ != NULL) endpoint_->::exec::DrillbitEndpoint::Clear(); |
| } |
| queue_length_ = 0; |
| report_time_ = GOOGLE_LONGLONG(0); |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool WorkQueueStatus::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.DrillbitEndpoint endpoint = 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_endpoint())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(16)) goto parse_queue_length; |
| break; |
| } |
| |
| // optional int32 queue_length = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_queue_length: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( |
| input, &queue_length_))); |
| set_has_queue_length(); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(24)) goto parse_report_time; |
| break; |
| } |
| |
| // optional int64 report_time = 3; |
| case 3: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { |
| parse_report_time: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( |
| input, &report_time_))); |
| set_has_report_time(); |
| } 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 WorkQueueStatus::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional .exec.DrillbitEndpoint endpoint = 1; |
| if (has_endpoint()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->endpoint(), output); |
| } |
| |
| // optional int32 queue_length = 2; |
| if (has_queue_length()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->queue_length(), output); |
| } |
| |
| // optional int64 report_time = 3; |
| if (has_report_time()) { |
| ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->report_time(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* WorkQueueStatus::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional .exec.DrillbitEndpoint endpoint = 1; |
| if (has_endpoint()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->endpoint(), target); |
| } |
| |
| // optional int32 queue_length = 2; |
| if (has_queue_length()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->queue_length(), target); |
| } |
| |
| // optional int64 report_time = 3; |
| if (has_report_time()) { |
| target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->report_time(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int WorkQueueStatus::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional .exec.DrillbitEndpoint endpoint = 1; |
| if (has_endpoint()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->endpoint()); |
| } |
| |
| // optional int32 queue_length = 2; |
| if (has_queue_length()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int32Size( |
| this->queue_length()); |
| } |
| |
| // optional int64 report_time = 3; |
| if (has_report_time()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::Int64Size( |
| this->report_time()); |
| } |
| |
| } |
| 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 WorkQueueStatus::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const WorkQueueStatus* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const WorkQueueStatus*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void WorkQueueStatus::MergeFrom(const WorkQueueStatus& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_endpoint()) { |
| mutable_endpoint()->::exec::DrillbitEndpoint::MergeFrom(from.endpoint()); |
| } |
| if (from.has_queue_length()) { |
| set_queue_length(from.queue_length()); |
| } |
| if (from.has_report_time()) { |
| set_report_time(from.report_time()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void WorkQueueStatus::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void WorkQueueStatus::CopyFrom(const WorkQueueStatus& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool WorkQueueStatus::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void WorkQueueStatus::Swap(WorkQueueStatus* other) { |
| if (other != this) { |
| std::swap(endpoint_, other->endpoint_); |
| std::swap(queue_length_, other->queue_length_); |
| std::swap(report_time_, other->report_time_); |
| 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 WorkQueueStatus::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = WorkQueueStatus_descriptor_; |
| metadata.reflection = WorkQueueStatus_reflection_; |
| return metadata; |
| } |
| |
| |
| // =================================================================== |
| |
| #ifndef _MSC_VER |
| const int FinishedReceiver::kReceiverFieldNumber; |
| const int FinishedReceiver::kSenderFieldNumber; |
| #endif // !_MSC_VER |
| |
| FinishedReceiver::FinishedReceiver() |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| } |
| |
| void FinishedReceiver::InitAsDefaultInstance() { |
| receiver_ = const_cast< ::exec::bit::FragmentHandle*>(&::exec::bit::FragmentHandle::default_instance()); |
| sender_ = const_cast< ::exec::bit::FragmentHandle*>(&::exec::bit::FragmentHandle::default_instance()); |
| } |
| |
| FinishedReceiver::FinishedReceiver(const FinishedReceiver& from) |
| : ::google::protobuf::Message() { |
| SharedCtor(); |
| MergeFrom(from); |
| } |
| |
| void FinishedReceiver::SharedCtor() { |
| _cached_size_ = 0; |
| receiver_ = NULL; |
| sender_ = NULL; |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| FinishedReceiver::~FinishedReceiver() { |
| SharedDtor(); |
| } |
| |
| void FinishedReceiver::SharedDtor() { |
| if (this != default_instance_) { |
| delete receiver_; |
| delete sender_; |
| } |
| } |
| |
| void FinishedReceiver::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ::google::protobuf::Descriptor* FinishedReceiver::descriptor() { |
| protobuf_AssignDescriptorsOnce(); |
| return FinishedReceiver_descriptor_; |
| } |
| |
| const FinishedReceiver& FinishedReceiver::default_instance() { |
| if (default_instance_ == NULL) protobuf_AddDesc_BitControl_2eproto(); |
| return *default_instance_; |
| } |
| |
| FinishedReceiver* FinishedReceiver::default_instance_ = NULL; |
| |
| FinishedReceiver* FinishedReceiver::New() const { |
| return new FinishedReceiver; |
| } |
| |
| void FinishedReceiver::Clear() { |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (has_receiver()) { |
| if (receiver_ != NULL) receiver_->::exec::bit::FragmentHandle::Clear(); |
| } |
| if (has_sender()) { |
| if (sender_ != NULL) sender_->::exec::bit::FragmentHandle::Clear(); |
| } |
| } |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| mutable_unknown_fields()->Clear(); |
| } |
| |
| bool FinishedReceiver::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.bit.FragmentHandle receiver = 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_receiver())); |
| } else { |
| goto handle_uninterpreted; |
| } |
| if (input->ExpectTag(18)) goto parse_sender; |
| break; |
| } |
| |
| // optional .exec.bit.FragmentHandle sender = 2; |
| case 2: { |
| if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == |
| ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { |
| parse_sender: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( |
| input, mutable_sender())); |
| } 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 FinishedReceiver::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // optional .exec.bit.FragmentHandle receiver = 1; |
| if (has_receiver()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 1, this->receiver(), output); |
| } |
| |
| // optional .exec.bit.FragmentHandle sender = 2; |
| if (has_sender()) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( |
| 2, this->sender(), output); |
| } |
| |
| if (!unknown_fields().empty()) { |
| ::google::protobuf::internal::WireFormat::SerializeUnknownFields( |
| unknown_fields(), output); |
| } |
| } |
| |
| ::google::protobuf::uint8* FinishedReceiver::SerializeWithCachedSizesToArray( |
| ::google::protobuf::uint8* target) const { |
| // optional .exec.bit.FragmentHandle receiver = 1; |
| if (has_receiver()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 1, this->receiver(), target); |
| } |
| |
| // optional .exec.bit.FragmentHandle sender = 2; |
| if (has_sender()) { |
| target = ::google::protobuf::internal::WireFormatLite:: |
| WriteMessageNoVirtualToArray( |
| 2, this->sender(), target); |
| } |
| |
| if (!unknown_fields().empty()) { |
| target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( |
| unknown_fields(), target); |
| } |
| return target; |
| } |
| |
| int FinishedReceiver::ByteSize() const { |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| // optional .exec.bit.FragmentHandle receiver = 1; |
| if (has_receiver()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->receiver()); |
| } |
| |
| // optional .exec.bit.FragmentHandle sender = 2; |
| if (has_sender()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->sender()); |
| } |
| |
| } |
| 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 FinishedReceiver::MergeFrom(const ::google::protobuf::Message& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| const FinishedReceiver* source = |
| ::google::protobuf::internal::dynamic_cast_if_available<const FinishedReceiver*>( |
| &from); |
| if (source == NULL) { |
| ::google::protobuf::internal::ReflectionOps::Merge(from, this); |
| } else { |
| MergeFrom(*source); |
| } |
| } |
| |
| void FinishedReceiver::MergeFrom(const FinishedReceiver& from) { |
| GOOGLE_CHECK_NE(&from, this); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_receiver()) { |
| mutable_receiver()->::exec::bit::FragmentHandle::MergeFrom(from.receiver()); |
| } |
| if (from.has_sender()) { |
| mutable_sender()->::exec::bit::FragmentHandle::MergeFrom(from.sender()); |
| } |
| } |
| mutable_unknown_fields()->MergeFrom(from.unknown_fields()); |
| } |
| |
| void FinishedReceiver::CopyFrom(const ::google::protobuf::Message& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| void FinishedReceiver::CopyFrom(const FinishedReceiver& from) { |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool FinishedReceiver::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void FinishedReceiver::Swap(FinishedReceiver* other) { |
| if (other != this) { |
| std::swap(receiver_, other->receiver_); |
| std::swap(sender_, other->sender_); |
| 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 FinishedReceiver::GetMetadata() const { |
| protobuf_AssignDescriptorsOnce(); |
| ::google::protobuf::Metadata metadata; |
| metadata.descriptor = FinishedReceiver_descriptor_; |
| metadata.reflection = FinishedReceiver_reflection_; |
| return metadata; |
| } |
| |
| |
| // @@protoc_insertion_point(namespace_scope) |
| |
| } // namespace control |
| } // namespace bit |
| } // namespace exec |
| |
| // @@protoc_insertion_point(global_scope) |