diff --git a/PrintS/Controller/Controller.cpp b/PrintS/Controller/Controller.cpp index 02f4343..94fc417 100644 --- a/PrintS/Controller/Controller.cpp +++ b/PrintS/Controller/Controller.cpp @@ -14,7 +14,8 @@ Controller::Controller() , m_SysParamWrapper(nullptr) , m_AxisRecordWrapper(nullptr) , m_SignalStateWrapper(nullptr) - , m_sendTdExitFlag(false){ + , m_sendTdExitFlag(false) + , m_reg(nullptr){ } @@ -38,6 +39,7 @@ Controller::~Controller() { DELP(m_ScannerCtrl); DELP(m_Purifier); + DELP(m_reg); BaseCtrl::SUninit(); } @@ -49,8 +51,6 @@ void Controller::Init(){ BaseCtrl::SInit(); m_jobController.SInit(); - - m_CoreCommunication = new CoreCommunication(); m_CoreCommunication->SetIOCfgWrapper(ConfigManager::GetInstance()->GetIoCfgWrapper()); m_CoreCommunication->SetSysParamWrapper(m_SysParamWrapper); @@ -119,6 +119,8 @@ void Controller::Init(){ } m_Purifier->Init(); + m_reg = new Registration(); + m_jobController.StartLoadPrepareJob(); } diff --git a/PrintS/Controller/Controller.h b/PrintS/Controller/Controller.h index f656190..ee3b7b4 100644 --- a/PrintS/Controller/Controller.h +++ b/PrintS/Controller/Controller.h @@ -8,6 +8,7 @@ #include "../remote/RemoteClient.h" #include "../Purifier/BasePurifier.h" #include +#include "../Registration/Registration.h" class Controller { public: @@ -39,7 +40,7 @@ public: MachineCfg* m_MachineCfg; - + Registration* m_reg; private: bool m_sendTdExitFlag; thread m_sendParamThread; diff --git a/PrintS/DataManage/DataHandle.cpp b/PrintS/DataManage/DataHandle.cpp index b3002aa..411731c 100644 --- a/PrintS/DataManage/DataHandle.cpp +++ b/PrintS/DataManage/DataHandle.cpp @@ -17,9 +17,9 @@ void DataHandle::LayersDataCallBackProc(void* pthis,const ReadData& msg, ::strea if (!p || index<1 || index>(int)size) return; p->m_controller->m_jobController.m_PrepareJob->GetMetaData()->GetLayerByIndex(index - 1, response); } - //else if ((READTYPE)msg.dataType == XYSCANSTATE) { - // - //} + else if ((READTYPE)msg.dataType == REGISTFUNC) { + p->m_controller->m_reg->CallFunc(msg,response); + } } @@ -99,33 +99,6 @@ void DataHandle::DataCallBackHandle(const ReadData& msg) { printf("没有准备好哦，无法操作\n"); return; } m_controller->m_Machine->CallAxisFunc(msg); break; - //case SCANERSTART: //开始扫描 - // scanners = m_controller->m_ScannerCtrl->GetScanners(); - // index = atoi(msg.strValue.c_str()); - // if (index >= (*scanners).size()) return; - // if ((*scanners)[index]) (*scanners)[index]->StartDebugTest(); - // break; - //case SCANERSTOP: //停止扫描 - // scanners = m_controller->m_ScannerCtrl->GetScanners(); - // index = atoi(msg.strValue.c_str()); - // if (index >= (*scanners).size()) return; - // if ((*scanners)[index]) (*scanners)[index]->StopDebugTest(); - // break; - //case STARTHEATINGSCANNERTEST: //开始振镜预热测试 - // scanners = m_controller->m_ScannerCtrl->GetScanners(); - // index = atoi(msg.strValue.c_str()); - // if (index >= (*scanners).size()) return; - // if((*scanners)[index]) (*scanners)[index]->StartHeatingScannerTest(); - // break; - //case STOPHEATINGSCANNERTEST: //停止振镜预热 - // scanners = m_controller->m_ScannerCtrl->GetScanners(); - // index = atoi(msg.strValue.c_str()); - // if (index >= (*scanners).size()) return; - // if ((*scanners)[index]) (*scanners)[index]->StopHeatingScannerTest(); - // break; - //case INITERRORINFOSREQ: //初始化错误信息 - // msg.clientPtr->PushMsg(new WriteData(INITERRORINFOSRSP, { {string(""), m_controller->m_ScannerCtrl->GetInitErrorInfos(), iSTRING} })); - // break; case VERSIONREQ: //获取版本信息 msg.clientPtr->PushMsg(new WriteData(VERSIONRSP, { { string(""), g_SystemInfo->m_ProductVersion, iSTRING } })); break; diff --git a/PrintS/DataManage/RWData.h b/PrintS/DataManage/RWData.h index 4e6fadf..4ad93e5 100644 --- a/PrintS/DataManage/RWData.h +++ b/PrintS/DataManage/RWData.h @@ -14,6 +14,7 @@ enum READTYPE { RESETELEC, //PowerMeterClient PURIFIERPARAMW, //净化器参数写入 LAYERDATAREQ, //layer数据请求 + REGISTFUNC, //注册函数集 SETZEROPOS, //AxisState使用 AXISSTOPALL, //axis 运动急停 diff --git a/PrintS/DataManage/StreamServer.cpp b/PrintS/DataManage/StreamServer.cpp index 7a4bdda..11a28c4 100644 --- a/PrintS/DataManage/StreamServer.cpp +++ b/PrintS/DataManage/StreamServer.cpp @@ -25,14 +25,6 @@ StreamServer::~StreamServer() { readData.nameKey = request->namekey(); readData.strValue = request->strvalue(); readData.valueType = (DATATYPE)request->valuetype(); - //if ((READTYPE)(request->datatype()) == LAYERDATAREQ) { - // if (m_layerDataCallBack) - // m_layerDataCallBack(m_handlePtr, readData, &response); - //} - //else if((READTYPE)(request->datatype()) == XYSCANSTATE){ - // if (m_layerDataCallBack) - // m_layerDataCallBack(m_handlePtr, readData, &response); - //} if (m_layerDataCallBack) m_layerDataCallBack(m_handlePtr, readData, &response); return Status::OK; diff --git a/PrintS/Registration/Registration.cpp b/PrintS/Registration/Registration.cpp index 28e17f0..344a3e8 100644 --- a/PrintS/Registration/Registration.cpp +++ b/PrintS/Registration/Registration.cpp @@ -1,4 +1,4 @@ -#include "Registration.h" +#include "Registration.h" #include #include "../config/ConfigManager.h" #include "../utils/TimeHelper.h" @@ -169,3 +169,27 @@ Registration::RegType Registration::CheckRegKey(std::string reg_file) else return REG_FAIL; } + + +void Registration::CallFunc(const ReadData& rd, ::stream::ResponseAny** response) { + char code[120]{ 0 }; + stream::RegResponce result; + REGFUNC regF = (REGFUNC)stoi(rd.nameKey); + switch (regF) { + case CHECKREG: + result.set_data(CheckReg(stoll(rd.strValue))); + (*response)->mutable_data()->PackFrom(result); + break; + case GETSN: + sprintf_s(code, 120, "%s", rd.strValue.c_str()); + result.set_data((int)GetSN(code)); + (*response)->mutable_data()->PackFrom(result); + break; + case CHECKREGKEY: + result.set_data(CheckRegKey(rd.strValue)); + (*response)->mutable_data()->PackFrom(result); + break; + default:break; + } + +} \ No newline at end of file diff --git a/PrintS/Registration/Registration.h b/PrintS/Registration/Registration.h index 3fa9512..1b7048f 100644 --- a/PrintS/Registration/Registration.h +++ b/PrintS/Registration/Registration.h @@ -1,9 +1,18 @@ -#pragma once +#pragma once #include "key.h" #include #include #include #include +#include "../DataManage/RWData.h" +#include "../protobuf/stream.pb.h" + +enum REGFUNC { + CHECKREG = 0, + GETSN, + CHECKREGKEY, + +}; class Registration { @@ -22,6 +31,7 @@ public: GLuint GetSN(char* strcode); RegType CheckRegKey(std::string reg_file); + void CallFunc(const ReadData& rd, ::stream::ResponseAny** response); private: unsigned int m_TrailYear; unsigned int m_TrailMonth; diff --git a/PrintS/ScannerCtrl/BaseCtrl.cpp b/PrintS/ScannerCtrl/BaseCtrl.cpp index 5a18019..312bc05 100644 --- a/PrintS/ScannerCtrl/BaseCtrl.cpp +++ b/PrintS/ScannerCtrl/BaseCtrl.cpp @@ -203,9 +203,9 @@ void BaseCtrl::SendToClients() { its.emplace_back(Item{"IsPrePrint",to_string(IsPrePrint()), iBOOL}); its.emplace_back(Item{"IsPauseStanBy",to_string(IsPauseStanBy()), iBOOL}); its.emplace_back(Item{"IsHeatingScanner",to_string(IsHeatingScanner()), iBOOL}); - its.emplace_back(Item{"State",to_string(GetState()), iBOOL}); - its.emplace_back(Item{"PreState",to_string(GetPreState()), iBOOL}); - its.emplace_back(Item{"PauseState",to_string(GetPauseState()), iBOOL}); + its.emplace_back(Item{"State",to_string(GetState()), iINT }); + its.emplace_back(Item{"PreState",to_string(GetPreState()), iINT }); + its.emplace_back(Item{"PauseState",to_string(GetPauseState()), iINT}); ClientWrapper::Instance()->PushAllClient(WriteData(SCANCTRLSTATE, its)); diff --git a/PrintS/ScannerCtrl/Scanner.h b/PrintS/ScannerCtrl/Scanner.h index bfb6695..304b7fa 100644 --- a/PrintS/ScannerCtrl/Scanner.h +++ b/PrintS/ScannerCtrl/Scanner.h @@ -98,7 +98,7 @@ public: void StartGetScanInfo(); void StopGetScanInfo(); void SetAutoUpdateScanInfo(bool isauto); - void GetXYScanState(ScanStateXYSCT* scanstate, time_t &t); //咋办 + void GetXYScanState(ScanStateXYSCT* scanstate, time_t &t); virtual void UpdateScannerInfo() {} //bool IsUpScanner(); diff --git a/PrintS/ScannerCtrl/ScannerCtrl.cpp b/PrintS/ScannerCtrl/ScannerCtrl.cpp index bac47a3..293440b 100644 --- a/PrintS/ScannerCtrl/ScannerCtrl.cpp +++ b/PrintS/ScannerCtrl/ScannerCtrl.cpp @@ -780,7 +780,7 @@ void ScannerCtrl::DispatchDataBlock() size_t layerindex = job->GetStartIndex(); - //m_Camera->SetDemandCatpure(true); //wxxtest + m_Camera->SetDemandCatpure(true); //wxxtest bool nodebug = !g_isDebug; //job->UpdateJobBeanWhenStart(); @@ -1814,12 +1814,10 @@ void ScannerCtrl::CallFunc(const ReadData& rd) { } void ScannerCtrl::SendToClients() { - std::shared_lock lck(m_mtx); - list lst; - lst.emplace_back(Item{ "IsTestLayerEnable", to_string(IsTestLayerEnable()), iBOOL}); - lst.emplace_back(Item{ "IsHeatingScannerEnable", to_string(IsHeatingScannerEnable()), iBOOL}); - lst.emplace_back(Item{ "InitErrorInfos", GetInitErrorInfos(), iSTRING}); + lst.emplace_back(Item{ "IsTestLayerEnable", to_string(IsTestLayerEnable()), iBOOL }); + lst.emplace_back(Item{ "IsHeatingScannerEnable", to_string(IsHeatingScannerEnable()), iBOOL }); + lst.emplace_back(Item{ "InitErrorInfos", GetInitErrorInfos(), iSTRING }); int count = m_scan.size(); lst.emplace_back(Item{ "ScanCount", to_string(count), iINT}); for (int i = 0; i < count; ++i) { @@ -1833,6 +1831,5 @@ void ScannerCtrl::SendToClients() { ++iter; } - ClientWrapper::Instance()->PushAllClient(WriteData(SCANCTRLPARAM,lst)); } \ No newline at end of file diff --git a/PrintS/ScannerCtrl/ScannerCtrl.h b/PrintS/ScannerCtrl/ScannerCtrl.h index aa72e59..0e1faa5 100644 --- a/PrintS/ScannerCtrl/ScannerCtrl.h +++ b/PrintS/ScannerCtrl/ScannerCtrl.h @@ -74,6 +74,7 @@ public: void SetServoManager(ServoManager* servoManager) { m_ServoManager = servoManager; } void StartHeatingMotion(); + void StopHeatingMotion(bool iswait); void SetRemoteClient(RemoteClient* rc) { m_RemoteClient = rc; } diff --git a/PrintS/output/Release/log/2024.hbd b/PrintS/output/Release/log/2024.hbd index e84a687..aa525ef 100644 Binary files a/PrintS/output/Release/log/2024.hbd and b/PrintS/output/Release/log/2024.hbd differ diff --git a/PrintS/protobuf/stream.pb.cc b/PrintS/protobuf/stream.pb.cc index 80d4d87..4c765c5 100644 --- a/PrintS/protobuf/stream.pb.cc +++ b/PrintS/protobuf/stream.pb.cc @@ -199,8 +199,24 @@ struct PointDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PointDefaultTypeInternal _Point_default_instance_; + template +PROTOBUF_CONSTEXPR RegResponce::RegResponce(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.data_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct RegResponceDefaultTypeInternal { + PROTOBUF_CONSTEXPR RegResponceDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RegResponceDefaultTypeInternal() {} + union { + RegResponce _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegResponceDefaultTypeInternal _RegResponce_default_instance_; } // namespace stream -static ::_pb::Metadata file_level_metadata_stream_2eproto[9]; +static ::_pb::Metadata file_level_metadata_stream_2eproto[10]; static const ::_pb::EnumDescriptor* file_level_enum_descriptors_stream_2eproto[1]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_stream_2eproto = nullptr; @@ -309,6 +325,15 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::stream::Point, _impl_.xpos_), PROTOBUF_FIELD_OFFSET(::stream::Point, _impl_.ypos_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::RegResponce, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::stream::RegResponce, _impl_.data_), }; static const ::_pbi::MigrationSchema @@ -322,6 +347,7 @@ static const ::_pbi::MigrationSchema {71, -1, -1, sizeof(::stream::VectorDataBlock)}, {83, -1, -1, sizeof(::stream::ChainDataBlock)}, {93, -1, -1, sizeof(::stream::Point)}, + {103, -1, -1, sizeof(::stream::RegResponce)}, }; static const ::_pb::Message* const file_default_instances[] = { @@ -334,6 +360,7 @@ static const ::_pb::Message* const file_default_instances[] = { &::stream::_VectorDataBlock_default_instance_._instance, &::stream::_ChainDataBlock_default_instance_._instance, &::stream::_Point_default_instance_._instance, + &::stream::_RegResponce_default_instance_._instance, }; const char descriptor_table_protodef_stream_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { "\n\014stream.proto\022\006stream\032\031google/protobuf/" @@ -357,17 +384,18 @@ const char descriptor_table_protodef_stream_2eproto[] PROTOBUF_SECTION_VARIABLE( " \001(\002\022\016\n\006startY\030\002 \001(\002\022\014\n\004endX\030\003 \001(\002\022\014\n\004en" "dY\030\004 \001(\002\"A\n\016ChainDataBlock\022\016\n\006dotNum\030\001 \001" "(\r\022\037\n\010pointVec\030\002 \003(\0132\r.stream.Point\"#\n\005P" - "oint\022\014\n\004xPos\030\001 \001(\002\022\014\n\004yPos\030\002 \001(\002*X\n\004TYPE" - "\022\t\n\005iBOOL\020\000\022\n\n\006iSHORT\020\001\022\013\n\007iUSHORT\020\002\022\010\n\004" - "iINT\020\003\022\t\n\005iUINT\020\004\022\n\n\006iFLOAT\020\005\022\013\n\007iSTRING" - "\020\0062\372\001\n\006Stream\0224\n\006Simple\022\023.stream.Request" - "Info\032\023.stream.ResponseAny\"\000\022=\n\014ServerStr" - "eam\022\023.stream.RequestInfo\032\024.stream.Respon" - "seInfo\"\0000\001\022=\n\014ClientStream\022\023.stream.Requ" - "estInfo\032\024.stream.ResponseInfo\"\000(\001\022<\n\tAll" - "Stream\022\023.stream.RequestInfo\032\024.stream.Res" - "ponseInfo\"\000(\0010\001B-\n\027io.grpc.examples.stre" - "amB\013StreamProtoP\001\242\002\002STb\006proto3" + "oint\022\014\n\004xPos\030\001 \001(\002\022\014\n\004yPos\030\002 \001(\002\"\033\n\013RegR" + "esponce\022\014\n\004data\030\001 \001(\005*X\n\004TYPE\022\t\n\005iBOOL\020\000" + "\022\n\n\006iSHORT\020\001\022\013\n\007iUSHORT\020\002\022\010\n\004iINT\020\003\022\t\n\005i" + "UINT\020\004\022\n\n\006iFLOAT\020\005\022\013\n\007iSTRING\020\0062\372\001\n\006Stre" + "am\0224\n\006Simple\022\023.stream.RequestInfo\032\023.stre" + "am.ResponseAny\"\000\022=\n\014ServerStream\022\023.strea" + "m.RequestInfo\032\024.stream.ResponseInfo\"\0000\001\022" + "=\n\014ClientStream\022\023.stream.RequestInfo\032\024.s" + "tream.ResponseInfo\"\000(\001\022<\n\tAllStream\022\023.st" + "ream.RequestInfo\032\024.stream.ResponseInfo\"\000" + "(\0010\001B-\n\027io.grpc.examples.streamB\013StreamP" + "rotoP\001\242\002\002STb\006proto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_stream_2eproto_deps[1] = { @@ -377,13 +405,13 @@ static ::absl::once_flag descriptor_table_stream_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_stream_2eproto = { false, false, - 1270, + 1299, descriptor_table_protodef_stream_2eproto, "stream.proto", &descriptor_table_stream_2eproto_once, descriptor_table_stream_2eproto_deps, 1, - 9, + 10, schemas, file_default_instances, TableStruct_stream_2eproto::offsets, @@ -2752,6 +2780,172 @@ void Point::InternalSwap(Point* other) { &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, file_level_metadata_stream_2eproto[8]); } +// =================================================================== + +class RegResponce::_Internal { + public: +}; + +RegResponce::RegResponce(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.RegResponce) +} +RegResponce::RegResponce(const RegResponce& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.RegResponce) +} +inline void RegResponce::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.data_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +RegResponce::~RegResponce() { + // @@protoc_insertion_point(destructor:stream.RegResponce) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void RegResponce::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void RegResponce::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void RegResponce::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.RegResponce) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.data_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* RegResponce::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RegResponce::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_RegResponce_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // int32 data = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RegResponce, _impl_.data_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RegResponce, _impl_.data_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 data = 1; + {PROTOBUF_FIELD_OFFSET(RegResponce, _impl_.data_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* RegResponce::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.RegResponce) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 data = 1; + if (this->_internal_data() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_data(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:stream.RegResponce) + return target; +} + +::size_t RegResponce::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.RegResponce) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 data = 1; + if (this->_internal_data() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_data()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData RegResponce::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + RegResponce::MergeImpl +}; +const ::google::protobuf::Message::ClassData*RegResponce::GetClassData() const { return &_class_data_; } + + +void RegResponce::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:stream.RegResponce) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_data() != 0) { + _this->_internal_set_data(from._internal_data()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RegResponce::CopyFrom(const RegResponce& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.RegResponce) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool RegResponce::IsInitialized() const { + return true; +} + +void RegResponce::InternalSwap(RegResponce* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.data_, other->_impl_.data_); +} + +::google::protobuf::Metadata RegResponce::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[9]); +} // @@protoc_insertion_point(namespace_scope) } // namespace stream namespace google { diff --git a/PrintS/protobuf/stream.pb.h b/PrintS/protobuf/stream.pb.h index f2960a0..baf6347 100644 --- a/PrintS/protobuf/stream.pb.h +++ b/PrintS/protobuf/stream.pb.h @@ -71,6 +71,9 @@ extern ParamInfoDefaultTypeInternal _ParamInfo_default_instance_; class Point; struct PointDefaultTypeInternal; extern PointDefaultTypeInternal _Point_default_instance_; +class RegResponce; +struct RegResponceDefaultTypeInternal; +extern RegResponceDefaultTypeInternal _RegResponce_default_instance_; class RequestInfo; struct RequestInfoDefaultTypeInternal; extern RequestInfoDefaultTypeInternal _RequestInfo_default_instance_; @@ -1875,6 +1878,164 @@ class Point final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class RegResponce final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.RegResponce) */ { + public: + inline RegResponce() : RegResponce(nullptr) {} + ~RegResponce() override; + template + explicit PROTOBUF_CONSTEXPR RegResponce(::google::protobuf::internal::ConstantInitialized); + + RegResponce(const RegResponce& from); + RegResponce(RegResponce&& from) noexcept + : RegResponce() { + *this = ::std::move(from); + } + + inline RegResponce& operator=(const RegResponce& from) { + CopyFrom(from); + return *this; + } + inline RegResponce& operator=(RegResponce&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RegResponce& default_instance() { + return *internal_default_instance(); + } + static inline const RegResponce* internal_default_instance() { + return reinterpret_cast( + &_RegResponce_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(RegResponce& a, RegResponce& b) { + a.Swap(&b); + } + inline void Swap(RegResponce* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RegResponce* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RegResponce* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RegResponce& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const RegResponce& from) { + RegResponce::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RegResponce* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.RegResponce"; + } + protected: + explicit RegResponce(::google::protobuf::Arena* arena); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDataFieldNumber = 1, + }; + // int32 data = 1; + void clear_data() ; + ::int32_t data() const; + void set_data(::int32_t value); + + private: + ::int32_t _internal_data() const; + void _internal_set_data(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:stream.RegResponce) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t data_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; }; // =================================================================== @@ -2891,6 +3052,32 @@ inline void Point::_internal_set_ypos(float value) { _impl_.ypos_ = value; } +// ------------------------------------------------------------------- + +// RegResponce + +// int32 data = 1; +inline void RegResponce::clear_data() { + _impl_.data_ = 0; +} +inline ::int32_t RegResponce::data() const { + // @@protoc_insertion_point(field_get:stream.RegResponce.data) + return _internal_data(); +} +inline void RegResponce::set_data(::int32_t value) { + _internal_set_data(value); + // @@protoc_insertion_point(field_set:stream.RegResponce.data) +} +inline ::int32_t RegResponce::_internal_data() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.data_; +} +inline void RegResponce::_internal_set_data(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.data_ = value; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ diff --git a/PrintS/protobuf/stream.proto b/PrintS/protobuf/stream.proto index c8d4d53..81941a8 100644 --- a/PrintS/protobuf/stream.proto +++ b/PrintS/protobuf/stream.proto @@ -98,6 +98,10 @@ message Point{ float yPos = 2; // Y 位置 : Float //单位 mm } +//注册功能返回信息 +message RegResponce{ + int32 data = 1; +} service Stream { diff --git a/TestClient/DataManage/DataHandle.cpp b/TestClient/DataManage/DataHandle.cpp index 5d49757..a995703 100644 --- a/TestClient/DataManage/DataHandle.cpp +++ b/TestClient/DataManage/DataHandle.cpp @@ -37,13 +37,15 @@ DataHandle::~DataHandle() { } + void DataHandle::Init() { m_streamClient = new StreamClient(); m_streamClient->SetCallBackFunc(this,&DataHandle::DataCallBackProc); m_streamClient->Init(); - stream::ResponseInfo* response = new stream::ResponseInfo(); //获取一层图层的数据 - m_streamClient->GetLayerByIndex(1, response); + //stream::ResponseInfo* response = new stream::ResponseInfo(); //获取一层图层的数据 + //m_streamClient->GetLayerByIndex(1, response); + } @@ -103,9 +105,10 @@ void DataHandle::Usage() { printf(COLOR_GREEN "print TestClient usage:\n" COLOR_RESET); printf(" 0: " COLOR_YELLOW "print help information...\n" COLOR_RESET); printf(" 1: " COLOR_YELLOW "exit program...\n" COLOR_RESET); - printf(" 2: " COLOR_YELLOW "start test all...\n" COLOR_RESET); - printf(" 3: " COLOR_YELLOW "start test axis move interface...\n" COLOR_RESET); - printf(" 4: " COLOR_YELLOW "start test scan control interface...\n" COLOR_RESET); + printf(" 2: " COLOR_YELLOW "test all...\n" COLOR_RESET); + printf(" 3: " COLOR_YELLOW "test axis move interface...\n" COLOR_RESET); + printf(" 4: " COLOR_YELLOW "test scan control interface...\n" COLOR_RESET); + printf(" 5: " COLOR_YELLOW "test registration interface...\n" COLOR_RESET); printf(" 100: " COLOR_YELLOW "start test recv param interface...\n" COLOR_RESET); } @@ -150,19 +153,56 @@ void DataHandle::ParamReadUsage() { printf(" 34: " COLOR_YELLOW "print scan ctrl state data...\n" COLOR_RESET); printf(" 35: " COLOR_YELLOW "print scan ctrl Param data...\n" COLOR_RESET); printf(" 36: " COLOR_YELLOW "print xy scan state data...\n" COLOR_RESET); - - } +int DataHandle::Request(int index) { + int result = 0; + + string userInput; + switch (index) { + case 0: + Usage(); break; + case 1: + Stop(); break; + case 2: + AllTest(); break; + case 3: + AxisMoveTest(); break; + case 4: + ScanCtrlTest(); break; + case 5: + RegistrationTest(); break; + case 100: + ParamReadUsage(); + while (printf("*请输入命令：") && std::getline(std::cin, userInput)) { + if (userInput == "q") { + printf("返回上一级...\n"); break; + } + else if (userInput.empty()) { + continue; + } + else if (userInput == "h") { + ParamReadUsage(); continue; + } + ParamRequest(stoi(userInput)); + } + break; + default: + result = -1; + break; + } + + return result; +} void DataHandle::AllTest() { AxisMoveTest(); ScanCtrlTest(); - + RegistrationTest(); } -void DataHandle::Request(int index) { +void DataHandle::ParamRequest(int index) { if (index == 2) { SetPushMsg(VERSIONREQ); //获取版本信息 } @@ -221,4 +261,43 @@ void DataHandle::ScanCtrlTest() { Sleep(1000); } +} + + +void DataHandle::RegistrationTest(){ + + ::stream::ResponseAny resp; + WriteData wdata; + stream::RegResponce result; + + wdata.valueType = iSTRING; + wdata.strValue = to_string(time(nullptr)); + wdata.nameKey = to_string(CHECKREG); + wdata.dataType = REGISTFUNC; + m_streamClient->Request(wdata,&resp); + + if (resp.data().Is()) { + resp.data().UnpackTo(&result); + printf("CHECKREG resp:%d\n", result.data()); + } + Sleep(100); + + wdata.valueType = iSTRING; + wdata.strValue = "123456789"; + wdata.nameKey = to_string(GETSN); + m_streamClient->Request(wdata, &resp); + if (resp.data().Is()) { + resp.data().UnpackTo(&result); + printf("GETSN resp:%u\n", (unsigned int)result.data()); + } + Sleep(100); + + wdata.valueType = iSTRING; + wdata.strValue = "regconfig"; + wdata.nameKey = to_string(CHECKREGKEY); + m_streamClient->Request(wdata, &resp); + if (resp.data().Is()) { + resp.data().UnpackTo(&result); + printf("CHECKREGKEY resp:%d\n", result.data()); + } } \ No newline at end of file diff --git a/TestClient/DataManage/DataHandle.h b/TestClient/DataManage/DataHandle.h index 2ba77f3..3d68de5 100644 --- a/TestClient/DataManage/DataHandle.h +++ b/TestClient/DataManage/DataHandle.h @@ -23,10 +23,12 @@ public: string GetVersion()const {return m_version;} - void Request(int index); + void ParamRequest(int index); + int Request(int index); void AllTest(); void AxisMoveTest(); //轴运动测试 void ScanCtrlTest(); //扫描控制测试 + void RegistrationTest(); //注册功能测试 void Usage(); void ParamReadUsage(); diff --git a/TestClient/DataManage/FunC.h b/TestClient/DataManage/FunC.h index 6f27849..624e38e 100644 --- a/TestClient/DataManage/FunC.h +++ b/TestClient/DataManage/FunC.h @@ -48,4 +48,18 @@ enum SCANCTRLFUNC { STOPHEATINGMOTION, END1 //结束标记 -}; \ No newline at end of file +}; + + +enum REGFUNC { + CHECKREG = 0, + GETSN, + CHECKREGKEY, +}; + + +typedef enum { + REG_SUCCESS = 0, + REG_TRIAL, + REG_FAIL, +} RegType; \ No newline at end of file diff --git a/TestClient/DataManage/RWData.h b/TestClient/DataManage/RWData.h index 93a55f4..6c5f5e6 100644 --- a/TestClient/DataManage/RWData.h +++ b/TestClient/DataManage/RWData.h @@ -97,6 +97,7 @@ enum WRITETYPE { RESETELEC, //PowerMeterClient PURIFIERPARAMW, //净化器参数写入 LAYERDATAREQ, //layer数据请求 + REGISTFUNC, //注册函数集 SETZEROPOS, //AxisState使用 AXISSTOPALL, //axis 运动急停 diff --git a/TestClient/DataManage/StreamClient.cpp b/TestClient/DataManage/StreamClient.cpp index 3d052f6..59c952d 100644 --- a/TestClient/DataManage/StreamClient.cpp +++ b/TestClient/DataManage/StreamClient.cpp @@ -113,7 +113,7 @@ void StreamClient::AllStream() { } -bool StreamClient::GetLayerByIndex(int index, ::stream::ResponseInfo* response){ +bool StreamClient::GetLayerByIndex(int index, ::stream::ResponseAny* response){ // 初始化 gRPC std::string targetStr = m_localIp + ":" + std::to_string(m_port); std::unique_ptr _stub = Stream::NewStub(grpc::CreateChannel(targetStr, grpc::InsecureChannelCredentials())); @@ -125,4 +125,21 @@ bool StreamClient::GetLayerByIndex(int index, ::stream::ResponseInfo* response){ request.set_valuetype((stream::TYPE)iINT); Status status = _stub->Simple(&context, request, response); return status.ok(); +} + + +int StreamClient::Request(const WriteData& writeData , ::stream::ResponseAny* response) { + // 初始化 gRPC + std::string targetStr = m_localIp + ":" + std::to_string(m_port); + std::unique_ptr _stub = Stream::NewStub(grpc::CreateChannel(targetStr, grpc::InsecureChannelCredentials())); + + ClientContext context; + ::stream::RequestInfo request; + request.set_datatype(REGISTFUNC); + request.set_namekey(writeData.nameKey); + request.set_strvalue(writeData.strValue); + request.set_valuetype((stream::TYPE)iSTRING); + Status status = _stub->Simple(&context, request, response); + return status.ok(); + } \ No newline at end of file diff --git a/TestClient/DataManage/StreamClient.h b/TestClient/DataManage/StreamClient.h index e6ae169..fbafb7f 100644 --- a/TestClient/DataManage/StreamClient.h +++ b/TestClient/DataManage/StreamClient.h @@ -32,7 +32,9 @@ public: } void SetPushMsg(const WriteData& msg); - bool GetLayerByIndex(int index, ::stream::ResponseInfo* response); + bool GetLayerByIndex(int index, ::stream::ResponseAny* response); + int RegistRequest(const WriteData& writeData, ::stream::ResponseAny* response); + int Request(const WriteData& writeData, ::stream::ResponseAny* response); private: bool GetPushMsg(WriteData& msg); diff --git a/TestClient/PrintC.vcxproj.filters b/TestClient/PrintC.vcxproj.filters index 878c465..4c379ec 100644 --- a/TestClient/PrintC.vcxproj.filters +++ b/TestClient/PrintC.vcxproj.filters @@ -74,9 +74,6 @@ - - protobuf - protobuf @@ -260,6 +257,9 @@ config\bean + + protobuf + diff --git a/TestClient/main.cpp b/TestClient/main.cpp index a54f9c5..b2cc40c 100644 --- a/TestClient/main.cpp +++ b/TestClient/main.cpp @@ -73,39 +73,9 @@ int main(int argc, char** argv) { if (!unknowCmd)printf("*请输入命令："); std::getline(std::cin, userInput); // 读取用户输入 unknowCmd = false; - if (userInput == "0") { - dataHandle->Usage(); - } - else if (userInput == "1") { - printf("service is exiting...\n"); - dataHandle->Stop(); - break; - } - else if (userInput == "2") { - dataHandle->AllTest(); - } - else if (userInput == "3") { - dataHandle->AxisMoveTest(); - } - else if (userInput == "4") { - dataHandle->ScanCtrlTest(); - } - else if (userInput == "100") { - dataHandle->ParamReadUsage(); - while (printf("*请输入命令：") && std::getline(std::cin, userInput)) { - if (userInput == "q") { - printf("返回上一级...\n"); break; - } - else if (userInput.empty()) { - continue; - } - else if (userInput == "h") { - dataHandle->ParamReadUsage(); continue; - } - dataHandle->Request(stoi(userInput)); - } - } - else { + if (userInput.empty()) continue; + + if(dataHandle->Request(stoi(userInput)) < 0){ printf("未识别的命令,请重新输入命令："); unknowCmd = true; } diff --git a/TestClient/protobuf/stream.grpc.pb.cc b/TestClient/protobuf/stream.grpc.pb.cc index 5244e70..f32fadd 100644 --- a/TestClient/protobuf/stream.grpc.pb.cc +++ b/TestClient/protobuf/stream.grpc.pb.cc @@ -41,23 +41,23 @@ Stream::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, co , rpcmethod_AllStream_(Stream_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) {} -::grpc::Status Stream::Stub::Simple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::stream::ResponseInfo* response) { - return ::grpc::internal::BlockingUnaryCall< ::stream::RequestInfo, ::stream::ResponseInfo, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Simple_, context, request, response); +::grpc::Status Stream::Stub::Simple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::stream::ResponseAny* response) { + return ::grpc::internal::BlockingUnaryCall< ::stream::RequestInfo, ::stream::ResponseAny, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Simple_, context, request, response); } -void Stream::Stub::async::Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response, std::function f) { - ::grpc::internal::CallbackUnaryCall< ::stream::RequestInfo, ::stream::ResponseInfo, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Simple_, context, request, response, std::move(f)); +void Stream::Stub::async::Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::stream::RequestInfo, ::stream::ResponseAny, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Simple_, context, request, response, std::move(f)); } -void Stream::Stub::async::Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response, ::grpc::ClientUnaryReactor* reactor) { +void Stream::Stub::async::Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Simple_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::stream::ResponseInfo>* Stream::Stub::PrepareAsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::stream::ResponseInfo, ::stream::RequestInfo, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Simple_, context, request); +::grpc::ClientAsyncResponseReader< ::stream::ResponseAny>* Stream::Stub::PrepareAsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::stream::ResponseAny, ::stream::RequestInfo, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Simple_, context, request); } -::grpc::ClientAsyncResponseReader< ::stream::ResponseInfo>* Stream::Stub::AsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::stream::ResponseAny>* Stream::Stub::AsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSimpleRaw(context, request, cq); result->StartCall(); @@ -116,11 +116,11 @@ Stream::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( Stream_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< Stream::Service, ::stream::RequestInfo, ::stream::ResponseInfo, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + new ::grpc::internal::RpcMethodHandler< Stream::Service, ::stream::RequestInfo, ::stream::ResponseAny, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Stream::Service* service, ::grpc::ServerContext* ctx, const ::stream::RequestInfo* req, - ::stream::ResponseInfo* resp) { + ::stream::ResponseAny* resp) { return service->Simple(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( @@ -158,7 +158,7 @@ Stream::Service::Service() { Stream::Service::~Service() { } -::grpc::Status Stream::Service::Simple(::grpc::ServerContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response) { +::grpc::Status Stream::Service::Simple(::grpc::ServerContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response) { (void) context; (void) request; (void) response; diff --git a/TestClient/protobuf/stream.grpc.pb.h b/TestClient/protobuf/stream.grpc.pb.h index b0a7bdc..f4a53ec 100644 --- a/TestClient/protobuf/stream.grpc.pb.h +++ b/TestClient/protobuf/stream.grpc.pb.h @@ -37,12 +37,12 @@ class Stream final { class StubInterface { public: virtual ~StubInterface() {} - virtual ::grpc::Status Simple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::stream::ResponseInfo* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseInfo>> AsyncSimple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseInfo>>(AsyncSimpleRaw(context, request, cq)); + virtual ::grpc::Status Simple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::stream::ResponseAny* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseAny>> AsyncSimple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseAny>>(AsyncSimpleRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseInfo>> PrepareAsyncSimple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseInfo>>(PrepareAsyncSimpleRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseAny>> PrepareAsyncSimple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseAny>>(PrepareAsyncSimpleRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReaderInterface< ::stream::ResponseInfo>> ServerStream(::grpc::ClientContext* context, const ::stream::RequestInfo& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::stream::ResponseInfo>>(ServerStreamRaw(context, request)); @@ -74,8 +74,8 @@ class Stream final { class async_interface { public: virtual ~async_interface() {} - virtual void Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response, std::function) = 0; - virtual void Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response, std::function) = 0; + virtual void Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void ServerStream(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::grpc::ClientReadReactor< ::stream::ResponseInfo>* reactor) = 0; virtual void ClientStream(::grpc::ClientContext* context, ::stream::ResponseInfo* response, ::grpc::ClientWriteReactor< ::stream::RequestInfo>* reactor) = 0; virtual void AllStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::stream::RequestInfo,::stream::ResponseInfo>* reactor) = 0; @@ -84,8 +84,8 @@ class Stream final { virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: - virtual ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseInfo>* AsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseInfo>* PrepareAsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseAny>* AsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::stream::ResponseAny>* PrepareAsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::stream::ResponseInfo>* ServerStreamRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::stream::ResponseInfo>* AsyncServerStreamRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::stream::ResponseInfo>* PrepareAsyncServerStreamRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) = 0; @@ -99,12 +99,12 @@ class Stream final { class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); - ::grpc::Status Simple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::stream::ResponseInfo* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::stream::ResponseInfo>> AsyncSimple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::stream::ResponseInfo>>(AsyncSimpleRaw(context, request, cq)); + ::grpc::Status Simple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::stream::ResponseAny* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::stream::ResponseAny>> AsyncSimple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::stream::ResponseAny>>(AsyncSimpleRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::stream::ResponseInfo>> PrepareAsyncSimple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::stream::ResponseInfo>>(PrepareAsyncSimpleRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::stream::ResponseAny>> PrepareAsyncSimple(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::stream::ResponseAny>>(PrepareAsyncSimpleRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::stream::ResponseInfo>> ServerStream(::grpc::ClientContext* context, const ::stream::RequestInfo& request) { return std::unique_ptr< ::grpc::ClientReader< ::stream::ResponseInfo>>(ServerStreamRaw(context, request)); @@ -136,8 +136,8 @@ class Stream final { class async final : public StubInterface::async_interface { public: - void Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response, std::function) override; - void Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response, ::grpc::ClientUnaryReactor* reactor) override; + void Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response, std::function) override; + void Simple(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response, ::grpc::ClientUnaryReactor* reactor) override; void ServerStream(::grpc::ClientContext* context, const ::stream::RequestInfo* request, ::grpc::ClientReadReactor< ::stream::ResponseInfo>* reactor) override; void ClientStream(::grpc::ClientContext* context, ::stream::ResponseInfo* response, ::grpc::ClientWriteReactor< ::stream::RequestInfo>* reactor) override; void AllStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::stream::RequestInfo,::stream::ResponseInfo>* reactor) override; @@ -152,8 +152,8 @@ class Stream final { private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; - ::grpc::ClientAsyncResponseReader< ::stream::ResponseInfo>* AsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::stream::ResponseInfo>* PrepareAsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::stream::ResponseAny>* AsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::stream::ResponseAny>* PrepareAsyncSimpleRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::stream::ResponseInfo>* ServerStreamRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request) override; ::grpc::ClientAsyncReader< ::stream::ResponseInfo>* AsyncServerStreamRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::stream::ResponseInfo>* PrepareAsyncServerStreamRaw(::grpc::ClientContext* context, const ::stream::RequestInfo& request, ::grpc::CompletionQueue* cq) override; @@ -174,7 +174,7 @@ class Stream final { public: Service(); virtual ~Service(); - virtual ::grpc::Status Simple(::grpc::ServerContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response); + virtual ::grpc::Status Simple(::grpc::ServerContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response); virtual ::grpc::Status ServerStream(::grpc::ServerContext* context, const ::stream::RequestInfo* request, ::grpc::ServerWriter< ::stream::ResponseInfo>* writer); virtual ::grpc::Status ClientStream(::grpc::ServerContext* context, ::grpc::ServerReader< ::stream::RequestInfo>* reader, ::stream::ResponseInfo* response); virtual ::grpc::Status AllStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::stream::ResponseInfo, ::stream::RequestInfo>* stream); @@ -191,11 +191,11 @@ class Stream final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseInfo* /*response*/) override { + ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseAny* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestSimple(::grpc::ServerContext* context, ::stream::RequestInfo* request, ::grpc::ServerAsyncResponseWriter< ::stream::ResponseInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestSimple(::grpc::ServerContext* context, ::stream::RequestInfo* request, ::grpc::ServerAsyncResponseWriter< ::stream::ResponseAny>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -267,25 +267,25 @@ class Stream final { public: WithCallbackMethod_Simple() { ::grpc::Service::MarkMethodCallback(0, - new ::grpc::internal::CallbackUnaryHandler< ::stream::RequestInfo, ::stream::ResponseInfo>( + new ::grpc::internal::CallbackUnaryHandler< ::stream::RequestInfo, ::stream::ResponseAny>( [this]( - ::grpc::CallbackServerContext* context, const ::stream::RequestInfo* request, ::stream::ResponseInfo* response) { return this->Simple(context, request, response); }));} + ::grpc::CallbackServerContext* context, const ::stream::RequestInfo* request, ::stream::ResponseAny* response) { return this->Simple(context, request, response); }));} void SetMessageAllocatorFor_Simple( - ::grpc::MessageAllocator< ::stream::RequestInfo, ::stream::ResponseInfo>* allocator) { + ::grpc::MessageAllocator< ::stream::RequestInfo, ::stream::ResponseAny>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); - static_cast<::grpc::internal::CallbackUnaryHandler< ::stream::RequestInfo, ::stream::ResponseInfo>*>(handler) + static_cast<::grpc::internal::CallbackUnaryHandler< ::stream::RequestInfo, ::stream::ResponseAny>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Simple() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseInfo* /*response*/) override { + ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseAny* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Simple( - ::grpc::CallbackServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseInfo* /*response*/) { return nullptr; } + ::grpc::CallbackServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseAny* /*response*/) { return nullptr; } }; template class WithCallbackMethod_ServerStream : public BaseClass { @@ -368,7 +368,7 @@ class Stream final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseInfo* /*response*/) override { + ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseAny* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -436,7 +436,7 @@ class Stream final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseInfo* /*response*/) override { + ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseAny* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -519,7 +519,7 @@ class Stream final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseInfo* /*response*/) override { + ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseAny* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -601,10 +601,10 @@ class Stream final { WithStreamedUnaryMethod_Simple() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< - ::stream::RequestInfo, ::stream::ResponseInfo>( + ::stream::RequestInfo, ::stream::ResponseAny>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< - ::stream::RequestInfo, ::stream::ResponseInfo>* streamer) { + ::stream::RequestInfo, ::stream::ResponseAny>* streamer) { return this->StreamedSimple(context, streamer); })); @@ -613,12 +613,12 @@ class Stream final { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseInfo* /*response*/) override { + ::grpc::Status Simple(::grpc::ServerContext* /*context*/, const ::stream::RequestInfo* /*request*/, ::stream::ResponseAny* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedSimple(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::stream::RequestInfo,::stream::ResponseInfo>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedSimple(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::stream::RequestInfo,::stream::ResponseAny>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_Simple StreamedUnaryService; template diff --git a/TestClient/protobuf/stream.pb.cc b/TestClient/protobuf/stream.pb.cc index 772076e..4c765c5 100644 --- a/TestClient/protobuf/stream.pb.cc +++ b/TestClient/protobuf/stream.pb.cc @@ -88,8 +88,135 @@ struct ResponseInfoDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResponseInfoDefaultTypeInternal _ResponseInfo_default_instance_; + template +PROTOBUF_CONSTEXPR ResponseAny::ResponseAny(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_._has_bits_)*/ {}, + /*decltype(_impl_._cached_size_)*/ {}, + /*decltype(_impl_.data_)*/ nullptr, + } {} +struct ResponseAnyDefaultTypeInternal { + PROTOBUF_CONSTEXPR ResponseAnyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ResponseAnyDefaultTypeInternal() {} + union { + ResponseAny _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResponseAnyDefaultTypeInternal _ResponseAny_default_instance_; + template +PROTOBUF_CONSTEXPR LayerData::LayerData(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.layerdatablock_)*/ {}, + /*decltype(_impl_.zcooldinate_)*/ 0, + /*decltype(_impl_.powder_)*/ 0, + /*decltype(_impl_.layerthickness_)*/ 0, + /*decltype(_impl_.result_)*/ false, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct LayerDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR LayerDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LayerDataDefaultTypeInternal() {} + union { + LayerData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LayerDataDefaultTypeInternal _LayerData_default_instance_; + template +PROTOBUF_CONSTEXPR LayerDataBlock::LayerDataBlock(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.vecblocks_)*/ {}, + /*decltype(_impl_.chainblocks_)*/ {}, + /*decltype(_impl_.elementid_)*/ 0, + /*decltype(_impl_.elementparamid_)*/ 0, + /*decltype(_impl_.blocktype_)*/ 0u, + /*decltype(_impl_.order_)*/ 0u, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct LayerDataBlockDefaultTypeInternal { + PROTOBUF_CONSTEXPR LayerDataBlockDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LayerDataBlockDefaultTypeInternal() {} + union { + LayerDataBlock _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LayerDataBlockDefaultTypeInternal _LayerDataBlock_default_instance_; + template +PROTOBUF_CONSTEXPR VectorDataBlock::VectorDataBlock(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.startx_)*/ 0, + /*decltype(_impl_.starty_)*/ 0, + /*decltype(_impl_.endx_)*/ 0, + /*decltype(_impl_.endy_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct VectorDataBlockDefaultTypeInternal { + PROTOBUF_CONSTEXPR VectorDataBlockDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~VectorDataBlockDefaultTypeInternal() {} + union { + VectorDataBlock _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VectorDataBlockDefaultTypeInternal _VectorDataBlock_default_instance_; + template +PROTOBUF_CONSTEXPR ChainDataBlock::ChainDataBlock(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.pointvec_)*/ {}, + /*decltype(_impl_.dotnum_)*/ 0u, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct ChainDataBlockDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChainDataBlockDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ChainDataBlockDefaultTypeInternal() {} + union { + ChainDataBlock _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChainDataBlockDefaultTypeInternal _ChainDataBlock_default_instance_; + template +PROTOBUF_CONSTEXPR Point::Point(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.xpos_)*/ 0, + /*decltype(_impl_.ypos_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct PointDefaultTypeInternal { + PROTOBUF_CONSTEXPR PointDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PointDefaultTypeInternal() {} + union { + Point _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PointDefaultTypeInternal _Point_default_instance_; + template +PROTOBUF_CONSTEXPR RegResponce::RegResponce(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.data_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct RegResponceDefaultTypeInternal { + PROTOBUF_CONSTEXPR RegResponceDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RegResponceDefaultTypeInternal() {} + union { + RegResponce _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegResponceDefaultTypeInternal _RegResponce_default_instance_; } // namespace stream -static ::_pb::Metadata file_level_metadata_stream_2eproto[3]; +static ::_pb::Metadata file_level_metadata_stream_2eproto[10]; static const ::_pb::EnumDescriptor* file_level_enum_descriptors_stream_2eproto[1]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_stream_2eproto = nullptr; @@ -129,6 +256,84 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE PROTOBUF_FIELD_OFFSET(::stream::ResponseInfo, _impl_.datatype_), PROTOBUF_FIELD_OFFSET(::stream::ResponseInfo, _impl_.result_), PROTOBUF_FIELD_OFFSET(::stream::ResponseInfo, _impl_.item_), + PROTOBUF_FIELD_OFFSET(::stream::ResponseAny, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::stream::ResponseAny, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::stream::ResponseAny, _impl_.data_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::LayerData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::stream::LayerData, _impl_.zcooldinate_), + PROTOBUF_FIELD_OFFSET(::stream::LayerData, _impl_.powder_), + PROTOBUF_FIELD_OFFSET(::stream::LayerData, _impl_.layerthickness_), + PROTOBUF_FIELD_OFFSET(::stream::LayerData, _impl_.layerdatablock_), + PROTOBUF_FIELD_OFFSET(::stream::LayerData, _impl_.result_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::LayerDataBlock, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::stream::LayerDataBlock, _impl_.elementid_), + PROTOBUF_FIELD_OFFSET(::stream::LayerDataBlock, _impl_.elementparamid_), + PROTOBUF_FIELD_OFFSET(::stream::LayerDataBlock, _impl_.blocktype_), + PROTOBUF_FIELD_OFFSET(::stream::LayerDataBlock, _impl_.vecblocks_), + PROTOBUF_FIELD_OFFSET(::stream::LayerDataBlock, _impl_.chainblocks_), + PROTOBUF_FIELD_OFFSET(::stream::LayerDataBlock, _impl_.order_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::VectorDataBlock, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::stream::VectorDataBlock, _impl_.startx_), + PROTOBUF_FIELD_OFFSET(::stream::VectorDataBlock, _impl_.starty_), + PROTOBUF_FIELD_OFFSET(::stream::VectorDataBlock, _impl_.endx_), + PROTOBUF_FIELD_OFFSET(::stream::VectorDataBlock, _impl_.endy_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::ChainDataBlock, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::stream::ChainDataBlock, _impl_.dotnum_), + PROTOBUF_FIELD_OFFSET(::stream::ChainDataBlock, _impl_.pointvec_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::Point, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::stream::Point, _impl_.xpos_), + PROTOBUF_FIELD_OFFSET(::stream::Point, _impl_.ypos_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::RegResponce, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::stream::RegResponce, _impl_.data_), }; static const ::_pbi::MigrationSchema @@ -136,44 +341,77 @@ static const ::_pbi::MigrationSchema {0, -1, -1, sizeof(::stream::ParamInfo)}, {11, -1, -1, sizeof(::stream::RequestInfo)}, {23, -1, -1, sizeof(::stream::ResponseInfo)}, + {34, 43, -1, sizeof(::stream::ResponseAny)}, + {44, -1, -1, sizeof(::stream::LayerData)}, + {57, -1, -1, sizeof(::stream::LayerDataBlock)}, + {71, -1, -1, sizeof(::stream::VectorDataBlock)}, + {83, -1, -1, sizeof(::stream::ChainDataBlock)}, + {93, -1, -1, sizeof(::stream::Point)}, + {103, -1, -1, sizeof(::stream::RegResponce)}, }; static const ::_pb::Message* const file_default_instances[] = { &::stream::_ParamInfo_default_instance_._instance, &::stream::_RequestInfo_default_instance_._instance, &::stream::_ResponseInfo_default_instance_._instance, + &::stream::_ResponseAny_default_instance_._instance, + &::stream::_LayerData_default_instance_._instance, + &::stream::_LayerDataBlock_default_instance_._instance, + &::stream::_VectorDataBlock_default_instance_._instance, + &::stream::_ChainDataBlock_default_instance_._instance, + &::stream::_Point_default_instance_._instance, + &::stream::_RegResponce_default_instance_._instance, }; const char descriptor_table_protodef_stream_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - "\n\014stream.proto\022\006stream\"O\n\tParamInfo\022\017\n\007n" - "ameKey\030\001 \001(\014\022\020\n\010strValue\030\002 \001(\014\022\037\n\tvalueT" - "ype\030\003 \001(\0162\014.stream.TYPE\"c\n\013RequestInfo\022\020" - "\n\010dataType\030\001 \001(\r\022\017\n\007nameKey\030\002 \001(\014\022\020\n\010str" - "Value\030\003 \001(\014\022\037\n\tvalueType\030\004 \001(\0162\014.stream." - "TYPE\"Q\n\014ResponseInfo\022\020\n\010dataType\030\001 \001(\r\022\016" - "\n\006result\030\002 \001(\010\022\037\n\004item\030\003 \003(\0132\021.stream.Pa" - "ramInfo*X\n\004TYPE\022\t\n\005iBOOL\020\000\022\n\n\006iSHORT\020\001\022\013" - "\n\007iUSHORT\020\002\022\010\n\004iINT\020\003\022\t\n\005iUINT\020\004\022\n\n\006iFLO" - "AT\020\005\022\013\n\007iSTRING\020\0062\373\001\n\006Stream\0225\n\006Simple\022\023" - ".stream.RequestInfo\032\024.stream.ResponseInf" - "o\"\000\022=\n\014ServerStream\022\023.stream.RequestInfo" - "\032\024.stream.ResponseInfo\"\0000\001\022=\n\014ClientStre" - "am\022\023.stream.RequestInfo\032\024.stream.Respons" - "eInfo\"\000(\001\022<\n\tAllStream\022\023.stream.RequestI" - "nfo\032\024.stream.ResponseInfo\"\000(\0010\001B-\n\027io.gr" - "pc.examples.streamB\013StreamProtoP\001\242\002\002STb\006" - "proto3" + "\n\014stream.proto\022\006stream\032\031google/protobuf/" + "any.proto\"O\n\tParamInfo\022\017\n\007nameKey\030\001 \001(\014\022" + "\020\n\010strValue\030\002 \001(\014\022\037\n\tvalueType\030\003 \001(\0162\014.s" + "tream.TYPE\"c\n\013RequestInfo\022\020\n\010dataType\030\001 " + "\001(\r\022\017\n\007nameKey\030\002 \001(\014\022\020\n\010strValue\030\003 \001(\014\022\037" + "\n\tvalueType\030\004 \001(\0162\014.stream.TYPE\"Q\n\014Respo" + "nseInfo\022\020\n\010dataType\030\001 \001(\r\022\016\n\006result\030\002 \001(" + "\010\022\037\n\004item\030\003 \003(\0132\021.stream.ParamInfo\"1\n\013Re" + "sponseAny\022\"\n\004data\030\001 \001(\0132\024.google.protobu" + "f.Any\"\210\001\n\tLayerData\022\023\n\013zCooldinate\030\001 \001(\002" + "\022\016\n\006powder\030\002 \001(\002\022\026\n\016layerThickness\030\003 \001(\002" + "\022.\n\016layerDataBlock\030\004 \003(\0132\026.stream.LayerD" + "ataBlock\022\016\n\006result\030\005 \001(\010\"\266\001\n\016LayerDataBl" + "ock\022\021\n\telementId\030\001 \001(\005\022\026\n\016elementParamId" + "\030\002 \001(\005\022\021\n\tblockType\030\003 \001(\r\022*\n\tvecBlocks\030\004" + " \003(\0132\027.stream.VectorDataBlock\022+\n\013chainBl" + "ocks\030\005 \003(\0132\026.stream.ChainDataBlock\022\r\n\005or" + "der\030\006 \001(\r\"M\n\017VectorDataBlock\022\016\n\006startX\030\001" + " \001(\002\022\016\n\006startY\030\002 \001(\002\022\014\n\004endX\030\003 \001(\002\022\014\n\004en" + "dY\030\004 \001(\002\"A\n\016ChainDataBlock\022\016\n\006dotNum\030\001 \001" + "(\r\022\037\n\010pointVec\030\002 \003(\0132\r.stream.Point\"#\n\005P" + "oint\022\014\n\004xPos\030\001 \001(\002\022\014\n\004yPos\030\002 \001(\002\"\033\n\013RegR" + "esponce\022\014\n\004data\030\001 \001(\005*X\n\004TYPE\022\t\n\005iBOOL\020\000" + "\022\n\n\006iSHORT\020\001\022\013\n\007iUSHORT\020\002\022\010\n\004iINT\020\003\022\t\n\005i" + "UINT\020\004\022\n\n\006iFLOAT\020\005\022\013\n\007iSTRING\020\0062\372\001\n\006Stre" + "am\0224\n\006Simple\022\023.stream.RequestInfo\032\023.stre" + "am.ResponseAny\"\000\022=\n\014ServerStream\022\023.strea" + "m.RequestInfo\032\024.stream.ResponseInfo\"\0000\001\022" + "=\n\014ClientStream\022\023.stream.RequestInfo\032\024.s" + "tream.ResponseInfo\"\000(\001\022<\n\tAllStream\022\023.st" + "ream.RequestInfo\032\024.stream.ResponseInfo\"\000" + "(\0010\001B-\n\027io.grpc.examples.streamB\013StreamP" + "rotoP\001\242\002\002STb\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_stream_2eproto_deps[1] = + { + &::descriptor_table_google_2fprotobuf_2fany_2eproto, }; static ::absl::once_flag descriptor_table_stream_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_stream_2eproto = { false, false, - 686, + 1299, descriptor_table_protodef_stream_2eproto, "stream.proto", &descriptor_table_stream_2eproto_once, - nullptr, - 0, - 3, + descriptor_table_stream_2eproto_deps, + 1, + 10, schemas, file_default_instances, TableStruct_stream_2eproto::offsets, @@ -986,6 +1224,1728 @@ void ResponseInfo::InternalSwap(ResponseInfo* other) { &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, file_level_metadata_stream_2eproto[2]); } +// =================================================================== + +class ResponseAny::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ResponseAny, _impl_._has_bits_); + static const ::google::protobuf::Any& data(const ResponseAny* msg); + static void set_has_data(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::google::protobuf::Any& ResponseAny::_Internal::data(const ResponseAny* msg) { + return *msg->_impl_.data_; +} +void ResponseAny::clear_data() { + if (_impl_.data_ != nullptr) _impl_.data_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +ResponseAny::ResponseAny(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ResponseAny) +} +ResponseAny::ResponseAny(const ResponseAny& from) : ::google::protobuf::Message() { + ResponseAny* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_}, + /*decltype(_impl_._cached_size_)*/ {}, + decltype(_impl_.data_){nullptr}, + }; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.data_ = new ::google::protobuf::Any(*from._impl_.data_); + } + + // @@protoc_insertion_point(copy_constructor:stream.ResponseAny) +} +inline void ResponseAny::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){}, + /*decltype(_impl_._cached_size_)*/ {}, + decltype(_impl_.data_){nullptr}, + }; +} +ResponseAny::~ResponseAny() { + // @@protoc_insertion_point(destructor:stream.ResponseAny) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ResponseAny::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.data_; +} +void ResponseAny::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ResponseAny::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ResponseAny) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.data_ != nullptr); + _impl_.data_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ResponseAny::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> ResponseAny::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ResponseAny, _impl_._has_bits_), + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_ResponseAny_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // .google.protobuf.Any data = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(ResponseAny, _impl_.data_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .google.protobuf.Any data = 1; + {PROTOBUF_FIELD_OFFSET(ResponseAny, _impl_.data_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + }}, {{ + }}, +}; + +::uint8_t* ResponseAny::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ResponseAny) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // .google.protobuf.Any data = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::data(this), + _Internal::data(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:stream.ResponseAny) + return target; +} + +::size_t ResponseAny::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ResponseAny) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .google.protobuf.Any data = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.data_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ResponseAny::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ResponseAny::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ResponseAny::GetClassData() const { return &_class_data_; } + + +void ResponseAny::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:stream.ResponseAny) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_internal_mutable_data()->::google::protobuf::Any::MergeFrom( + from._internal_data()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ResponseAny::CopyFrom(const ResponseAny& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ResponseAny) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ResponseAny::IsInitialized() const { + return true; +} + +void ResponseAny::InternalSwap(ResponseAny* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.data_, other->_impl_.data_); +} + +::google::protobuf::Metadata ResponseAny::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[3]); +} +// =================================================================== + +class LayerData::_Internal { + public: +}; + +LayerData::LayerData(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.LayerData) +} +LayerData::LayerData(const LayerData& from) : ::google::protobuf::Message() { + LayerData* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.layerdatablock_){from._impl_.layerdatablock_}, + decltype(_impl_.zcooldinate_){}, + decltype(_impl_.powder_){}, + decltype(_impl_.layerthickness_){}, + decltype(_impl_.result_){}, + /*decltype(_impl_._cached_size_)*/ {}, + }; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + ::memcpy(&_impl_.zcooldinate_, &from._impl_.zcooldinate_, + static_cast<::size_t>(reinterpret_cast(&_impl_.result_) - + reinterpret_cast(&_impl_.zcooldinate_)) + sizeof(_impl_.result_)); + + // @@protoc_insertion_point(copy_constructor:stream.LayerData) +} +inline void LayerData::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.layerdatablock_){arena}, + decltype(_impl_.zcooldinate_){0}, + decltype(_impl_.powder_){0}, + decltype(_impl_.layerthickness_){0}, + decltype(_impl_.result_){false}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +LayerData::~LayerData() { + // @@protoc_insertion_point(destructor:stream.LayerData) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void LayerData::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.layerdatablock_.~RepeatedPtrField(); +} +void LayerData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void LayerData::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.LayerData) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_layerdatablock()->Clear(); + ::memset(&_impl_.zcooldinate_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.result_) - + reinterpret_cast(&_impl_.zcooldinate_)) + sizeof(_impl_.result_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* LayerData::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 1, 0, 2> LayerData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 5, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_LayerData_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // float zCooldinate = 1; + {::_pbi::TcParser::FastF32S1, + {13, 63, 0, PROTOBUF_FIELD_OFFSET(LayerData, _impl_.zcooldinate_)}}, + // float powder = 2; + {::_pbi::TcParser::FastF32S1, + {21, 63, 0, PROTOBUF_FIELD_OFFSET(LayerData, _impl_.powder_)}}, + // float layerThickness = 3; + {::_pbi::TcParser::FastF32S1, + {29, 63, 0, PROTOBUF_FIELD_OFFSET(LayerData, _impl_.layerthickness_)}}, + // repeated .stream.LayerDataBlock layerDataBlock = 4; + {::_pbi::TcParser::FastMtR1, + {34, 63, 0, PROTOBUF_FIELD_OFFSET(LayerData, _impl_.layerdatablock_)}}, + // bool result = 5; + {::_pbi::TcParser::SingularVarintNoZag1(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(LayerData, _impl_.result_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // float zCooldinate = 1; + {PROTOBUF_FIELD_OFFSET(LayerData, _impl_.zcooldinate_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float powder = 2; + {PROTOBUF_FIELD_OFFSET(LayerData, _impl_.powder_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float layerThickness = 3; + {PROTOBUF_FIELD_OFFSET(LayerData, _impl_.layerthickness_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // repeated .stream.LayerDataBlock layerDataBlock = 4; + {PROTOBUF_FIELD_OFFSET(LayerData, _impl_.layerdatablock_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // bool result = 5; + {PROTOBUF_FIELD_OFFSET(LayerData, _impl_.result_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, {{ + {::_pbi::TcParser::GetTable<::stream::LayerDataBlock>()}, + }}, {{ + }}, +}; + +::uint8_t* LayerData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.LayerData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // float zCooldinate = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_zcooldinate = this->_internal_zcooldinate(); + ::uint32_t raw_zcooldinate; + memcpy(&raw_zcooldinate, &tmp_zcooldinate, sizeof(tmp_zcooldinate)); + if (raw_zcooldinate != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 1, this->_internal_zcooldinate(), target); + } + + // float powder = 2; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_powder = this->_internal_powder(); + ::uint32_t raw_powder; + memcpy(&raw_powder, &tmp_powder, sizeof(tmp_powder)); + if (raw_powder != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 2, this->_internal_powder(), target); + } + + // float layerThickness = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_layerthickness = this->_internal_layerthickness(); + ::uint32_t raw_layerthickness; + memcpy(&raw_layerthickness, &tmp_layerthickness, sizeof(tmp_layerthickness)); + if (raw_layerthickness != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 3, this->_internal_layerthickness(), target); + } + + // repeated .stream.LayerDataBlock layerDataBlock = 4; + for (unsigned i = 0, + n = static_cast(this->_internal_layerdatablock_size()); i < n; i++) { + const auto& repfield = this->_internal_layerdatablock().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); + } + + // bool result = 5; + if (this->_internal_result() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this->_internal_result(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:stream.LayerData) + return target; +} + +::size_t LayerData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.LayerData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .stream.LayerDataBlock layerDataBlock = 4; + total_size += 1UL * this->_internal_layerdatablock_size(); + for (const auto& msg : this->_internal_layerdatablock()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // float zCooldinate = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_zcooldinate = this->_internal_zcooldinate(); + ::uint32_t raw_zcooldinate; + memcpy(&raw_zcooldinate, &tmp_zcooldinate, sizeof(tmp_zcooldinate)); + if (raw_zcooldinate != 0) { + total_size += 5; + } + + // float powder = 2; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_powder = this->_internal_powder(); + ::uint32_t raw_powder; + memcpy(&raw_powder, &tmp_powder, sizeof(tmp_powder)); + if (raw_powder != 0) { + total_size += 5; + } + + // float layerThickness = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_layerthickness = this->_internal_layerthickness(); + ::uint32_t raw_layerthickness; + memcpy(&raw_layerthickness, &tmp_layerthickness, sizeof(tmp_layerthickness)); + if (raw_layerthickness != 0) { + total_size += 5; + } + + // bool result = 5; + if (this->_internal_result() != 0) { + total_size += 2; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData LayerData::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + LayerData::MergeImpl +}; +const ::google::protobuf::Message::ClassData*LayerData::GetClassData() const { return &_class_data_; } + + +void LayerData::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:stream.LayerData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_layerdatablock()->MergeFrom(from._internal_layerdatablock()); + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_zcooldinate = from._internal_zcooldinate(); + ::uint32_t raw_zcooldinate; + memcpy(&raw_zcooldinate, &tmp_zcooldinate, sizeof(tmp_zcooldinate)); + if (raw_zcooldinate != 0) { + _this->_internal_set_zcooldinate(from._internal_zcooldinate()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_powder = from._internal_powder(); + ::uint32_t raw_powder; + memcpy(&raw_powder, &tmp_powder, sizeof(tmp_powder)); + if (raw_powder != 0) { + _this->_internal_set_powder(from._internal_powder()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_layerthickness = from._internal_layerthickness(); + ::uint32_t raw_layerthickness; + memcpy(&raw_layerthickness, &tmp_layerthickness, sizeof(tmp_layerthickness)); + if (raw_layerthickness != 0) { + _this->_internal_set_layerthickness(from._internal_layerthickness()); + } + if (from._internal_result() != 0) { + _this->_internal_set_result(from._internal_result()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void LayerData::CopyFrom(const LayerData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.LayerData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool LayerData::IsInitialized() const { + return true; +} + +void LayerData::InternalSwap(LayerData* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.layerdatablock_.InternalSwap(&other->_impl_.layerdatablock_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(LayerData, _impl_.result_) + + sizeof(LayerData::_impl_.result_) + - PROTOBUF_FIELD_OFFSET(LayerData, _impl_.zcooldinate_)>( + reinterpret_cast(&_impl_.zcooldinate_), + reinterpret_cast(&other->_impl_.zcooldinate_)); +} + +::google::protobuf::Metadata LayerData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[4]); +} +// =================================================================== + +class LayerDataBlock::_Internal { + public: +}; + +LayerDataBlock::LayerDataBlock(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.LayerDataBlock) +} +LayerDataBlock::LayerDataBlock(const LayerDataBlock& from) : ::google::protobuf::Message() { + LayerDataBlock* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.vecblocks_){from._impl_.vecblocks_}, + decltype(_impl_.chainblocks_){from._impl_.chainblocks_}, + decltype(_impl_.elementid_){}, + decltype(_impl_.elementparamid_){}, + decltype(_impl_.blocktype_){}, + decltype(_impl_.order_){}, + /*decltype(_impl_._cached_size_)*/ {}, + }; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + ::memcpy(&_impl_.elementid_, &from._impl_.elementid_, + static_cast<::size_t>(reinterpret_cast(&_impl_.order_) - + reinterpret_cast(&_impl_.elementid_)) + sizeof(_impl_.order_)); + + // @@protoc_insertion_point(copy_constructor:stream.LayerDataBlock) +} +inline void LayerDataBlock::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.vecblocks_){arena}, + decltype(_impl_.chainblocks_){arena}, + decltype(_impl_.elementid_){0}, + decltype(_impl_.elementparamid_){0}, + decltype(_impl_.blocktype_){0u}, + decltype(_impl_.order_){0u}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +LayerDataBlock::~LayerDataBlock() { + // @@protoc_insertion_point(destructor:stream.LayerDataBlock) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void LayerDataBlock::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.vecblocks_.~RepeatedPtrField(); + _impl_.chainblocks_.~RepeatedPtrField(); +} +void LayerDataBlock::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void LayerDataBlock::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.LayerDataBlock) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_vecblocks()->Clear(); + _internal_mutable_chainblocks()->Clear(); + ::memset(&_impl_.elementid_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.order_) - + reinterpret_cast(&_impl_.elementid_)) + sizeof(_impl_.order_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* LayerDataBlock::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 6, 2, 0, 2> LayerDataBlock::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 6, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967232, // skipmap + offsetof(decltype(_table_), field_entries), + 6, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_LayerDataBlock_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 elementId = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(LayerDataBlock, _impl_.elementid_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.elementid_)}}, + // int32 elementParamId = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(LayerDataBlock, _impl_.elementparamid_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.elementparamid_)}}, + // uint32 blockType = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(LayerDataBlock, _impl_.blocktype_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.blocktype_)}}, + // repeated .stream.VectorDataBlock vecBlocks = 4; + {::_pbi::TcParser::FastMtR1, + {34, 63, 0, PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.vecblocks_)}}, + // repeated .stream.ChainDataBlock chainBlocks = 5; + {::_pbi::TcParser::FastMtR1, + {42, 63, 1, PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.chainblocks_)}}, + // uint32 order = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(LayerDataBlock, _impl_.order_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.order_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 elementId = 1; + {PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.elementid_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 elementParamId = 2; + {PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.elementparamid_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint32 blockType = 3; + {PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.blocktype_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // repeated .stream.VectorDataBlock vecBlocks = 4; + {PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.vecblocks_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .stream.ChainDataBlock chainBlocks = 5; + {PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.chainblocks_), 0, 1, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 order = 6; + {PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.order_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, {{ + {::_pbi::TcParser::GetTable<::stream::VectorDataBlock>()}, + {::_pbi::TcParser::GetTable<::stream::ChainDataBlock>()}, + }}, {{ + }}, +}; + +::uint8_t* LayerDataBlock::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.LayerDataBlock) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 elementId = 1; + if (this->_internal_elementid() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_elementid(), target); + } + + // int32 elementParamId = 2; + if (this->_internal_elementparamid() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_elementparamid(), target); + } + + // uint32 blockType = 3; + if (this->_internal_blocktype() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this->_internal_blocktype(), target); + } + + // repeated .stream.VectorDataBlock vecBlocks = 4; + for (unsigned i = 0, + n = static_cast(this->_internal_vecblocks_size()); i < n; i++) { + const auto& repfield = this->_internal_vecblocks().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .stream.ChainDataBlock chainBlocks = 5; + for (unsigned i = 0, + n = static_cast(this->_internal_chainblocks_size()); i < n; i++) { + const auto& repfield = this->_internal_chainblocks().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream); + } + + // uint32 order = 6; + if (this->_internal_order() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 6, this->_internal_order(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:stream.LayerDataBlock) + return target; +} + +::size_t LayerDataBlock::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.LayerDataBlock) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .stream.VectorDataBlock vecBlocks = 4; + total_size += 1UL * this->_internal_vecblocks_size(); + for (const auto& msg : this->_internal_vecblocks()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // repeated .stream.ChainDataBlock chainBlocks = 5; + total_size += 1UL * this->_internal_chainblocks_size(); + for (const auto& msg : this->_internal_chainblocks()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // int32 elementId = 1; + if (this->_internal_elementid() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_elementid()); + } + + // int32 elementParamId = 2; + if (this->_internal_elementparamid() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_elementparamid()); + } + + // uint32 blockType = 3; + if (this->_internal_blocktype() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_blocktype()); + } + + // uint32 order = 6; + if (this->_internal_order() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_order()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData LayerDataBlock::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + LayerDataBlock::MergeImpl +}; +const ::google::protobuf::Message::ClassData*LayerDataBlock::GetClassData() const { return &_class_data_; } + + +void LayerDataBlock::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:stream.LayerDataBlock) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_vecblocks()->MergeFrom(from._internal_vecblocks()); + _this->_internal_mutable_chainblocks()->MergeFrom(from._internal_chainblocks()); + if (from._internal_elementid() != 0) { + _this->_internal_set_elementid(from._internal_elementid()); + } + if (from._internal_elementparamid() != 0) { + _this->_internal_set_elementparamid(from._internal_elementparamid()); + } + if (from._internal_blocktype() != 0) { + _this->_internal_set_blocktype(from._internal_blocktype()); + } + if (from._internal_order() != 0) { + _this->_internal_set_order(from._internal_order()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void LayerDataBlock::CopyFrom(const LayerDataBlock& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.LayerDataBlock) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool LayerDataBlock::IsInitialized() const { + return true; +} + +void LayerDataBlock::InternalSwap(LayerDataBlock* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.vecblocks_.InternalSwap(&other->_impl_.vecblocks_); + _impl_.chainblocks_.InternalSwap(&other->_impl_.chainblocks_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.order_) + + sizeof(LayerDataBlock::_impl_.order_) + - PROTOBUF_FIELD_OFFSET(LayerDataBlock, _impl_.elementid_)>( + reinterpret_cast(&_impl_.elementid_), + reinterpret_cast(&other->_impl_.elementid_)); +} + +::google::protobuf::Metadata LayerDataBlock::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[5]); +} +// =================================================================== + +class VectorDataBlock::_Internal { + public: +}; + +VectorDataBlock::VectorDataBlock(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.VectorDataBlock) +} +VectorDataBlock::VectorDataBlock(const VectorDataBlock& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.VectorDataBlock) +} +inline void VectorDataBlock::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.startx_){0}, + decltype(_impl_.starty_){0}, + decltype(_impl_.endx_){0}, + decltype(_impl_.endy_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +VectorDataBlock::~VectorDataBlock() { + // @@protoc_insertion_point(destructor:stream.VectorDataBlock) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void VectorDataBlock::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void VectorDataBlock::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void VectorDataBlock::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.VectorDataBlock) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.startx_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.endy_) - + reinterpret_cast(&_impl_.startx_)) + sizeof(_impl_.endy_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* VectorDataBlock::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 0, 2> VectorDataBlock::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 4, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_VectorDataBlock_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // float endY = 4; + {::_pbi::TcParser::FastF32S1, + {37, 63, 0, PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.endy_)}}, + // float startX = 1; + {::_pbi::TcParser::FastF32S1, + {13, 63, 0, PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.startx_)}}, + // float startY = 2; + {::_pbi::TcParser::FastF32S1, + {21, 63, 0, PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.starty_)}}, + // float endX = 3; + {::_pbi::TcParser::FastF32S1, + {29, 63, 0, PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.endx_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // float startX = 1; + {PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.startx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float startY = 2; + {PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.starty_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float endX = 3; + {PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.endx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float endY = 4; + {PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.endy_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* VectorDataBlock::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.VectorDataBlock) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // float startX = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_startx = this->_internal_startx(); + ::uint32_t raw_startx; + memcpy(&raw_startx, &tmp_startx, sizeof(tmp_startx)); + if (raw_startx != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 1, this->_internal_startx(), target); + } + + // float startY = 2; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_starty = this->_internal_starty(); + ::uint32_t raw_starty; + memcpy(&raw_starty, &tmp_starty, sizeof(tmp_starty)); + if (raw_starty != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 2, this->_internal_starty(), target); + } + + // float endX = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_endx = this->_internal_endx(); + ::uint32_t raw_endx; + memcpy(&raw_endx, &tmp_endx, sizeof(tmp_endx)); + if (raw_endx != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 3, this->_internal_endx(), target); + } + + // float endY = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_endy = this->_internal_endy(); + ::uint32_t raw_endy; + memcpy(&raw_endy, &tmp_endy, sizeof(tmp_endy)); + if (raw_endy != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 4, this->_internal_endy(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:stream.VectorDataBlock) + return target; +} + +::size_t VectorDataBlock::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.VectorDataBlock) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // float startX = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_startx = this->_internal_startx(); + ::uint32_t raw_startx; + memcpy(&raw_startx, &tmp_startx, sizeof(tmp_startx)); + if (raw_startx != 0) { + total_size += 5; + } + + // float startY = 2; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_starty = this->_internal_starty(); + ::uint32_t raw_starty; + memcpy(&raw_starty, &tmp_starty, sizeof(tmp_starty)); + if (raw_starty != 0) { + total_size += 5; + } + + // float endX = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_endx = this->_internal_endx(); + ::uint32_t raw_endx; + memcpy(&raw_endx, &tmp_endx, sizeof(tmp_endx)); + if (raw_endx != 0) { + total_size += 5; + } + + // float endY = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_endy = this->_internal_endy(); + ::uint32_t raw_endy; + memcpy(&raw_endy, &tmp_endy, sizeof(tmp_endy)); + if (raw_endy != 0) { + total_size += 5; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData VectorDataBlock::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + VectorDataBlock::MergeImpl +}; +const ::google::protobuf::Message::ClassData*VectorDataBlock::GetClassData() const { return &_class_data_; } + + +void VectorDataBlock::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:stream.VectorDataBlock) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_startx = from._internal_startx(); + ::uint32_t raw_startx; + memcpy(&raw_startx, &tmp_startx, sizeof(tmp_startx)); + if (raw_startx != 0) { + _this->_internal_set_startx(from._internal_startx()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_starty = from._internal_starty(); + ::uint32_t raw_starty; + memcpy(&raw_starty, &tmp_starty, sizeof(tmp_starty)); + if (raw_starty != 0) { + _this->_internal_set_starty(from._internal_starty()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_endx = from._internal_endx(); + ::uint32_t raw_endx; + memcpy(&raw_endx, &tmp_endx, sizeof(tmp_endx)); + if (raw_endx != 0) { + _this->_internal_set_endx(from._internal_endx()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_endy = from._internal_endy(); + ::uint32_t raw_endy; + memcpy(&raw_endy, &tmp_endy, sizeof(tmp_endy)); + if (raw_endy != 0) { + _this->_internal_set_endy(from._internal_endy()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void VectorDataBlock::CopyFrom(const VectorDataBlock& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.VectorDataBlock) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool VectorDataBlock::IsInitialized() const { + return true; +} + +void VectorDataBlock::InternalSwap(VectorDataBlock* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.endy_) + + sizeof(VectorDataBlock::_impl_.endy_) + - PROTOBUF_FIELD_OFFSET(VectorDataBlock, _impl_.startx_)>( + reinterpret_cast(&_impl_.startx_), + reinterpret_cast(&other->_impl_.startx_)); +} + +::google::protobuf::Metadata VectorDataBlock::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[6]); +} +// =================================================================== + +class ChainDataBlock::_Internal { + public: +}; + +ChainDataBlock::ChainDataBlock(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ChainDataBlock) +} +ChainDataBlock::ChainDataBlock(const ChainDataBlock& from) : ::google::protobuf::Message() { + ChainDataBlock* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.pointvec_){from._impl_.pointvec_}, + decltype(_impl_.dotnum_){}, + /*decltype(_impl_._cached_size_)*/ {}, + }; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + _this->_impl_.dotnum_ = from._impl_.dotnum_; + + // @@protoc_insertion_point(copy_constructor:stream.ChainDataBlock) +} +inline void ChainDataBlock::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.pointvec_){arena}, + decltype(_impl_.dotnum_){0u}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +ChainDataBlock::~ChainDataBlock() { + // @@protoc_insertion_point(destructor:stream.ChainDataBlock) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ChainDataBlock::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.pointvec_.~RepeatedPtrField(); +} +void ChainDataBlock::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ChainDataBlock::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ChainDataBlock) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_pointvec()->Clear(); + _impl_.dotnum_ = 0u; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ChainDataBlock::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> ChainDataBlock::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_ChainDataBlock_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // repeated .stream.Point pointVec = 2; + {::_pbi::TcParser::FastMtR1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(ChainDataBlock, _impl_.pointvec_)}}, + // uint32 dotNum = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChainDataBlock, _impl_.dotnum_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ChainDataBlock, _impl_.dotnum_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 dotNum = 1; + {PROTOBUF_FIELD_OFFSET(ChainDataBlock, _impl_.dotnum_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // repeated .stream.Point pointVec = 2; + {PROTOBUF_FIELD_OFFSET(ChainDataBlock, _impl_.pointvec_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::stream::Point>()}, + }}, {{ + }}, +}; + +::uint8_t* ChainDataBlock::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ChainDataBlock) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 dotNum = 1; + if (this->_internal_dotnum() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this->_internal_dotnum(), target); + } + + // repeated .stream.Point pointVec = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_pointvec_size()); i < n; i++) { + const auto& repfield = this->_internal_pointvec().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:stream.ChainDataBlock) + return target; +} + +::size_t ChainDataBlock::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ChainDataBlock) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .stream.Point pointVec = 2; + total_size += 1UL * this->_internal_pointvec_size(); + for (const auto& msg : this->_internal_pointvec()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // uint32 dotNum = 1; + if (this->_internal_dotnum() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_dotnum()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ChainDataBlock::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ChainDataBlock::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ChainDataBlock::GetClassData() const { return &_class_data_; } + + +void ChainDataBlock::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:stream.ChainDataBlock) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_pointvec()->MergeFrom(from._internal_pointvec()); + if (from._internal_dotnum() != 0) { + _this->_internal_set_dotnum(from._internal_dotnum()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ChainDataBlock::CopyFrom(const ChainDataBlock& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ChainDataBlock) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ChainDataBlock::IsInitialized() const { + return true; +} + +void ChainDataBlock::InternalSwap(ChainDataBlock* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.pointvec_.InternalSwap(&other->_impl_.pointvec_); + swap(_impl_.dotnum_, other->_impl_.dotnum_); +} + +::google::protobuf::Metadata ChainDataBlock::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[7]); +} +// =================================================================== + +class Point::_Internal { + public: +}; + +Point::Point(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.Point) +} +Point::Point(const Point& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.Point) +} +inline void Point::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.xpos_){0}, + decltype(_impl_.ypos_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +Point::~Point() { + // @@protoc_insertion_point(destructor:stream.Point) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void Point::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void Point::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void Point::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.Point) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.xpos_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.ypos_) - + reinterpret_cast(&_impl_.xpos_)) + sizeof(_impl_.ypos_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* Point::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> Point::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_Point_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // float yPos = 2; + {::_pbi::TcParser::FastF32S1, + {21, 63, 0, PROTOBUF_FIELD_OFFSET(Point, _impl_.ypos_)}}, + // float xPos = 1; + {::_pbi::TcParser::FastF32S1, + {13, 63, 0, PROTOBUF_FIELD_OFFSET(Point, _impl_.xpos_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // float xPos = 1; + {PROTOBUF_FIELD_OFFSET(Point, _impl_.xpos_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float yPos = 2; + {PROTOBUF_FIELD_OFFSET(Point, _impl_.ypos_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* Point::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.Point) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // float xPos = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_xpos = this->_internal_xpos(); + ::uint32_t raw_xpos; + memcpy(&raw_xpos, &tmp_xpos, sizeof(tmp_xpos)); + if (raw_xpos != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 1, this->_internal_xpos(), target); + } + + // float yPos = 2; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_ypos = this->_internal_ypos(); + ::uint32_t raw_ypos; + memcpy(&raw_ypos, &tmp_ypos, sizeof(tmp_ypos)); + if (raw_ypos != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 2, this->_internal_ypos(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:stream.Point) + return target; +} + +::size_t Point::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.Point) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // float xPos = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_xpos = this->_internal_xpos(); + ::uint32_t raw_xpos; + memcpy(&raw_xpos, &tmp_xpos, sizeof(tmp_xpos)); + if (raw_xpos != 0) { + total_size += 5; + } + + // float yPos = 2; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_ypos = this->_internal_ypos(); + ::uint32_t raw_ypos; + memcpy(&raw_ypos, &tmp_ypos, sizeof(tmp_ypos)); + if (raw_ypos != 0) { + total_size += 5; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData Point::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + Point::MergeImpl +}; +const ::google::protobuf::Message::ClassData*Point::GetClassData() const { return &_class_data_; } + + +void Point::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:stream.Point) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_xpos = from._internal_xpos(); + ::uint32_t raw_xpos; + memcpy(&raw_xpos, &tmp_xpos, sizeof(tmp_xpos)); + if (raw_xpos != 0) { + _this->_internal_set_xpos(from._internal_xpos()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_ypos = from._internal_ypos(); + ::uint32_t raw_ypos; + memcpy(&raw_ypos, &tmp_ypos, sizeof(tmp_ypos)); + if (raw_ypos != 0) { + _this->_internal_set_ypos(from._internal_ypos()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Point::CopyFrom(const Point& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.Point) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool Point::IsInitialized() const { + return true; +} + +void Point::InternalSwap(Point* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(Point, _impl_.ypos_) + + sizeof(Point::_impl_.ypos_) + - PROTOBUF_FIELD_OFFSET(Point, _impl_.xpos_)>( + reinterpret_cast(&_impl_.xpos_), + reinterpret_cast(&other->_impl_.xpos_)); +} + +::google::protobuf::Metadata Point::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[8]); +} +// =================================================================== + +class RegResponce::_Internal { + public: +}; + +RegResponce::RegResponce(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.RegResponce) +} +RegResponce::RegResponce(const RegResponce& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.RegResponce) +} +inline void RegResponce::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.data_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +RegResponce::~RegResponce() { + // @@protoc_insertion_point(destructor:stream.RegResponce) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void RegResponce::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void RegResponce::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void RegResponce::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.RegResponce) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.data_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* RegResponce::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RegResponce::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_RegResponce_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // int32 data = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RegResponce, _impl_.data_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RegResponce, _impl_.data_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 data = 1; + {PROTOBUF_FIELD_OFFSET(RegResponce, _impl_.data_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* RegResponce::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.RegResponce) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 data = 1; + if (this->_internal_data() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_data(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:stream.RegResponce) + return target; +} + +::size_t RegResponce::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.RegResponce) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 data = 1; + if (this->_internal_data() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_data()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData RegResponce::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + RegResponce::MergeImpl +}; +const ::google::protobuf::Message::ClassData*RegResponce::GetClassData() const { return &_class_data_; } + + +void RegResponce::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:stream.RegResponce) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_data() != 0) { + _this->_internal_set_data(from._internal_data()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RegResponce::CopyFrom(const RegResponce& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.RegResponce) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool RegResponce::IsInitialized() const { + return true; +} + +void RegResponce::InternalSwap(RegResponce* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.data_, other->_impl_.data_); +} + +::google::protobuf::Metadata RegResponce::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[9]); +} // @@protoc_insertion_point(namespace_scope) } // namespace stream namespace google { diff --git a/TestClient/protobuf/stream.pb.h b/TestClient/protobuf/stream.pb.h index 635d478..baf6347 100644 --- a/TestClient/protobuf/stream.pb.h +++ b/TestClient/protobuf/stream.pb.h @@ -33,6 +33,7 @@ #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" +#include "google/protobuf/any.pb.h" // @@protoc_insertion_point(includes) // Must be included last. @@ -55,15 +56,36 @@ struct TableStruct_stream_2eproto { extern const ::google::protobuf::internal::DescriptorTable descriptor_table_stream_2eproto; namespace stream { +class ChainDataBlock; +struct ChainDataBlockDefaultTypeInternal; +extern ChainDataBlockDefaultTypeInternal _ChainDataBlock_default_instance_; +class LayerData; +struct LayerDataDefaultTypeInternal; +extern LayerDataDefaultTypeInternal _LayerData_default_instance_; +class LayerDataBlock; +struct LayerDataBlockDefaultTypeInternal; +extern LayerDataBlockDefaultTypeInternal _LayerDataBlock_default_instance_; class ParamInfo; struct ParamInfoDefaultTypeInternal; extern ParamInfoDefaultTypeInternal _ParamInfo_default_instance_; +class Point; +struct PointDefaultTypeInternal; +extern PointDefaultTypeInternal _Point_default_instance_; +class RegResponce; +struct RegResponceDefaultTypeInternal; +extern RegResponceDefaultTypeInternal _RegResponce_default_instance_; class RequestInfo; struct RequestInfoDefaultTypeInternal; extern RequestInfoDefaultTypeInternal _RequestInfo_default_instance_; +class ResponseAny; +struct ResponseAnyDefaultTypeInternal; +extern ResponseAnyDefaultTypeInternal _ResponseAny_default_instance_; class ResponseInfo; struct ResponseInfoDefaultTypeInternal; extern ResponseInfoDefaultTypeInternal _ResponseInfo_default_instance_; +class VectorDataBlock; +struct VectorDataBlockDefaultTypeInternal; +extern VectorDataBlockDefaultTypeInternal _VectorDataBlock_default_instance_; } // namespace stream namespace google { namespace protobuf { @@ -702,6 +724,1318 @@ class ResponseInfo final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ResponseAny final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ResponseAny) */ { + public: + inline ResponseAny() : ResponseAny(nullptr) {} + ~ResponseAny() override; + template + explicit PROTOBUF_CONSTEXPR ResponseAny(::google::protobuf::internal::ConstantInitialized); + + ResponseAny(const ResponseAny& from); + ResponseAny(ResponseAny&& from) noexcept + : ResponseAny() { + *this = ::std::move(from); + } + + inline ResponseAny& operator=(const ResponseAny& from) { + CopyFrom(from); + return *this; + } + inline ResponseAny& operator=(ResponseAny&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ResponseAny& default_instance() { + return *internal_default_instance(); + } + static inline const ResponseAny* internal_default_instance() { + return reinterpret_cast( + &_ResponseAny_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(ResponseAny& a, ResponseAny& b) { + a.Swap(&b); + } + inline void Swap(ResponseAny* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ResponseAny* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ResponseAny* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ResponseAny& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ResponseAny& from) { + ResponseAny::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ResponseAny* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ResponseAny"; + } + protected: + explicit ResponseAny(::google::protobuf::Arena* arena); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDataFieldNumber = 1, + }; + // .google.protobuf.Any data = 1; + bool has_data() const; + void clear_data() ; + const ::google::protobuf::Any& data() const; + PROTOBUF_NODISCARD ::google::protobuf::Any* release_data(); + ::google::protobuf::Any* mutable_data(); + void set_allocated_data(::google::protobuf::Any* value); + void unsafe_arena_set_allocated_data(::google::protobuf::Any* value); + ::google::protobuf::Any* unsafe_arena_release_data(); + + private: + const ::google::protobuf::Any& _internal_data() const; + ::google::protobuf::Any* _internal_mutable_data(); + + public: + // @@protoc_insertion_point(class_scope:stream.ResponseAny) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, 1, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::Any* data_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class LayerData final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.LayerData) */ { + public: + inline LayerData() : LayerData(nullptr) {} + ~LayerData() override; + template + explicit PROTOBUF_CONSTEXPR LayerData(::google::protobuf::internal::ConstantInitialized); + + LayerData(const LayerData& from); + LayerData(LayerData&& from) noexcept + : LayerData() { + *this = ::std::move(from); + } + + inline LayerData& operator=(const LayerData& from) { + CopyFrom(from); + return *this; + } + inline LayerData& operator=(LayerData&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LayerData& default_instance() { + return *internal_default_instance(); + } + static inline const LayerData* internal_default_instance() { + return reinterpret_cast( + &_LayerData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(LayerData& a, LayerData& b) { + a.Swap(&b); + } + inline void Swap(LayerData* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LayerData* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LayerData* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const LayerData& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const LayerData& from) { + LayerData::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LayerData* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.LayerData"; + } + protected: + explicit LayerData(::google::protobuf::Arena* arena); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLayerDataBlockFieldNumber = 4, + kZCooldinateFieldNumber = 1, + kPowderFieldNumber = 2, + kLayerThicknessFieldNumber = 3, + kResultFieldNumber = 5, + }; + // repeated .stream.LayerDataBlock layerDataBlock = 4; + int layerdatablock_size() const; + private: + int _internal_layerdatablock_size() const; + + public: + void clear_layerdatablock() ; + ::stream::LayerDataBlock* mutable_layerdatablock(int index); + ::google::protobuf::RepeatedPtrField< ::stream::LayerDataBlock >* + mutable_layerdatablock(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::LayerDataBlock>& _internal_layerdatablock() const; + ::google::protobuf::RepeatedPtrField<::stream::LayerDataBlock>* _internal_mutable_layerdatablock(); + public: + const ::stream::LayerDataBlock& layerdatablock(int index) const; + ::stream::LayerDataBlock* add_layerdatablock(); + const ::google::protobuf::RepeatedPtrField< ::stream::LayerDataBlock >& + layerdatablock() const; + // float zCooldinate = 1; + void clear_zcooldinate() ; + float zcooldinate() const; + void set_zcooldinate(float value); + + private: + float _internal_zcooldinate() const; + void _internal_set_zcooldinate(float value); + + public: + // float powder = 2; + void clear_powder() ; + float powder() const; + void set_powder(float value); + + private: + float _internal_powder() const; + void _internal_set_powder(float value); + + public: + // float layerThickness = 3; + void clear_layerthickness() ; + float layerthickness() const; + void set_layerthickness(float value); + + private: + float _internal_layerthickness() const; + void _internal_set_layerthickness(float value); + + public: + // bool result = 5; + void clear_result() ; + bool result() const; + void set_result(bool value); + + private: + bool _internal_result() const; + void _internal_set_result(bool value); + + public: + // @@protoc_insertion_point(class_scope:stream.LayerData) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, 1, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::google::protobuf::RepeatedPtrField< ::stream::LayerDataBlock > layerdatablock_; + float zcooldinate_; + float powder_; + float layerthickness_; + bool result_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class LayerDataBlock final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.LayerDataBlock) */ { + public: + inline LayerDataBlock() : LayerDataBlock(nullptr) {} + ~LayerDataBlock() override; + template + explicit PROTOBUF_CONSTEXPR LayerDataBlock(::google::protobuf::internal::ConstantInitialized); + + LayerDataBlock(const LayerDataBlock& from); + LayerDataBlock(LayerDataBlock&& from) noexcept + : LayerDataBlock() { + *this = ::std::move(from); + } + + inline LayerDataBlock& operator=(const LayerDataBlock& from) { + CopyFrom(from); + return *this; + } + inline LayerDataBlock& operator=(LayerDataBlock&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LayerDataBlock& default_instance() { + return *internal_default_instance(); + } + static inline const LayerDataBlock* internal_default_instance() { + return reinterpret_cast( + &_LayerDataBlock_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(LayerDataBlock& a, LayerDataBlock& b) { + a.Swap(&b); + } + inline void Swap(LayerDataBlock* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LayerDataBlock* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LayerDataBlock* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const LayerDataBlock& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const LayerDataBlock& from) { + LayerDataBlock::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LayerDataBlock* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.LayerDataBlock"; + } + protected: + explicit LayerDataBlock(::google::protobuf::Arena* arena); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVecBlocksFieldNumber = 4, + kChainBlocksFieldNumber = 5, + kElementIdFieldNumber = 1, + kElementParamIdFieldNumber = 2, + kBlockTypeFieldNumber = 3, + kOrderFieldNumber = 6, + }; + // repeated .stream.VectorDataBlock vecBlocks = 4; + int vecblocks_size() const; + private: + int _internal_vecblocks_size() const; + + public: + void clear_vecblocks() ; + ::stream::VectorDataBlock* mutable_vecblocks(int index); + ::google::protobuf::RepeatedPtrField< ::stream::VectorDataBlock >* + mutable_vecblocks(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::VectorDataBlock>& _internal_vecblocks() const; + ::google::protobuf::RepeatedPtrField<::stream::VectorDataBlock>* _internal_mutable_vecblocks(); + public: + const ::stream::VectorDataBlock& vecblocks(int index) const; + ::stream::VectorDataBlock* add_vecblocks(); + const ::google::protobuf::RepeatedPtrField< ::stream::VectorDataBlock >& + vecblocks() const; + // repeated .stream.ChainDataBlock chainBlocks = 5; + int chainblocks_size() const; + private: + int _internal_chainblocks_size() const; + + public: + void clear_chainblocks() ; + ::stream::ChainDataBlock* mutable_chainblocks(int index); + ::google::protobuf::RepeatedPtrField< ::stream::ChainDataBlock >* + mutable_chainblocks(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::ChainDataBlock>& _internal_chainblocks() const; + ::google::protobuf::RepeatedPtrField<::stream::ChainDataBlock>* _internal_mutable_chainblocks(); + public: + const ::stream::ChainDataBlock& chainblocks(int index) const; + ::stream::ChainDataBlock* add_chainblocks(); + const ::google::protobuf::RepeatedPtrField< ::stream::ChainDataBlock >& + chainblocks() const; + // int32 elementId = 1; + void clear_elementid() ; + ::int32_t elementid() const; + void set_elementid(::int32_t value); + + private: + ::int32_t _internal_elementid() const; + void _internal_set_elementid(::int32_t value); + + public: + // int32 elementParamId = 2; + void clear_elementparamid() ; + ::int32_t elementparamid() const; + void set_elementparamid(::int32_t value); + + private: + ::int32_t _internal_elementparamid() const; + void _internal_set_elementparamid(::int32_t value); + + public: + // uint32 blockType = 3; + void clear_blocktype() ; + ::uint32_t blocktype() const; + void set_blocktype(::uint32_t value); + + private: + ::uint32_t _internal_blocktype() const; + void _internal_set_blocktype(::uint32_t value); + + public: + // uint32 order = 6; + void clear_order() ; + ::uint32_t order() const; + void set_order(::uint32_t value); + + private: + ::uint32_t _internal_order() const; + void _internal_set_order(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:stream.LayerDataBlock) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 6, 2, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::google::protobuf::RepeatedPtrField< ::stream::VectorDataBlock > vecblocks_; + ::google::protobuf::RepeatedPtrField< ::stream::ChainDataBlock > chainblocks_; + ::int32_t elementid_; + ::int32_t elementparamid_; + ::uint32_t blocktype_; + ::uint32_t order_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class VectorDataBlock final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.VectorDataBlock) */ { + public: + inline VectorDataBlock() : VectorDataBlock(nullptr) {} + ~VectorDataBlock() override; + template + explicit PROTOBUF_CONSTEXPR VectorDataBlock(::google::protobuf::internal::ConstantInitialized); + + VectorDataBlock(const VectorDataBlock& from); + VectorDataBlock(VectorDataBlock&& from) noexcept + : VectorDataBlock() { + *this = ::std::move(from); + } + + inline VectorDataBlock& operator=(const VectorDataBlock& from) { + CopyFrom(from); + return *this; + } + inline VectorDataBlock& operator=(VectorDataBlock&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const VectorDataBlock& default_instance() { + return *internal_default_instance(); + } + static inline const VectorDataBlock* internal_default_instance() { + return reinterpret_cast( + &_VectorDataBlock_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(VectorDataBlock& a, VectorDataBlock& b) { + a.Swap(&b); + } + inline void Swap(VectorDataBlock* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(VectorDataBlock* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + VectorDataBlock* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const VectorDataBlock& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const VectorDataBlock& from) { + VectorDataBlock::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorDataBlock* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.VectorDataBlock"; + } + protected: + explicit VectorDataBlock(::google::protobuf::Arena* arena); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStartXFieldNumber = 1, + kStartYFieldNumber = 2, + kEndXFieldNumber = 3, + kEndYFieldNumber = 4, + }; + // float startX = 1; + void clear_startx() ; + float startx() const; + void set_startx(float value); + + private: + float _internal_startx() const; + void _internal_set_startx(float value); + + public: + // float startY = 2; + void clear_starty() ; + float starty() const; + void set_starty(float value); + + private: + float _internal_starty() const; + void _internal_set_starty(float value); + + public: + // float endX = 3; + void clear_endx() ; + float endx() const; + void set_endx(float value); + + private: + float _internal_endx() const; + void _internal_set_endx(float value); + + public: + // float endY = 4; + void clear_endy() ; + float endy() const; + void set_endy(float value); + + private: + float _internal_endy() const; + void _internal_set_endy(float value); + + public: + // @@protoc_insertion_point(class_scope:stream.VectorDataBlock) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 4, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + float startx_; + float starty_; + float endx_; + float endy_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ChainDataBlock final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ChainDataBlock) */ { + public: + inline ChainDataBlock() : ChainDataBlock(nullptr) {} + ~ChainDataBlock() override; + template + explicit PROTOBUF_CONSTEXPR ChainDataBlock(::google::protobuf::internal::ConstantInitialized); + + ChainDataBlock(const ChainDataBlock& from); + ChainDataBlock(ChainDataBlock&& from) noexcept + : ChainDataBlock() { + *this = ::std::move(from); + } + + inline ChainDataBlock& operator=(const ChainDataBlock& from) { + CopyFrom(from); + return *this; + } + inline ChainDataBlock& operator=(ChainDataBlock&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ChainDataBlock& default_instance() { + return *internal_default_instance(); + } + static inline const ChainDataBlock* internal_default_instance() { + return reinterpret_cast( + &_ChainDataBlock_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(ChainDataBlock& a, ChainDataBlock& b) { + a.Swap(&b); + } + inline void Swap(ChainDataBlock* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChainDataBlock* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ChainDataBlock* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ChainDataBlock& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ChainDataBlock& from) { + ChainDataBlock::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ChainDataBlock* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ChainDataBlock"; + } + protected: + explicit ChainDataBlock(::google::protobuf::Arena* arena); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPointVecFieldNumber = 2, + kDotNumFieldNumber = 1, + }; + // repeated .stream.Point pointVec = 2; + int pointvec_size() const; + private: + int _internal_pointvec_size() const; + + public: + void clear_pointvec() ; + ::stream::Point* mutable_pointvec(int index); + ::google::protobuf::RepeatedPtrField< ::stream::Point >* + mutable_pointvec(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::Point>& _internal_pointvec() const; + ::google::protobuf::RepeatedPtrField<::stream::Point>* _internal_mutable_pointvec(); + public: + const ::stream::Point& pointvec(int index) const; + ::stream::Point* add_pointvec(); + const ::google::protobuf::RepeatedPtrField< ::stream::Point >& + pointvec() const; + // uint32 dotNum = 1; + void clear_dotnum() ; + ::uint32_t dotnum() const; + void set_dotnum(::uint32_t value); + + private: + ::uint32_t _internal_dotnum() const; + void _internal_set_dotnum(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:stream.ChainDataBlock) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, 1, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::google::protobuf::RepeatedPtrField< ::stream::Point > pointvec_; + ::uint32_t dotnum_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class Point final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.Point) */ { + public: + inline Point() : Point(nullptr) {} + ~Point() override; + template + explicit PROTOBUF_CONSTEXPR Point(::google::protobuf::internal::ConstantInitialized); + + Point(const Point& from); + Point(Point&& from) noexcept + : Point() { + *this = ::std::move(from); + } + + inline Point& operator=(const Point& from) { + CopyFrom(from); + return *this; + } + inline Point& operator=(Point&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Point& default_instance() { + return *internal_default_instance(); + } + static inline const Point* internal_default_instance() { + return reinterpret_cast( + &_Point_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(Point& a, Point& b) { + a.Swap(&b); + } + inline void Swap(Point* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Point* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Point* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Point& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const Point& from) { + Point::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Point* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.Point"; + } + protected: + explicit Point(::google::protobuf::Arena* arena); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kXPosFieldNumber = 1, + kYPosFieldNumber = 2, + }; + // float xPos = 1; + void clear_xpos() ; + float xpos() const; + void set_xpos(float value); + + private: + float _internal_xpos() const; + void _internal_set_xpos(float value); + + public: + // float yPos = 2; + void clear_ypos() ; + float ypos() const; + void set_ypos(float value); + + private: + float _internal_ypos() const; + void _internal_set_ypos(float value); + + public: + // @@protoc_insertion_point(class_scope:stream.Point) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + float xpos_; + float ypos_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class RegResponce final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.RegResponce) */ { + public: + inline RegResponce() : RegResponce(nullptr) {} + ~RegResponce() override; + template + explicit PROTOBUF_CONSTEXPR RegResponce(::google::protobuf::internal::ConstantInitialized); + + RegResponce(const RegResponce& from); + RegResponce(RegResponce&& from) noexcept + : RegResponce() { + *this = ::std::move(from); + } + + inline RegResponce& operator=(const RegResponce& from) { + CopyFrom(from); + return *this; + } + inline RegResponce& operator=(RegResponce&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RegResponce& default_instance() { + return *internal_default_instance(); + } + static inline const RegResponce* internal_default_instance() { + return reinterpret_cast( + &_RegResponce_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(RegResponce& a, RegResponce& b) { + a.Swap(&b); + } + inline void Swap(RegResponce* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RegResponce* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RegResponce* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RegResponce& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const RegResponce& from) { + RegResponce::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RegResponce* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.RegResponce"; + } + protected: + explicit RegResponce(::google::protobuf::Arena* arena); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDataFieldNumber = 1, + }; + // int32 data = 1; + void clear_data() ; + ::int32_t data() const; + void set_data(::int32_t value); + + private: + ::int32_t _internal_data() const; + void _internal_set_data(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:stream.RegResponce) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t data_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; }; // =================================================================== @@ -1088,6 +2422,662 @@ ResponseInfo::_internal_mutable_item() { return &_impl_.item_; } +// ------------------------------------------------------------------- + +// ResponseAny + +// .google.protobuf.Any data = 1; +inline bool ResponseAny::has_data() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); + return value; +} +inline const ::google::protobuf::Any& ResponseAny::_internal_data() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::google::protobuf::Any* p = _impl_.data_; + return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); +} +inline const ::google::protobuf::Any& ResponseAny::data() const { + // @@protoc_insertion_point(field_get:stream.ResponseAny.data) + return _internal_data(); +} +inline void ResponseAny::unsafe_arena_set_allocated_data(::google::protobuf::Any* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); + } + _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ResponseAny.data) +} +inline ::google::protobuf::Any* ResponseAny::release_data() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::google::protobuf::Any* released = _impl_.data_; + _impl_.data_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return released; +} +inline ::google::protobuf::Any* ResponseAny::unsafe_arena_release_data() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ResponseAny.data) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::google::protobuf::Any* temp = _impl_.data_; + _impl_.data_ = nullptr; + return temp; +} +inline ::google::protobuf::Any* ResponseAny::_internal_mutable_data() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.data_ == nullptr) { + auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArenaForAllocation()); + _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(p); + } + return _impl_.data_; +} +inline ::google::protobuf::Any* ResponseAny::mutable_data() { + ::google::protobuf::Any* _msg = _internal_mutable_data(); + // @@protoc_insertion_point(field_mutable:stream.ResponseAny.data) + return _msg; +} +inline void ResponseAny::set_allocated_data(::google::protobuf::Any* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::google::protobuf::MessageLite*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ResponseAny.data) +} + +// ------------------------------------------------------------------- + +// LayerData + +// float zCooldinate = 1; +inline void LayerData::clear_zcooldinate() { + _impl_.zcooldinate_ = 0; +} +inline float LayerData::zcooldinate() const { + // @@protoc_insertion_point(field_get:stream.LayerData.zCooldinate) + return _internal_zcooldinate(); +} +inline void LayerData::set_zcooldinate(float value) { + _internal_set_zcooldinate(value); + // @@protoc_insertion_point(field_set:stream.LayerData.zCooldinate) +} +inline float LayerData::_internal_zcooldinate() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.zcooldinate_; +} +inline void LayerData::_internal_set_zcooldinate(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.zcooldinate_ = value; +} + +// float powder = 2; +inline void LayerData::clear_powder() { + _impl_.powder_ = 0; +} +inline float LayerData::powder() const { + // @@protoc_insertion_point(field_get:stream.LayerData.powder) + return _internal_powder(); +} +inline void LayerData::set_powder(float value) { + _internal_set_powder(value); + // @@protoc_insertion_point(field_set:stream.LayerData.powder) +} +inline float LayerData::_internal_powder() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.powder_; +} +inline void LayerData::_internal_set_powder(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.powder_ = value; +} + +// float layerThickness = 3; +inline void LayerData::clear_layerthickness() { + _impl_.layerthickness_ = 0; +} +inline float LayerData::layerthickness() const { + // @@protoc_insertion_point(field_get:stream.LayerData.layerThickness) + return _internal_layerthickness(); +} +inline void LayerData::set_layerthickness(float value) { + _internal_set_layerthickness(value); + // @@protoc_insertion_point(field_set:stream.LayerData.layerThickness) +} +inline float LayerData::_internal_layerthickness() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.layerthickness_; +} +inline void LayerData::_internal_set_layerthickness(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.layerthickness_ = value; +} + +// repeated .stream.LayerDataBlock layerDataBlock = 4; +inline int LayerData::_internal_layerdatablock_size() const { + return _internal_layerdatablock().size(); +} +inline int LayerData::layerdatablock_size() const { + return _internal_layerdatablock_size(); +} +inline void LayerData::clear_layerdatablock() { + _internal_mutable_layerdatablock()->Clear(); +} +inline ::stream::LayerDataBlock* LayerData::mutable_layerdatablock(int index) { + // @@protoc_insertion_point(field_mutable:stream.LayerData.layerDataBlock) + return _internal_mutable_layerdatablock()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::LayerDataBlock >* +LayerData::mutable_layerdatablock() { + // @@protoc_insertion_point(field_mutable_list:stream.LayerData.layerDataBlock) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_layerdatablock(); +} +inline const ::stream::LayerDataBlock& LayerData::layerdatablock(int index) const { + // @@protoc_insertion_point(field_get:stream.LayerData.layerDataBlock) + return _internal_layerdatablock().Get(index); +} +inline ::stream::LayerDataBlock* LayerData::add_layerdatablock() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::LayerDataBlock* _add = _internal_mutable_layerdatablock()->Add(); + // @@protoc_insertion_point(field_add:stream.LayerData.layerDataBlock) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::LayerDataBlock >& +LayerData::layerdatablock() const { + // @@protoc_insertion_point(field_list:stream.LayerData.layerDataBlock) + return _internal_layerdatablock(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::LayerDataBlock>& +LayerData::_internal_layerdatablock() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.layerdatablock_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::LayerDataBlock>* +LayerData::_internal_mutable_layerdatablock() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.layerdatablock_; +} + +// bool result = 5; +inline void LayerData::clear_result() { + _impl_.result_ = false; +} +inline bool LayerData::result() const { + // @@protoc_insertion_point(field_get:stream.LayerData.result) + return _internal_result(); +} +inline void LayerData::set_result(bool value) { + _internal_set_result(value); + // @@protoc_insertion_point(field_set:stream.LayerData.result) +} +inline bool LayerData::_internal_result() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.result_; +} +inline void LayerData::_internal_set_result(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.result_ = value; +} + +// ------------------------------------------------------------------- + +// LayerDataBlock + +// int32 elementId = 1; +inline void LayerDataBlock::clear_elementid() { + _impl_.elementid_ = 0; +} +inline ::int32_t LayerDataBlock::elementid() const { + // @@protoc_insertion_point(field_get:stream.LayerDataBlock.elementId) + return _internal_elementid(); +} +inline void LayerDataBlock::set_elementid(::int32_t value) { + _internal_set_elementid(value); + // @@protoc_insertion_point(field_set:stream.LayerDataBlock.elementId) +} +inline ::int32_t LayerDataBlock::_internal_elementid() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.elementid_; +} +inline void LayerDataBlock::_internal_set_elementid(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.elementid_ = value; +} + +// int32 elementParamId = 2; +inline void LayerDataBlock::clear_elementparamid() { + _impl_.elementparamid_ = 0; +} +inline ::int32_t LayerDataBlock::elementparamid() const { + // @@protoc_insertion_point(field_get:stream.LayerDataBlock.elementParamId) + return _internal_elementparamid(); +} +inline void LayerDataBlock::set_elementparamid(::int32_t value) { + _internal_set_elementparamid(value); + // @@protoc_insertion_point(field_set:stream.LayerDataBlock.elementParamId) +} +inline ::int32_t LayerDataBlock::_internal_elementparamid() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.elementparamid_; +} +inline void LayerDataBlock::_internal_set_elementparamid(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.elementparamid_ = value; +} + +// uint32 blockType = 3; +inline void LayerDataBlock::clear_blocktype() { + _impl_.blocktype_ = 0u; +} +inline ::uint32_t LayerDataBlock::blocktype() const { + // @@protoc_insertion_point(field_get:stream.LayerDataBlock.blockType) + return _internal_blocktype(); +} +inline void LayerDataBlock::set_blocktype(::uint32_t value) { + _internal_set_blocktype(value); + // @@protoc_insertion_point(field_set:stream.LayerDataBlock.blockType) +} +inline ::uint32_t LayerDataBlock::_internal_blocktype() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.blocktype_; +} +inline void LayerDataBlock::_internal_set_blocktype(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.blocktype_ = value; +} + +// repeated .stream.VectorDataBlock vecBlocks = 4; +inline int LayerDataBlock::_internal_vecblocks_size() const { + return _internal_vecblocks().size(); +} +inline int LayerDataBlock::vecblocks_size() const { + return _internal_vecblocks_size(); +} +inline void LayerDataBlock::clear_vecblocks() { + _internal_mutable_vecblocks()->Clear(); +} +inline ::stream::VectorDataBlock* LayerDataBlock::mutable_vecblocks(int index) { + // @@protoc_insertion_point(field_mutable:stream.LayerDataBlock.vecBlocks) + return _internal_mutable_vecblocks()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::VectorDataBlock >* +LayerDataBlock::mutable_vecblocks() { + // @@protoc_insertion_point(field_mutable_list:stream.LayerDataBlock.vecBlocks) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_vecblocks(); +} +inline const ::stream::VectorDataBlock& LayerDataBlock::vecblocks(int index) const { + // @@protoc_insertion_point(field_get:stream.LayerDataBlock.vecBlocks) + return _internal_vecblocks().Get(index); +} +inline ::stream::VectorDataBlock* LayerDataBlock::add_vecblocks() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::VectorDataBlock* _add = _internal_mutable_vecblocks()->Add(); + // @@protoc_insertion_point(field_add:stream.LayerDataBlock.vecBlocks) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::VectorDataBlock >& +LayerDataBlock::vecblocks() const { + // @@protoc_insertion_point(field_list:stream.LayerDataBlock.vecBlocks) + return _internal_vecblocks(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::VectorDataBlock>& +LayerDataBlock::_internal_vecblocks() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.vecblocks_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::VectorDataBlock>* +LayerDataBlock::_internal_mutable_vecblocks() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.vecblocks_; +} + +// repeated .stream.ChainDataBlock chainBlocks = 5; +inline int LayerDataBlock::_internal_chainblocks_size() const { + return _internal_chainblocks().size(); +} +inline int LayerDataBlock::chainblocks_size() const { + return _internal_chainblocks_size(); +} +inline void LayerDataBlock::clear_chainblocks() { + _internal_mutable_chainblocks()->Clear(); +} +inline ::stream::ChainDataBlock* LayerDataBlock::mutable_chainblocks(int index) { + // @@protoc_insertion_point(field_mutable:stream.LayerDataBlock.chainBlocks) + return _internal_mutable_chainblocks()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::ChainDataBlock >* +LayerDataBlock::mutable_chainblocks() { + // @@protoc_insertion_point(field_mutable_list:stream.LayerDataBlock.chainBlocks) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_chainblocks(); +} +inline const ::stream::ChainDataBlock& LayerDataBlock::chainblocks(int index) const { + // @@protoc_insertion_point(field_get:stream.LayerDataBlock.chainBlocks) + return _internal_chainblocks().Get(index); +} +inline ::stream::ChainDataBlock* LayerDataBlock::add_chainblocks() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::ChainDataBlock* _add = _internal_mutable_chainblocks()->Add(); + // @@protoc_insertion_point(field_add:stream.LayerDataBlock.chainBlocks) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::ChainDataBlock >& +LayerDataBlock::chainblocks() const { + // @@protoc_insertion_point(field_list:stream.LayerDataBlock.chainBlocks) + return _internal_chainblocks(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::ChainDataBlock>& +LayerDataBlock::_internal_chainblocks() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.chainblocks_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::ChainDataBlock>* +LayerDataBlock::_internal_mutable_chainblocks() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.chainblocks_; +} + +// uint32 order = 6; +inline void LayerDataBlock::clear_order() { + _impl_.order_ = 0u; +} +inline ::uint32_t LayerDataBlock::order() const { + // @@protoc_insertion_point(field_get:stream.LayerDataBlock.order) + return _internal_order(); +} +inline void LayerDataBlock::set_order(::uint32_t value) { + _internal_set_order(value); + // @@protoc_insertion_point(field_set:stream.LayerDataBlock.order) +} +inline ::uint32_t LayerDataBlock::_internal_order() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.order_; +} +inline void LayerDataBlock::_internal_set_order(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.order_ = value; +} + +// ------------------------------------------------------------------- + +// VectorDataBlock + +// float startX = 1; +inline void VectorDataBlock::clear_startx() { + _impl_.startx_ = 0; +} +inline float VectorDataBlock::startx() const { + // @@protoc_insertion_point(field_get:stream.VectorDataBlock.startX) + return _internal_startx(); +} +inline void VectorDataBlock::set_startx(float value) { + _internal_set_startx(value); + // @@protoc_insertion_point(field_set:stream.VectorDataBlock.startX) +} +inline float VectorDataBlock::_internal_startx() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.startx_; +} +inline void VectorDataBlock::_internal_set_startx(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.startx_ = value; +} + +// float startY = 2; +inline void VectorDataBlock::clear_starty() { + _impl_.starty_ = 0; +} +inline float VectorDataBlock::starty() const { + // @@protoc_insertion_point(field_get:stream.VectorDataBlock.startY) + return _internal_starty(); +} +inline void VectorDataBlock::set_starty(float value) { + _internal_set_starty(value); + // @@protoc_insertion_point(field_set:stream.VectorDataBlock.startY) +} +inline float VectorDataBlock::_internal_starty() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.starty_; +} +inline void VectorDataBlock::_internal_set_starty(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.starty_ = value; +} + +// float endX = 3; +inline void VectorDataBlock::clear_endx() { + _impl_.endx_ = 0; +} +inline float VectorDataBlock::endx() const { + // @@protoc_insertion_point(field_get:stream.VectorDataBlock.endX) + return _internal_endx(); +} +inline void VectorDataBlock::set_endx(float value) { + _internal_set_endx(value); + // @@protoc_insertion_point(field_set:stream.VectorDataBlock.endX) +} +inline float VectorDataBlock::_internal_endx() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.endx_; +} +inline void VectorDataBlock::_internal_set_endx(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.endx_ = value; +} + +// float endY = 4; +inline void VectorDataBlock::clear_endy() { + _impl_.endy_ = 0; +} +inline float VectorDataBlock::endy() const { + // @@protoc_insertion_point(field_get:stream.VectorDataBlock.endY) + return _internal_endy(); +} +inline void VectorDataBlock::set_endy(float value) { + _internal_set_endy(value); + // @@protoc_insertion_point(field_set:stream.VectorDataBlock.endY) +} +inline float VectorDataBlock::_internal_endy() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.endy_; +} +inline void VectorDataBlock::_internal_set_endy(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.endy_ = value; +} + +// ------------------------------------------------------------------- + +// ChainDataBlock + +// uint32 dotNum = 1; +inline void ChainDataBlock::clear_dotnum() { + _impl_.dotnum_ = 0u; +} +inline ::uint32_t ChainDataBlock::dotnum() const { + // @@protoc_insertion_point(field_get:stream.ChainDataBlock.dotNum) + return _internal_dotnum(); +} +inline void ChainDataBlock::set_dotnum(::uint32_t value) { + _internal_set_dotnum(value); + // @@protoc_insertion_point(field_set:stream.ChainDataBlock.dotNum) +} +inline ::uint32_t ChainDataBlock::_internal_dotnum() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.dotnum_; +} +inline void ChainDataBlock::_internal_set_dotnum(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.dotnum_ = value; +} + +// repeated .stream.Point pointVec = 2; +inline int ChainDataBlock::_internal_pointvec_size() const { + return _internal_pointvec().size(); +} +inline int ChainDataBlock::pointvec_size() const { + return _internal_pointvec_size(); +} +inline void ChainDataBlock::clear_pointvec() { + _internal_mutable_pointvec()->Clear(); +} +inline ::stream::Point* ChainDataBlock::mutable_pointvec(int index) { + // @@protoc_insertion_point(field_mutable:stream.ChainDataBlock.pointVec) + return _internal_mutable_pointvec()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::Point >* +ChainDataBlock::mutable_pointvec() { + // @@protoc_insertion_point(field_mutable_list:stream.ChainDataBlock.pointVec) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_pointvec(); +} +inline const ::stream::Point& ChainDataBlock::pointvec(int index) const { + // @@protoc_insertion_point(field_get:stream.ChainDataBlock.pointVec) + return _internal_pointvec().Get(index); +} +inline ::stream::Point* ChainDataBlock::add_pointvec() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::Point* _add = _internal_mutable_pointvec()->Add(); + // @@protoc_insertion_point(field_add:stream.ChainDataBlock.pointVec) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::Point >& +ChainDataBlock::pointvec() const { + // @@protoc_insertion_point(field_list:stream.ChainDataBlock.pointVec) + return _internal_pointvec(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::Point>& +ChainDataBlock::_internal_pointvec() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.pointvec_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::Point>* +ChainDataBlock::_internal_mutable_pointvec() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.pointvec_; +} + +// ------------------------------------------------------------------- + +// Point + +// float xPos = 1; +inline void Point::clear_xpos() { + _impl_.xpos_ = 0; +} +inline float Point::xpos() const { + // @@protoc_insertion_point(field_get:stream.Point.xPos) + return _internal_xpos(); +} +inline void Point::set_xpos(float value) { + _internal_set_xpos(value); + // @@protoc_insertion_point(field_set:stream.Point.xPos) +} +inline float Point::_internal_xpos() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xpos_; +} +inline void Point::_internal_set_xpos(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xpos_ = value; +} + +// float yPos = 2; +inline void Point::clear_ypos() { + _impl_.ypos_ = 0; +} +inline float Point::ypos() const { + // @@protoc_insertion_point(field_get:stream.Point.yPos) + return _internal_ypos(); +} +inline void Point::set_ypos(float value) { + _internal_set_ypos(value); + // @@protoc_insertion_point(field_set:stream.Point.yPos) +} +inline float Point::_internal_ypos() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ypos_; +} +inline void Point::_internal_set_ypos(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ypos_ = value; +} + +// ------------------------------------------------------------------- + +// RegResponce + +// int32 data = 1; +inline void RegResponce::clear_data() { + _impl_.data_ = 0; +} +inline ::int32_t RegResponce::data() const { + // @@protoc_insertion_point(field_get:stream.RegResponce.data) + return _internal_data(); +} +inline void RegResponce::set_data(::int32_t value) { + _internal_set_data(value); + // @@protoc_insertion_point(field_set:stream.RegResponce.data) +} +inline ::int32_t RegResponce::_internal_data() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.data_; +} +inline void RegResponce::_internal_set_data(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.data_ = value; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ diff --git a/TestClient/protobuf/stream.proto b/TestClient/protobuf/stream.proto index 0efa1bc..81941a8 100644 --- a/TestClient/protobuf/stream.proto +++ b/TestClient/protobuf/stream.proto @@ -1,8 +1,11 @@ //bytes替代string 防止乱码 syntax = "proto3"; + +import "google/protobuf/any.proto"; package stream; + //ption cc_generic_services = true; option java_multiple_files = true; option java_package = "io.grpc.examples.stream"; @@ -19,9 +22,12 @@ enum TYPE{ iSTRING = 6; } +/*==================begin 通用通信结构体====================*/ + message ParamInfo{ bytes nameKey = 1; //参数key bytes strValue = 2; //value + //bool isOutput = 2; //是否只读 TYPE valueType = 3; //数据类型 } @@ -39,9 +45,67 @@ message ResponseInfo { repeated ParamInfo item = 3; //参数值 } +/*==================end 通用通信结构体====================*/ + +message ResponseAny{ + google.protobuf.Any data = 1; +} + +/*==================begin h3d图层结构体===================*/ +message LayerData{ + + float zCooldinate = 1; // Z 坐标 : Float 单位 mm + float powder = 2; // 供粉量: Float 单位 mm + float layerThickness = 3; //层厚 + //LayerSummary layerSummary = 3; // 层统计区() : Struct + //uint32 layerBlock = 5; //层块数 决定多少个层块数据库 + repeated LayerDataBlock layerDataBlock = 4; //层块数据区 + + bool result = 5; //是否ok +} + + +message LayerDataBlock +{ + int32 elementId = 1; // 零件 ID : Int32 + int32 elementParamId = 2; // 零件参数 ID : Int32 + //DataBlockSummary dbSummary = 3; //块统计区 : Struct + //uint32 blockNum = 4; // 块数据数: Uint32 //决定有多少个块数据区 + + uint32 blockType = 3; // 块类型: Char //1 代表向量型数据块，3 代表链型数据块 + repeated VectorDataBlock vecBlocks= 4; //块数据区 向量型 + repeated ChainDataBlock chainBlocks = 5; //块数据区 链型 + uint32 order = 6; +} + + +message VectorDataBlock{ + float startX = 1; // 始点 X 位置 : Float //单位 mm + float startY=2; // 始点 Y 位置 : Float //单位 mm + float endX = 3; // 终点 X 位置 : Float //单位 mm + float endY = 4; // 终点 Y 位置 : Float //单位 mm +} + + +message ChainDataBlock +{ + uint32 dotNum = 1; // 点数:Uint32 //决定有多少个点区 + repeated Point pointVec = 2; // 点区 +} + +message Point{ + float xPos = 1; // X 位置 : Float //单位 mm + float yPos = 2; // Y 位置 : Float //单位 mm +} + +//注册功能返回信息 +message RegResponce{ + int32 data = 1; +} + service Stream { - rpc Simple(RequestInfo) returns (ResponseInfo) {} // 简单模式 + rpc Simple(RequestInfo) returns (ResponseAny) {} // 简单模式 rpc ServerStream (RequestInfo) returns (stream ResponseInfo) {} // 服务端数据流模式 rpc ClientStream (stream RequestInfo) returns (ResponseInfo) {} // 客户端数据流模式 rpc AllStream (stream RequestInfo) returns (stream ResponseInfo) {} // 双向数据流模式