From f2f5f4adb4ae1950c3a7fa8d45916a09640fb631 Mon Sep 17 00:00:00 2001 From: wangxx1809 Date: Thu, 27 Jun 2024 10:56:50 +0800 Subject: [PATCH] =?UTF-8?q?=E9=85=8D=E7=BD=AE=E4=BF=A1=E6=81=AF=E4=BC=A0?= =?UTF-8?q?=E8=BE=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- PrintS/Config/ConfigManager.cpp | 86 +- PrintS/Config/ConfigManager.h | 3 +- PrintS/Config/bean/CorrectParamCfg.cpp | 40 +- PrintS/Config/bean/CorrectParamCfg.h | 39 +- PrintS/Config/bean/FixPointCfg.cpp | 10 +- PrintS/Config/bean/FixPointCfg.h | 4 +- PrintS/Config/bean/PowerCompensate.cpp | 11 +- PrintS/Config/bean/PowerCompensate.h | 4 +- PrintS/Config/bean/ScanParamCfg.cpp | 37 +- PrintS/Config/bean/ScanParamCfg.h | 4 +- PrintS/Config/bean/ScanTestCfg.cpp | 31 +- PrintS/Config/bean/ScanTestCfg.h | 6 +- PrintS/Config/bean/ScannerControlCfg.cpp | 24 +- PrintS/Config/bean/ScannerControlCfg.h | 25 +- PrintS/Config/bean/SkyWritingCfg.cpp | 24 +- PrintS/Config/bean/SkyWritingCfg.h | 5 +- PrintS/Config/bean/TimePowerCompensate.cpp | 9 +- PrintS/Config/bean/TimePowerCompensate.h | 5 +- PrintS/Config/dao/ScannerControlCfgDao.cpp | 64 +- PrintS/DataManage/DataHandle.cpp | 3 + PrintS/DataManage/RWData.h | 33 +- PrintS/DataManage/StreamServer.cpp | 32 +- PrintS/ScannerCtrl/RTC5Scanner.cpp | 76 +- PrintS/ScannerCtrl/Scanner.cpp | 20 +- PrintS/ScannerCtrl/ScannerCtrl.cpp | 34 +- PrintS/additional/Calibration.cpp | 4 +- PrintS/job/H3DFileProcessor.cpp | 6 +- PrintS/job/JobMetaData.cpp | 6 +- PrintS/job/MetaData.cpp | 2 +- PrintS/output/Release/log/2024.hbd | Bin 172032 -> 176128 bytes PrintS/protobuf/stream.pb.cc | 6320 +++++++++++++++++- PrintS/protobuf/stream.pb.h | 6909 +++++++++++++++++++- PrintS/protobuf/stream.proto | 174 + TestClient/DataManage/DataHandle.cpp | 102 +- TestClient/DataManage/DataHandle.h | 4 +- TestClient/DataManage/RWData.h | 13 + TestClient/DataManage/StreamClient.cpp | 5 +- TestClient/protobuf/stream.pb.cc | 6320 +++++++++++++++++- TestClient/protobuf/stream.pb.h | 6909 +++++++++++++++++++- TestClient/protobuf/stream.proto | 173 +- 40 files changed, 27187 insertions(+), 389 deletions(-) diff --git a/PrintS/Config/ConfigManager.cpp b/PrintS/Config/ConfigManager.cpp index 5ce60af..5bc8622 100644 --- a/PrintS/Config/ConfigManager.cpp +++ b/PrintS/Config/ConfigManager.cpp @@ -492,13 +492,6 @@ void ConfigManager::SendCfgToClients() { SendAlarmCfg(); SendPowderCfg(); - - //int index = 0; - //auto item = m_ScannerControlCfgDao->m_ScannerControlCfgMap.begin(); - //while (item != m_ScannerControlCfgDao->m_ScannerControlCfgMap.end()) { - // //item->second->SendToClients(); - // ++item; - //} m_MoldCfg->SendToClients(MOLDCFGPARAM); m_LoadCfg->SendToClients(LOADCFGPARAM); @@ -532,42 +525,60 @@ void ConfigManager::CallFuncs(const ReadData& rd, const list& lst, ::strea RedTestCfgStart(); break; case REDTESTCFGSTOP: RedTestCfgStop(); break; - //case FIXPOINTDAOADD: - // FixPointDaoAdd(lst); break; - //case FIXPOINTDAODEL: - // FixPointDaoDel(lst); break; default: break; } - + +} + + +void ConfigManager::ScanerCtrlCfgReq(const ReadData& rd, const list& lst, ::stream::ResponseAny** response) { + + stream::ScannerCrtlCfgResp result; + auto start = m_ScannerControlCfgDao->m_ScannerControlCfgMap.begin(); + while(start != m_ScannerControlCfgDao->m_ScannerControlCfgMap.end()) { + ::stream::ScannerCrtlCfgData* sccfg = result.add_scannercfg(); + start->second->SetScannerCtrlCfg(sccfg); + + auto fpitem = start->second->m_FixPointWrapper.m_Cfgs.begin(); + while (fpitem != start->second->m_FixPointWrapper.m_Cfgs.end()) { + (*fpitem)->SetFixPointCfg(sccfg->add_fixpointdata()); + ++fpitem; + } + + start->second->m_ScanCfgWrapper.m_ScanParamCfg.SetScanParam(sccfg->mutable_scanparamcfg()); + start->second->m_ScanCfgWrapper.m_HatchingParams.SetScanParam(sccfg->mutable_hatchingparams()); + start->second->m_ScanCfgWrapper.m_BorderParams.SetScanParam(sccfg->mutable_borderparams()); + start->second->m_ScanCfgWrapper.m_SupportParams.SetScanParam(sccfg->mutable_supportparams()); + start->second->m_ScanCfgWrapper.m_CorrectParamCfg.SetCorrectCfg(sccfg->mutable_correctparamcfg()); + start->second->m_ScanCfgWrapper.m_ScanTestCfg.SetScanTestCfg(sccfg->mutable_scantestcfg()); + start->second->m_ScanCfgWrapper.m_SkyWritingCfg.SetSkyWritingCfg(sccfg->mutable_skywritingcfg()); + + auto pcs = start->second->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.begin(); + while (pcs != start->second->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.end()) { + (*pcs)->SetPowerComp(sccfg->add_powercompensate()); + ++pcs; + } + + auto tpcs = start->second->m_ScanCfgWrapper.m_TimePowerCompensateCfg.m_TimePowerCompensates.begin(); + while (tpcs != start->second->m_ScanCfgWrapper.m_TimePowerCompensateCfg.m_TimePowerCompensates.end()) { + (*tpcs)->SetTimePowerComp(sccfg->add_tpowercompensate()); + ++tpcs; + } + + ++start; + } + + (*response)->mutable_data()->PackFrom(result); } -//void ConfigManager::FixPointDaoAdd(const list& lst) { -// int scannerIndex = -1; -// FixPointCfg* fpc = new FixPointCfg(); -// for (auto it = lst.begin(); it != lst.end(); ++it) { -// if (it->nameKey == "index") scannerIndex = ConverType::TryToI(it->strValue); -// if (it->nameKey == "cno") fpc->m_Cno = ConverType::TryToI(it->strValue); -// if (it->nameKey == "pointX") fpc->m_PointX = ConverType::TryToF(it->strValue); -// if (it->nameKey == "pointY") fpc->m_PointY = ConverType::TryToF(it->strValue); -// if (it->nameKey == "duration") fpc->m_Duration = (unsigned int)ConverType::TryToI(it->strValue); -// } -// -// //if (GetFixPointDao()->Add(fpc)){ -// // (*m_UIController.m_ScannerCtrl->GetScanners())[scannerIndex]->GetConfig()->m_FixPointWrapper.m_Cfgs->push_back(fpc); -// //} -//} -// -//void ConfigManager::FixPointDaoDel(const list& lst) { -// -//} void ConfigManager::SendAlarmCfg() { list lst; auto start = m_AlarmCfgWrapper->m_StopAlarmCfgMap.begin(); while (start != m_AlarmCfgWrapper->m_StopAlarmCfgMap.end()) { - lst.emplace_back(Item{ start->first,"",UNKNOW,(*start).second->m_Content, (*start).second->m_IsEnable, + lst.emplace_back(Item{ start->first,(*start).second->m_Content, (*start).second->m_IsEnable, (*start).second->m_IsAlarm, (*start).second->m_IsShow }); ++start; } @@ -576,7 +587,7 @@ void ConfigManager::SendAlarmCfg() { lst.clear(); start = m_AlarmCfgWrapper->m_PauseAlarmCfgMap.begin(); while (start != m_AlarmCfgWrapper->m_PauseAlarmCfgMap.end()) { - lst.emplace_back(Item{ start->first,"",UNKNOW,(*start).second->m_Content, (*start).second->m_IsEnable, + lst.emplace_back(Item{ start->first,(*start).second->m_Content, (*start).second->m_IsEnable, (*start).second->m_IsAlarm, (*start).second->m_IsShow }); ++start; } @@ -585,7 +596,7 @@ void ConfigManager::SendAlarmCfg() { lst.clear(); start = m_AlarmCfgWrapper->m_WarnAlarmCfgMap.begin(); while (start != m_AlarmCfgWrapper->m_WarnAlarmCfgMap.end()) { - lst.emplace_back(Item{ start->first,"",UNKNOW,(*start).second->m_Content, (*start).second->m_IsEnable, + lst.emplace_back(Item{ start->first,(*start).second->m_Content, (*start).second->m_IsEnable, (*start).second->m_IsAlarm, (*start).second->m_IsShow }); ++start; } @@ -602,14 +613,14 @@ void ConfigManager::SendPowderCfg() { m_ParamSetCfg.GetPowderCfg(vec); auto powderStart = vec.begin(); while (powderStart != vec.end()) { - lst.emplace_back(Item{ "","",UNKNOW,"", 0,0,0, - powderStart->start_layer,powderStart->end_layer,powderStart->powder }); + lst.emplace_back(Item{powderStart->start_layer,powderStart->end_layer,powderStart->powder }); ++powderStart; } ClientWrapper::Instance()->PushAllClient(WriteData(POWDERSETPARAM, lst)); } + void ConfigManager::UpdateCfg(const ReadData& rd) { switch (rd.dataType) @@ -666,9 +677,9 @@ void ConfigManager::UpdateCommunicationCfg(const ReadData& rd) { printf("not find this [%s] param\n", rd.nameKey.data()); } - } + void ConfigManager::ControlRun(const list& its) { bool enable = false; string code; @@ -678,7 +689,6 @@ void ConfigManager::ControlRun(const list& its) { if (item->nameKey == "code") code = item->strValue; } - CommunicationCfg* cCfg = nullptr; if (m_pCommunicationCfgDao->GetCommunicationCfg()->find(code) != m_pCommunicationCfgDao->GetCommunicationCfg()->end()) { cCfg = (*m_pCommunicationCfgDao->GetCommunicationCfg())[code]; diff --git a/PrintS/Config/ConfigManager.h b/PrintS/Config/ConfigManager.h index a031b88..7e94421 100644 --- a/PrintS/Config/ConfigManager.h +++ b/PrintS/Config/ConfigManager.h @@ -106,7 +106,7 @@ public: ParamSetCfg* GetParamSetCfg() { return &m_ParamSetCfg; } //已传 //map* GetLaserCfgMap() { return &m_pLaserCfgDao->m_LaserCfgMap; } //vector* GetLaserCfgs() { return &m_pLaserCfgDao->m_LaserCfgs; } - map* GetScannerControlCfg() { return &m_ScannerControlCfgDao->m_ScannerControlCfgMap; } //传 + map* GetScannerControlCfg() { return &m_ScannerControlCfgDao->m_ScannerControlCfgMap; } //已传 ScanerCtrlCfgReq发送 vector* GetScannerControlCfgs() { return &m_ScannerControlCfgDao->m_ScannerControlCfgs; } //不传 vector* GetMatchScannerControlCfg() { return &m_ScannerControlCfgDao->m_MatchCfg; } //添加2个函数 已传 ScannerControlCfgDao* GetScannerControlCfgDao() { return m_ScannerControlCfgDao; } //不用 @@ -137,6 +137,7 @@ public: void SendCfgToClients(); void UpdateCfg(const ReadData& rd); void CallFuncs(const ReadData& rd, const list& lst = list(), ::stream::ResponseAny** response = nullptr); + void ScanerCtrlCfgReq(const ReadData& rd, const list& lst, ::stream::ResponseAny** response); // private: ConfigManager(const ConfigManager&) {}; ConfigManager& operator=(const ConfigManager&) {}; diff --git a/PrintS/Config/bean/CorrectParamCfg.cpp b/PrintS/Config/bean/CorrectParamCfg.cpp index fcccfb7..8f88cb4 100644 --- a/PrintS/Config/bean/CorrectParamCfg.cpp +++ b/PrintS/Config/bean/CorrectParamCfg.cpp @@ -1,4 +1,4 @@ -#include "CorrectParamCfg.h" +#include "CorrectParamCfg.h" #include "ScanCfg.h" @@ -41,8 +41,8 @@ CorrectParamCfg::CorrectParamCfg() m_FactorK=1824.0; m_IsCorrectFile3D = true; //m_DownSkinStopTimes = 0; - m_IsDynamicFocus = true; //Ƿ̬۽ - m_DefocusRatio = 10.0; //뽹 + m_IsDynamicFocus = true; //是否动态聚焦 + m_DefocusRatio = 10.0; //离焦比 m_DefocusRatioMin = 0.0; m_DefocusRatioMax = 50.0; } @@ -110,6 +110,40 @@ void CorrectParamCfg::GetUpdateSql(int cno,vector& ups) { ups.push_back(buffer); } +void CorrectParamCfg::SetCorrectCfg(stream::CorrectParamCfg* cp) { + cp->set_xmeasuremin(m_xmeasure_min); + cp->set_xmeasuremax(m_xmeasure_max); + cp->set_ymeasuremin(m_ymeasure_min); + cp->set_ymeasuremax(m_ymeasure_max); + cp->set_xposfix(m_xposfix); + cp->set_yposfix(m_yposfix); + + cp->set_scanangle(m_scan_angle); + cp->set_scananglemin(m_scan_angle_min); + cp->set_scananglemax(m_scan_angle_max); + cp->set_fixanglemax(m_fix_angle); + cp->set_fixanglemin(m_fix_angle_min); + cp->set_fixanglemax(m_fix_angle_max); + + cp->set_xcorrect(m_xcorrect); + cp->set_ycorrect(m_ycorrect); + cp->set_xcorrectmin(m_xcorrect_min); + cp->set_xcorrectmax(m_xcorrect_max); + cp->set_ycorrectmin(m_ycorrect_min); + cp->set_ycorrectmax(m_ycorrect_max); + + cp->set_realxoffset(m_realXOffset); + cp->set_realyoffset(m_realYOffset); + cp->set_factork(m_FactorK); + cp->set_iscorrectfile3d(m_IsCorrectFile3D); + cp->set_isdynamicfocus(m_IsDynamicFocus); + + cp->set_defocusratio(m_DefocusRatio); + cp->set_defocusratiomin(m_DefocusRatioMin); + cp->set_defocusratiomax(m_DefocusRatioMax); + +} + string CorrectParamCfg::CONFIG_NAME = "CorrectParamCfg"; string CorrectParamCfg::FIELD_X_MEASURE_MIN = "XMeasureMin"; string CorrectParamCfg::FIELD_X_MEASURE_MAX = "XMeasureMax"; diff --git a/PrintS/Config/bean/CorrectParamCfg.h b/PrintS/Config/bean/CorrectParamCfg.h index 0852c9b..3864c56 100644 --- a/PrintS/Config/bean/CorrectParamCfg.h +++ b/PrintS/Config/bean/CorrectParamCfg.h @@ -1,6 +1,7 @@ -#pragma once +#pragma once #include #include +#include "../protobuf/stream.pb.h" using namespace std; class CorrectParamCfg @@ -9,40 +10,42 @@ public: CorrectParamCfg(); ~CorrectParamCfg(); void GetUpdateSql(int cno,vector& ups); + + void SetCorrectCfg(stream::CorrectParamCfg* cp); public: - double m_xmeasure_min; //xɴӡСλ - double m_xmeasure_max; //xɴӡλ - double m_ymeasure_min; //yɴӡСλ - double m_ymeasure_max; //yɴӡλ - double m_xposfix; //xλ - double m_yposfix; //yλ - //double m_xoffset; //xλƫ - //double m_yoffset; //yλƫ - double m_scan_angle; //תǶ ʱ + double m_xmeasure_min; //x可打印最小位置 + double m_xmeasure_max; //x可打印最大位置 + double m_ymeasure_min; //y可打印最小位置 + double m_ymeasure_max; //y可打印最大位置 + double m_xposfix; //x位置修正 + double m_yposfix; //y位置修正 + //double m_xoffset; //x位置偏移 不保存 + //double m_yoffset; //y位置偏移 不保存 + double m_scan_angle; //旋转角度 逆时针 double m_scan_angle_min; double m_scan_angle_max; - double m_fix_angle; //תǶ ʱ + double m_fix_angle; //旋转角度 逆时针 double m_fix_angle_min; double m_fix_angle_max; - double m_xcorrect; //xߴ - double m_ycorrect; //yߴ + double m_xcorrect; //x尺寸修正 + double m_ycorrect; //y尺寸修正 double m_xcorrect_min; double m_xcorrect_max; double m_ycorrect_min; double m_ycorrect_max; - //double m_xscale; //xű + //double m_xscale; //x缩放比例 不保存 //double m_xscale_min; //double m_xscale_max; - //double m_yscale; //yű + //double m_yscale; //y缩放比例 不保存 //double m_yscale_min; //double m_yscale_max; double m_realXOffset; double m_realYOffset; double m_FactorK; bool m_IsCorrectFile3D; - //unsigned int m_DownSkinStopTimes; //±ֹͣ - bool m_IsDynamicFocus; //Ƿ̬۽ - double m_DefocusRatio; //뽹 + //unsigned int m_DownSkinStopTimes; //下表面停止次数 + bool m_IsDynamicFocus; //是否动态聚焦 + double m_DefocusRatio; //离焦比 double m_DefocusRatioMin; double m_DefocusRatioMax; diff --git a/PrintS/Config/bean/FixPointCfg.cpp b/PrintS/Config/bean/FixPointCfg.cpp index 0f429d6..6047d79 100644 --- a/PrintS/Config/bean/FixPointCfg.cpp +++ b/PrintS/Config/bean/FixPointCfg.cpp @@ -1,4 +1,4 @@ -#include "FixPointCfg.h" +#include "FixPointCfg.h" @@ -19,6 +19,14 @@ string FixPointCfg::GetUpdateSql() return buffer; } +void FixPointCfg::SetFixPointCfg(stream::FixPointData* fp) { + fp->set_cno(m_Cno); + fp->set_duration(m_Duration); + fp->set_id(m_Id); + fp->set_pointx(m_PointX); + fp->set_pointy(m_PointY); +} + const string FixPointCfg::TABLE_NAME="FixPoints"; const string FixPointCfg::FIELD_ID="Id"; const string FixPointCfg::FIELD_CNO = "Cno"; diff --git a/PrintS/Config/bean/FixPointCfg.h b/PrintS/Config/bean/FixPointCfg.h index 1d97823..7a406b6 100644 --- a/PrintS/Config/bean/FixPointCfg.h +++ b/PrintS/Config/bean/FixPointCfg.h @@ -1,8 +1,9 @@ -#pragma once +#pragma once #include #include #include #include +#include "../protobuf/stream.pb.h" using namespace std; class FixPointCfg @@ -11,6 +12,7 @@ public: FixPointCfg(); ~FixPointCfg(); string GetUpdateSql(); + void SetFixPointCfg(stream::FixPointData* sp); public: int m_Id; int m_Cno; diff --git a/PrintS/Config/bean/PowerCompensate.cpp b/PrintS/Config/bean/PowerCompensate.cpp index f832a78..2eff2c1 100644 --- a/PrintS/Config/bean/PowerCompensate.cpp +++ b/PrintS/Config/bean/PowerCompensate.cpp @@ -1,4 +1,4 @@ -#include "PowerCompensate.h" +#include "PowerCompensate.h" @@ -33,6 +33,15 @@ void PowerCompensate::Generate(int cno,vector& ins) } } +void PowerCompensate::SetPowerComp(stream::PowerCompensate* cp) { + cp->set_cno(m_cno); + cp->set_percent(m_percent); + cp->set_value(m_value); + cp->set_value_min(m_value_min); + cp->set_value_max(m_value_max); + +} + const string PowerCompensate::TABLE_NAME="PowerCompensate"; const string PowerCompensate::FIELD_CNO = "cno"; diff --git a/PrintS/Config/bean/PowerCompensate.h b/PrintS/Config/bean/PowerCompensate.h index f9ed3c3..44da056 100644 --- a/PrintS/Config/bean/PowerCompensate.h +++ b/PrintS/Config/bean/PowerCompensate.h @@ -1,6 +1,7 @@ -#pragma once +#pragma once #include #include +#include "../protobuf/stream.pb.h" using namespace std; class PowerCompensate @@ -9,6 +10,7 @@ public: PowerCompensate(); ~PowerCompensate(); static void Generate(int cno,vector& ins); + void SetPowerComp(stream::PowerCompensate* cp); public: int m_cno; unsigned short m_percent; diff --git a/PrintS/Config/bean/ScanParamCfg.cpp b/PrintS/Config/bean/ScanParamCfg.cpp index 46595af..54530e2 100644 --- a/PrintS/Config/bean/ScanParamCfg.cpp +++ b/PrintS/Config/bean/ScanParamCfg.cpp @@ -1,4 +1,4 @@ -#include "ScanParamCfg.h" +#include "ScanParamCfg.h" #include "ScanCfg.h" #include "../../utils/StringHelper.h" @@ -92,6 +92,41 @@ void ScanParamCfg::GetUpdateSql(int cno,vector& ups) } +void ScanParamCfg::SetScanParam(stream::ScanParamCfg* sp) { + sp->set_edgelevel(m_edge_level); + sp->set_edgelevelmin( m_edge_level_min); + sp->set_edgelevelmax( m_edge_level_max); + sp->set_jumpdelay( m_jump_delay); + sp->set_jumpdelaymin( m_jump_delay_min); + sp->set_jumpdelaymax( m_jump_delay_max); + sp->set_scandelay( m_scan_delay); + sp->set_scandelaymin( m_scan_delay_min); + sp->set_scandelaymax( m_scan_delay_max); + sp->set_polygondelay( m_polygon_delay); + sp->set_polygondelaymin( m_polygon_delay_min); + sp->set_polygondelaymax( m_polygon_delay_max); + sp->set_laseroffdelay( m_laseroff_delay); + sp->set_laseroffdelaymin( m_laseroff_delay_min); + sp->set_laseroffdelaymax( m_laseroff_delay_max); + sp->set_laserondelay( m_laseron_delay); + sp->set_laserondelaymin( m_laseron_delay_min); + sp->set_laserondelaymax( m_laseron_delay_max); + sp->set_minjumpdelay( m_min_jump_delay); + sp->set_minjumpdelaymin( m_min_jump_delay_min); + sp->set_minjumpdelaymax( m_min_jump_delay_max); + sp->set_jumplengthlimit( m_jump_length_limit); + sp->set_jumplengthlimitmin( m_jump_length_limit_min); + sp->set_jumplengthlimitmax( m_jump_length_limit_max); + sp->set_jumpspeed( m_jump_speed); + sp->set_jumpspeedmin( m_jump_speed_min); + sp->set_jumpspeedmax( m_jump_speed_max); + sp->set_markspeed( m_mark_speed); + sp->set_markspeedmin( m_mark_speed_min); + sp->set_markspeedmax( m_polygon_delay_max); + +} + + //string ScanParamCfg::CONFIG_NAME = "ScanParamCfg"; string ScanParamCfg::FIELD_EDGE_LEVEL = "EdgeLevel"; string ScanParamCfg::FIELD_EDGE_LEVEL_MIN = "EdgeLevelMin"; diff --git a/PrintS/Config/bean/ScanParamCfg.h b/PrintS/Config/bean/ScanParamCfg.h index e1af2f3..deec20a 100644 --- a/PrintS/Config/bean/ScanParamCfg.h +++ b/PrintS/Config/bean/ScanParamCfg.h @@ -1,6 +1,7 @@ -#pragma once +#pragma once #include #include +#include "../protobuf/stream.pb.h" using namespace std; class ScanParamCfg { @@ -9,6 +10,7 @@ public: ~ScanParamCfg(); void GetUpdateSql(int cno,vector& ups); + void SetScanParam(stream::ScanParamCfg* sp); public: string CONFIG_NAME; static string FIELD_EDGE_LEVEL; diff --git a/PrintS/Config/bean/ScanTestCfg.cpp b/PrintS/Config/bean/ScanTestCfg.cpp index 4d92fea..a8b03c8 100644 --- a/PrintS/Config/bean/ScanTestCfg.cpp +++ b/PrintS/Config/bean/ScanTestCfg.cpp @@ -1,4 +1,4 @@ -#include "ScanTestCfg.h" +#include "ScanTestCfg.h" #include "ScanCfg.h" #include "../../utils/StringHelper.h" @@ -90,6 +90,35 @@ void ScanTestCfg::GetUpdateSql(int cno,vector& ups) } +void ScanTestCfg::SetScanTestCfg(stream::ScanTestCfg* cp) { + cp->set_debugshape(m_debug_shape); + cp->set_shapesize(m_shape_size); + cp->set_shapesizemin(m_shape_size_min); + cp->set_shape_size_max(m_shape_size_max); + cp->set_laser_power(m_laser_power); + cp->set_laser_power_min(m_laser_power_min); + cp->set_laser_power_max(m_laser_power_max); + + cp->set_defocus(m_defocus); + cp->set_defocus_min(m_defocus_min); + cp->set_defocus_max(m_defocus_max); + cp->set_is_cycle(m_is_cycle); + cp->set_cross_x(m_cross_x); + cp->set_cross_y(m_cross_y); + + cp->set_z_distance(m_z_distance); + cp->set_isautoheatingscanner(m_IsAutoHeatingScanner); + cp->set_autoheatingscannerminutes(m_AutoHeatingScannerMinutes); + cp->set_autoheatingscannersize(m_AutoHeatingScannerSize); + cp->set_autoheatingscannerspeed(m_AutoHeatingScannerSpeed); + + cp->set_mark_test_start_x(m_mark_test_start_x); + cp->set_mark_test_start_y(m_mark_test_start_y); + cp->set_mark_test_end_x(m_mark_test_end_x); + cp->set_mark_test_end_y(m_mark_test_end_y); + +} + string ScanTestCfg::CONFIG_NAME="ScanTest"; string ScanTestCfg::FIELD_DEBUG_SHAPE = "DebugShape"; string ScanTestCfg::FIELD_SHAPE_SIZE = "ShapeSize"; diff --git a/PrintS/Config/bean/ScanTestCfg.h b/PrintS/Config/bean/ScanTestCfg.h index a8bc172..9915ab0 100644 --- a/PrintS/Config/bean/ScanTestCfg.h +++ b/PrintS/Config/bean/ScanTestCfg.h @@ -1,6 +1,7 @@ -#pragma once +#pragma once #include #include +#include "../protobuf/stream.pb.h" using namespace std; class ScanTestCfg @@ -10,6 +11,7 @@ public: ~ScanTestCfg(); void GetUpdateSql(int cno,vector& ups); + void SetScanTestCfg(stream::ScanTestCfg* cp); public: int m_debug_shape; int m_shape_size; @@ -27,7 +29,7 @@ public: double m_z_distance; - bool m_IsAutoHeatingScanner; //ͣʼʱԤ + bool m_IsAutoHeatingScanner; //开启暂停开始时预热振镜 unsigned int m_AutoHeatingScannerMinutes; unsigned int m_AutoHeatingScannerSize; double m_AutoHeatingScannerSpeed; diff --git a/PrintS/Config/bean/ScannerControlCfg.cpp b/PrintS/Config/bean/ScannerControlCfg.cpp index f1ce230..31fecc9 100644 --- a/PrintS/Config/bean/ScannerControlCfg.cpp +++ b/PrintS/Config/bean/ScannerControlCfg.cpp @@ -3,8 +3,8 @@ ScannerControlCfg::ScannerControlCfg() - : /*m_Index(new IntData("Index")) - ,*/ m_SeqNo(new IntData("SeqNo")) + /*: m_Index(new IntData("Index")) + , m_SeqNo(new IntData("SeqNo")) , m_ControlNo(new IntData("ControlNo")) , m_SerialNo(new IntData("SerialNo")) , m_ControlType(new IntData("ControlType")) @@ -12,7 +12,7 @@ ScannerControlCfg::ScannerControlCfg() , m_CardIP(new StrData("CardIP")) , m_IsEnable(new BoolData("IsEnable")) , m_HadAssign(new BoolData("HadAssign")) - , m_HadMatch(new BoolData("HadMatch")) + , m_HadMatch(new BoolData("HadMatch"))*/ { } @@ -40,9 +40,9 @@ string ScannerControlCfg::GetUpdateSql() string sql = "UPDATE %s SET %s=%d,%s=%d WHERE %s=%d"; sprintf_s(buffer, sizeof(buffer), "UPDATE %s SET %s=%d,%s=%d WHERE %s=%d", TABLE_NAME.c_str(), - FIELD_CONTROL_NO.c_str(), m_ControlNo->GetValue(), - FIELD_SERIAL_NO.c_str(), m_SerialNo->GetValue(), - FIELD_SEQ_NO.c_str(),m_SeqNo->GetValue()); + FIELD_CONTROL_NO.c_str(), m_ControlNo , + FIELD_SERIAL_NO.c_str(), m_SerialNo , + FIELD_SEQ_NO.c_str(),m_SeqNo ); return buffer; } @@ -58,6 +58,18 @@ ScanParamCfg* ScannerControlCfg::GetScanParamCfg(string str) } } +void ScannerControlCfg::SetScannerCtrlCfg(stream::ScannerCrtlCfgData* sccd) { + sccd->set_seqno(m_SeqNo); + sccd->set_controlno(m_ControlNo); + sccd->set_serialno(m_SerialNo); + sccd->set_controltype(m_ControlType); + sccd->set_cardname(m_CardName); + sccd->set_cardip(m_CardIP); + sccd->set_isenable(m_IsEnable); + sccd->set_hadassign(m_HadAssign); + sccd->set_hadmatch(m_HadMatch); +} + const string ScannerControlCfg::TABLE_NAME="ScannerControlCfg"; const string ScannerControlCfg::FIELD_SEQ_NO="SeqNo"; const string ScannerControlCfg::FIELD_CONTROL_NO="ControlNo"; diff --git a/PrintS/Config/bean/ScannerControlCfg.h b/PrintS/Config/bean/ScannerControlCfg.h index 39e2c08..0dc5700 100644 --- a/PrintS/Config/bean/ScannerControlCfg.h +++ b/PrintS/Config/bean/ScannerControlCfg.h @@ -6,6 +6,8 @@ #include "FixPointCfg.h" #include "IOCfg.h" #include "../Controller/Base.h" +#include "../protobuf/stream.pb.h" + using namespace std; struct CardSerialPair { @@ -23,21 +25,22 @@ public: string GetUpdateSql(); void Init(); ScanParamCfg* GetScanParamCfg(string str); + + void SetScannerCtrlCfg(stream::ScannerCrtlCfgData* ); public: //IntData* m_Index; - IntData* m_SeqNo; //编号 配合ConfigManager中的map - IntData* m_ControlNo; - IntData* m_SerialNo; - IntData* m_ControlType; - StrData* m_CardName; - StrData* m_CardIP; - BoolData* m_IsEnable; //是否启动 - BoolData* m_HadAssign; - BoolData* m_HadMatch; - + int m_SeqNo; //编号 ConfigManager中的m_ScannerControlCfgMap的key + int m_ControlNo; + int m_SerialNo; + int m_ControlType; + string m_CardName; + string m_CardIP; + bool m_IsEnable; //是否启动 + bool m_HadAssign; + bool m_HadMatch; ScanCfgWrapper m_ScanCfgWrapper; - FixPointWrapper m_FixPointWrapper; + FixPointWrapper m_FixPointWrapper; //添加一个函数，不传 IOCfg* m_LaserRed; //不传了 IOCfg* m_LaserEnable; //不传了 diff --git a/PrintS/Config/bean/SkyWritingCfg.cpp b/PrintS/Config/bean/SkyWritingCfg.cpp index e01a2b7..f03691d 100644 --- a/PrintS/Config/bean/SkyWritingCfg.cpp +++ b/PrintS/Config/bean/SkyWritingCfg.cpp @@ -1,4 +1,4 @@ -#include "SkyWritingCfg.h" +#include "SkyWritingCfg.h" #include "ScanCfg.h" @@ -65,6 +65,28 @@ void SkyWritingCfg::GetUpdateSql(int cno,vector& ups) ups.push_back(buffer); } + + +void SkyWritingCfg::SetSkyWritingCfg(stream::SkyWritingCfg * cp) { + cp->set_isenable(m_IsEnable); + cp->set_timelag(m_Timelag); + cp->set_timelagmin(m_TimelagMin); + cp->set_timelagmax(m_TimelagMax); + cp->set_laseronshift(m_LaserOnShift); + cp->set_laseronshiftmin(m_LaserOnShiftMin); + cp->set_laseronshiftmax(m_LaserOnShiftMax); + cp->set_nprev(m_Nprev); + cp->set_nprevmin(m_NprevMin); + cp->set_nprevmax(m_NprevMax); + cp->set_npost(m_Npost); + cp->set_npostmin(m_NpostMin); + cp->set_npostmax(m_NpostMax); + cp->set_mode(m_Mode); + cp->set_limite(m_Limite); + cp->set_limitemin(m_LimiteMin); + cp->set_limitemax(m_LimiteMax); +} + string SkyWritingCfg::CONFIG_NAME = "SkyWriting"; string SkyWritingCfg::FIELD_IS_ENABLE = "is_enable"; string SkyWritingCfg::FIELD_TIMELAG = "timelag"; diff --git a/PrintS/Config/bean/SkyWritingCfg.h b/PrintS/Config/bean/SkyWritingCfg.h index 08e0ab8..b361fbc 100644 --- a/PrintS/Config/bean/SkyWritingCfg.h +++ b/PrintS/Config/bean/SkyWritingCfg.h @@ -1,6 +1,7 @@ -#pragma once +#pragma once #include #include +#include "../protobuf/stream.pb.h" using namespace std; @@ -10,7 +11,7 @@ public: SkyWritingCfg(); ~SkyWritingCfg(); void GetUpdateSql(int cno,vector& ups); - + void SetSkyWritingCfg(stream::SkyWritingCfg* cp); public: bool m_IsEnable; double m_Timelag; diff --git a/PrintS/Config/bean/TimePowerCompensate.cpp b/PrintS/Config/bean/TimePowerCompensate.cpp index 1f98e52..27973ae 100644 --- a/PrintS/Config/bean/TimePowerCompensate.cpp +++ b/PrintS/Config/bean/TimePowerCompensate.cpp @@ -1,4 +1,4 @@ -#include "TimePowerCompensate.h" +#include "TimePowerCompensate.h" @@ -13,6 +13,13 @@ TimePowerCompensate::~TimePowerCompensate() } +void TimePowerCompensate::SetTimePowerComp(stream::TimePowerCompensate* tpc) { + tpc->set_id(m_ID); + tpc->set_cno(m_Cno); + tpc->set_startminute(m_StartMinute); + tpc->set_endminute(m_EndMinute); + tpc->set_compensate(m_Compensate); +} const string TimePowerCompensate::TABLE_NAME="TimePowerCompensate"; const string TimePowerCompensate::FIELD_ID="id"; diff --git a/PrintS/Config/bean/TimePowerCompensate.h b/PrintS/Config/bean/TimePowerCompensate.h index eac7918..653d0d5 100644 --- a/PrintS/Config/bean/TimePowerCompensate.h +++ b/PrintS/Config/bean/TimePowerCompensate.h @@ -1,7 +1,8 @@ -#pragma once +#pragma once #include #include #include +#include "../protobuf/stream.pb.h" using namespace std; class TimePowerCompensate @@ -9,7 +10,7 @@ class TimePowerCompensate public: TimePowerCompensate(); ~TimePowerCompensate(); - + void SetTimePowerComp(stream::TimePowerCompensate* cp); public: int m_ID; int m_Cno; diff --git a/PrintS/Config/dao/ScannerControlCfgDao.cpp b/PrintS/Config/dao/ScannerControlCfgDao.cpp index 71aed4c..7e2df53 100644 --- a/PrintS/Config/dao/ScannerControlCfgDao.cpp +++ b/PrintS/Config/dao/ScannerControlCfgDao.cpp @@ -54,10 +54,10 @@ void ScannerControlCfgDao::Save() ScannerControlCfg* pcfg = m_MatchCfg[i]; if (pcfg == NULL)continue; m_pDB->exec(pcfg->GetUpdateSql()); - m_ScanCfgDao->Save(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper); - m_PowerCompensateDao->Save(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg); - m_TimePowerCompensateDao->Save(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg); - m_FixPointDao->Save(pcfg->m_SeqNo->GetValue(), pcfg->m_FixPointWrapper); + m_ScanCfgDao->Save(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper); + m_PowerCompensateDao->Save(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg); + m_TimePowerCompensateDao->Save(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg); + m_FixPointDao->Save(pcfg->m_SeqNo , pcfg->m_FixPointWrapper); } } @@ -68,22 +68,22 @@ void ScannerControlCfgDao::FindCfg() { { ScannerControlCfg* cfg = m_ScannerControlCfgs[i]; //machine->InitScanParamBeforeFind(&cfg->m_ScanCfgWrapper); - m_ScanCfgDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper); - m_PowerCompensateDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper.m_PowerCompensateCfg); + m_ScanCfgDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper); + m_PowerCompensateDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper.m_PowerCompensateCfg); if (cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.empty()) { for (int pcIndex = 5; pcIndex <= 100; pcIndex += 5) { PowerCompensate* pc = new PowerCompensate(); - pc->m_cno = cfg->m_SeqNo->GetValue(); + pc->m_cno = cfg->m_SeqNo ; pc->m_percent = pcIndex; pc->m_value = 1.0f; pc->m_value_min = 0.0f; pc->m_value_max = 3.0f; cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.push_back(pc); - m_PowerCompensateDao->Add(cfg->m_SeqNo->GetValue(), pc); + m_PowerCompensateDao->Add(cfg->m_SeqNo , pc); } } - m_TimePowerCompensateDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg); - m_FixPointDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_FixPointWrapper); + m_TimePowerCompensateDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg); + m_FixPointDao->Find(cfg->m_SeqNo , cfg->m_FixPointWrapper); } } @@ -95,15 +95,15 @@ void ScannerControlCfgDao::FindMain() SQLite::Statement query(*m_pDB, buffer); while (query.executeStep()) { ScannerControlCfg* cfg = new ScannerControlCfg(); - cfg->m_SeqNo ->SetValue(query.getColumn(ScannerControlCfg::FIELD_SEQ_NO.c_str()).getInt()); - cfg->m_ControlNo->SetValue(query.getColumn(ScannerControlCfg::FIELD_CONTROL_NO.c_str()).getInt()); - cfg->m_SerialNo->SetValue(query.getColumn(ScannerControlCfg::FIELD_SERIAL_NO.c_str()).getInt()); - cfg->m_ControlType->SetValue(query.getColumn(ScannerControlCfg::FIELD_CONTROL_TYPE.c_str()).getInt()); - cfg->m_CardName->SetValue(query.getColumn(ScannerControlCfg::FIELD_CARD_NAME.c_str()).getString()); - cfg->m_CardIP->SetValue(query.getColumn(ScannerControlCfg::FIELD_CARD_IP.c_str()).getString()); - cfg->m_IsEnable->SetValue(query.getColumn(ScannerControlCfg::FIELD_IS_ENABLE.c_str()).getInt() > 0 ? true : false); + cfg->m_SeqNo=query.getColumn(ScannerControlCfg::FIELD_SEQ_NO.c_str()).getInt(); + cfg->m_ControlNo =query.getColumn(ScannerControlCfg::FIELD_CONTROL_NO.c_str()).getInt(); + cfg->m_SerialNo =query.getColumn(ScannerControlCfg::FIELD_SERIAL_NO.c_str()).getInt(); + cfg->m_ControlType =query.getColumn(ScannerControlCfg::FIELD_CONTROL_TYPE.c_str()).getInt(); + cfg->m_CardName =query.getColumn(ScannerControlCfg::FIELD_CARD_NAME.c_str()).getString(); + cfg->m_CardIP =query.getColumn(ScannerControlCfg::FIELD_CARD_IP.c_str()).getString(); + cfg->m_IsEnable =query.getColumn(ScannerControlCfg::FIELD_IS_ENABLE.c_str()).getInt() > 0 ? true : false; m_ScannerControlCfgs.push_back(cfg); - m_ScannerControlCfgMap[cfg->m_SeqNo->GetValue()] = cfg; + m_ScannerControlCfgMap[cfg->m_SeqNo ] = cfg; } } @@ -113,9 +113,9 @@ void ScannerControlCfgDao::Export(stringstream& ss) ScannerControlCfg* pcfg = m_MatchCfg[i]; if (pcfg == NULL)continue; ss << pcfg->GetUpdateSql() << "\n"; - m_ScanCfgDao->Export(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper, ss); - m_PowerCompensateDao->Export(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg, ss); - m_TimePowerCompensateDao->Export(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg, ss); + m_ScanCfgDao->Export(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper, ss); + m_PowerCompensateDao->Export(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg, ss); + m_TimePowerCompensateDao->Export(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg, ss); } } @@ -123,7 +123,7 @@ void ScannerControlCfgDao::ExportAllPC(stringstream& ss) { for (size_t i = 0; i < m_MatchCfg.size(); ++i) { ScannerControlCfg* pcfg = m_MatchCfg[i]; - m_PowerCompensateDao->Export(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg, ss); + m_PowerCompensateDao->Export(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg, ss); } } @@ -140,7 +140,7 @@ void ScannerControlCfgDao::ImportAllPc(std::string &sql) for (size_t i = 0; i < m_ScannerControlCfgs.size(); ++i) { ScannerControlCfg* pcfg = m_ScannerControlCfgMap[i]; - m_PowerCompensateDao->Find(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg); + m_PowerCompensateDao->Find(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg); } } @@ -157,7 +157,7 @@ void ScannerControlCfgDao::Add(ScannerControlCfg* cfg) ScannerControlCfg::FIELD_CARD_NAME.c_str(), ScannerControlCfg::FIELD_CARD_IP.c_str(), ScannerControlCfg::FIELD_IS_ENABLE.c_str(), - cfg->m_SeqNo->GetValue(), cfg->m_ControlNo->GetValue(), cfg->m_SerialNo->GetValue(), cfg->m_ControlType->GetValue(), cfg->m_CardName->GetValueStr().c_str(), "", cfg->m_IsEnable->GetValue() ? 1 : 0); + cfg->m_SeqNo , cfg->m_ControlNo , cfg->m_SerialNo , cfg->m_ControlType , cfg->m_CardName.c_str(), "", cfg->m_IsEnable ? 1 : 0); m_pDB->exec(buffer); } @@ -168,7 +168,7 @@ void ScannerControlCfgDao::Delete(int seq) m_pDB->exec(buffer); for (vector::iterator it = m_ScannerControlCfgs.begin(); it != m_ScannerControlCfgs.end();) { - if ((*it)->m_SeqNo->GetValue() == seq) + if ((*it)->m_SeqNo == seq) { it = m_ScannerControlCfgs.erase(it); break; @@ -179,7 +179,7 @@ void ScannerControlCfgDao::Delete(int seq) } for (vector::iterator it = m_MatchCfg.begin(); it != m_MatchCfg.end();) { - if ((*it)->m_SeqNo->GetValue() == seq) + if ((*it)->m_SeqNo == seq) { it = m_MatchCfg.erase(it); break; @@ -204,20 +204,20 @@ void ScannerControlCfgDao::Delete(int seq) void ScannerControlCfgDao::Maintain(ScannerControlCfg* cfg) { - m_ScanCfgDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper); - m_PowerCompensateDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper.m_PowerCompensateCfg); + m_ScanCfgDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper); + m_PowerCompensateDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper.m_PowerCompensateCfg); if (cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.empty()) { for (int pcIndex = 5; pcIndex <= 100; pcIndex += 5) { PowerCompensate* pc = new PowerCompensate(); - pc->m_cno = cfg->m_SeqNo->GetValue(); + pc->m_cno = cfg->m_SeqNo ; pc->m_percent = pcIndex; pc->m_value = 1.0f; pc->m_value_min = 0.0f; pc->m_value_max = 3.0f; cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.push_back(pc); - m_PowerCompensateDao->Add(cfg->m_SeqNo->GetValue(), pc); + m_PowerCompensateDao->Add(cfg->m_SeqNo , pc); } } - m_TimePowerCompensateDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg); - m_FixPointDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_FixPointWrapper); + m_TimePowerCompensateDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg); + m_FixPointDao->Find(cfg->m_SeqNo , cfg->m_FixPointWrapper); } \ No newline at end of file diff --git a/PrintS/DataManage/DataHandle.cpp b/PrintS/DataManage/DataHandle.cpp index 8252e8d..1518e2a 100644 --- a/PrintS/DataManage/DataHandle.cpp +++ b/PrintS/DataManage/DataHandle.cpp @@ -29,6 +29,9 @@ void DataHandle::FuncDataCallBackProc(void* pthis,const ReadData& msg, const lis else if ((READTYPE)msg.dataType == CONFIGFUNC) { p->m_config->CallFuncs(msg, lst, response); } + else if ((READTYPE)msg.dataType == SCANERCTRLCFG) { + p->m_config->ScanerCtrlCfgReq(msg, lst, response); + } } diff --git a/PrintS/DataManage/RWData.h b/PrintS/DataManage/RWData.h index e1cb071..5aed65e 100644 --- a/PrintS/DataManage/RWData.h +++ b/PrintS/DataManage/RWData.h @@ -35,6 +35,7 @@ enum READTYPE { COMMUNICATIONCFG, ALARMCFG, POWDERSET, + SCANERCTRLCFG, LOADPARAM, //装载参数 @@ -118,6 +119,7 @@ enum WRITETYPE { PAUSEALARMCFGPARAM, //AlarmCfgWrapper pause参数 WARNALARMCFGPARAM, //AlarmCfgWrapper warn参数 POWDERSETPARAM, //PowderSet 参数 + //SCANNERCONTROLCFGPARAM, //ScannerControlCfg 参数 MOLDCFGPARAM, LOADCFGPARAM, @@ -138,31 +140,42 @@ enum WRITETYPE { }; struct Item { + Item() {} + std::string nameKey; //参数key std::string strValue; //value DATATYPE valueType; //数据类型 + Item(const std::string& nameKey,const std::string& strValue, DATATYPE valueType) + :nameKey(nameKey), strValue(strValue), valueType(valueType) {} std::string content; //alarmcfgwrapper使用 bool isEnable; bool isAlarm; bool isShow; + Item(const std::string& nameKey, const std::string& content, bool isEnable, bool isAlarm, bool isShow) + :nameKey(nameKey), content(content), isEnable(isEnable), isAlarm(isAlarm), isShow(isShow){} //层供粉量配置使用 struct PowderSet int start_layer; int end_layer; float powder; + Item(int start_layer,int end_layer,float powder) :start_layer(start_layer), end_layer(end_layer), powder(powder){} // - //IntData* m_Index; //编号 配合ConfigManager中的map - //IntData* m_SeqNo; - //IntData* m_ControlNo; - //IntData* m_SerialNo; - //IntData* m_ControlType; - //StrData* m_CardName; - //StrData* m_CardIP; - //BoolData* m_IsEnable; //是否启动 - //BoolData* m_HadAssign; - //BoolData* m_HadMatch; + int seqNo; //ScannerControlCfg使用 + int controlNo; + int serialNo; + int controlType; + std::string cardName; + std::string cardIP; + //bool isEnable; //是否启动 + bool hadAssign; + bool hadMatch; + Item(int seqNo, int controlNo, int serialNo, int controlType,const std::string& cardName,const std::string& cardIP, bool isEnable, bool hadAssign, bool hadMatch) + :seqNo(seqNo), controlNo(controlNo), serialNo(serialNo), controlType(controlType), + cardName(cardName), cardIP(cardIP), isEnable(isEnable), hadAssign(hadAssign), hadMatch(hadMatch) { + + } }; class ClientInfo; diff --git a/PrintS/DataManage/StreamServer.cpp b/PrintS/DataManage/StreamServer.cpp index d1efe88..7e16107 100644 --- a/PrintS/DataManage/StreamServer.cpp +++ b/PrintS/DataManage/StreamServer.cpp @@ -64,8 +64,26 @@ Status StreamServer::AllStream(ServerContext* context, grpc::ServerReaderWriter< //函数参数 std::list paramLst; // for (const ::stream::ParamInfo it : request.item()) { - paramLst.emplace_back(Item{ it.namekey(),it.strvalue() ,(DATATYPE)it.valuetype() - ,it.context(),it.isenable(),it.isalarm(),it.isshow(),it.startlayer(),it.endlayer(),it.powder()}); //直接加到readData.its上面，后续的请求无法收到，不知道为啥 + Item temp{ it.namekey(),it.strvalue() ,(DATATYPE)it.valuetype() }; + + temp.content = it.context(); + temp.isEnable = it.isenable(); + temp.isAlarm = it.isalarm(); + temp.isShow = it.isshow(); + + temp.start_layer = it.startlayer(); + temp.end_layer = it.endlayer(); + temp.powder = it.powder(); + + temp.seqNo = it.seqno(); + temp.controlNo = it.controlno(); + temp.serialNo = it.serialno(); + temp.controlType = it.controltype(); + temp.cardName = it.cardname(); + temp.cardIP = it.cardip(); + temp.hadAssign = it.hadassign(); + temp.hadMatch = it.hadmatch(); + paramLst.emplace_back(std::move(temp)); //直接加到readData.its上面，后续的请求无法收到，不知道为啥 } printf("客户端消息：dataType:%d,nameKey:%s, strValue:%s,valueType:%d,lst:%zd\n", @@ -101,6 +119,16 @@ Status StreamServer::AllStream(ServerContext* context, grpc::ServerReaderWriter< paramInfo->set_startlayer(wd->start_layer); paramInfo->set_endlayer(wd->end_layer); paramInfo->set_powder(wd->powder); + + paramInfo->set_seqno(wd->seqNo); + paramInfo->set_controlno(wd->controlNo); + paramInfo->set_serialno(wd->serialNo); + paramInfo->set_controltype(wd->controlType); + paramInfo->set_cardname(wd->cardName); + paramInfo->set_cardip(wd->cardIP); + paramInfo->set_isenable(wd->isEnable); + paramInfo->set_hadassign(wd->hadAssign); + paramInfo->set_hadmatch(wd->hadMatch); } stream->Write(response); } diff --git a/PrintS/ScannerCtrl/RTC5Scanner.cpp b/PrintS/ScannerCtrl/RTC5Scanner.cpp index 837850f..ab7c1f5 100644 --- a/PrintS/ScannerCtrl/RTC5Scanner.cpp +++ b/PrintS/ScannerCtrl/RTC5Scanner.cpp @@ -76,8 +76,8 @@ bool RTC5Scanner::Init() // m_SeqBit[i] = true; //} - int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue(); - if ((m_ScannerControlCfg->m_SeqNo->GetValue() % 2) != 0) { + int controlNo = m_ScannerControlCfg->m_ControlNo ; + if ((m_ScannerControlCfg->m_SeqNo % 2) != 0) { m_IsLeftScan = true; } else { @@ -104,7 +104,7 @@ bool RTC5Scanner::Init() return false; } char buffer[512]; - sprintf_s(buffer, sizeof(buffer), "%sSLM%d.ct5", g_AppPath.c_str(), m_ScannerControlCfg->m_SeqNo->GetValue()); + sprintf_s(buffer, sizeof(buffer), "%sSLM%d.ct5", g_AppPath.c_str(), m_ScannerControlCfg->m_SeqNo ); string crtPath = string(buffer); uint32_t dim = m_CorrectParamCfg->m_IsCorrectFile3D ? 3 : 2; error = n_load_correction_file(controlNo, crtPath.c_str(), 1, dim); @@ -195,7 +195,7 @@ void RTC5Scanner::LoadList(unsigned int listid, bool wait) { if (wait) { - while (!n_load_list(m_ScannerControlCfg->m_ControlNo->GetValue(), listid, 0)) { + while (!n_load_list(m_ScannerControlCfg->m_ControlNo , listid, 0)) { Sleep(20); if (BaseCtrl::IsStop()) { break; @@ -203,28 +203,28 @@ void RTC5Scanner::LoadList(unsigned int listid, bool wait) } } else { - n_load_list(m_ScannerControlCfg->m_ControlNo->GetValue(), listid, 0); + n_load_list(m_ScannerControlCfg->m_ControlNo , listid, 0); } } void RTC5Scanner::EndList() { - n_set_end_of_list(m_ScannerControlCfg->m_ControlNo->GetValue()); + n_set_end_of_list(m_ScannerControlCfg->m_ControlNo ); } void RTC5Scanner::AutoChangeList() { - n_auto_change(m_ScannerControlCfg->m_ControlNo->GetValue()); + n_auto_change(m_ScannerControlCfg->m_ControlNo ); } void RTC5Scanner::ListExecute(unsigned int listid, bool wait) { - n_execute_list(m_ScannerControlCfg->m_ControlNo->GetValue(), listid); + n_execute_list(m_ScannerControlCfg->m_ControlNo , listid); unsigned int Busy(0), Pos(0); if (wait) { do { Sleep(10); - n_get_status(m_ScannerControlCfg->m_ControlNo->GetValue(), Busy, Pos); + n_get_status(m_ScannerControlCfg->m_ControlNo , Busy, Pos); if (BaseCtrl::IsStop()) { break; } @@ -248,8 +248,8 @@ void RTC5Scanner::AddVector(double startx, double starty, double endx, double en long lstarty = lround(bity1); long lendx = lround(bitx2); long lendy = lround(bity2); - n_jump_abs(m_ScannerControlCfg->m_ControlNo->GetValue(), lstartx, lstarty); - n_mark_abs(m_ScannerControlCfg->m_ControlNo->GetValue(), lendx, lendy); + n_jump_abs(m_ScannerControlCfg->m_ControlNo , lstartx, lstarty); + n_mark_abs(m_ScannerControlCfg->m_ControlNo , lendx, lendy); } @@ -264,7 +264,7 @@ void RTC5Scanner::JumpAbs(double x, double y) long lx = lround(bitx1); long ly = lround(bity1); - n_jump_abs(m_ScannerControlCfg->m_ControlNo->GetValue(), lx, ly); + n_jump_abs(m_ScannerControlCfg->m_ControlNo , lx, ly); } void RTC5Scanner::MarkAbs(double x, double y) @@ -278,7 +278,7 @@ void RTC5Scanner::MarkAbs(double x, double y) long lx = lround(bitx1); long ly = lround(bity1); - n_mark_abs(m_ScannerControlCfg->m_ControlNo->GetValue(), lx, ly); + n_mark_abs(m_ScannerControlCfg->m_ControlNo , lx, ly); } @@ -288,7 +288,7 @@ void RTC5Scanner::WaitListFree() do { Sleep(5); - n_get_status(m_ScannerControlCfg->m_ControlNo->GetValue(), Busy, Pos); + n_get_status(m_ScannerControlCfg->m_ControlNo , Busy, Pos); if (BaseCtrl::IsStop()) { break; } @@ -300,7 +300,7 @@ void RTC5Scanner::ScanDebug() { SetAutoUpdateScanInfo(false); Sleep(200); - int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue(); + int controlNo = m_ScannerControlCfg->m_ControlNo ; unsigned int power = (unsigned int)(4095.0*m_PowerCompensateCfg->CalcPowerCompensate((float)m_ScanTestCfg->m_laser_power) / 100.0); if (power > 4095)power = 4095; double markspeed = m_kfactor*m_ScanParamCfg->m_mark_speed / 1000.0; @@ -326,7 +326,7 @@ void RTC5Scanner::ScanDebug() void RTC5Scanner::ScanTestProc() { - int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue(); + int controlNo = m_ScannerControlCfg->m_ControlNo ; int shapeSize = m_ScanTestCfg->m_shape_size; switch (m_ScanTestCfg->m_debug_shape) { case Cross: { @@ -472,7 +472,7 @@ void RTC5Scanner::UpdateScanParamByCfg(ScanParamCfg* cfg) unsigned int minJumpDelay = cfg->m_min_jump_delay / 10; double jumpspeed = m_kfactor* cfg->m_jump_speed / 1000.0; - int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue(); + int controlNo = m_ScannerControlCfg->m_ControlNo ; n_set_scanner_delays(controlNo, jumpDelay, markDelay, polygonDelay); n_set_laser_delays(controlNo, laserOnDealy, laserOffDelay); n_set_delay_mode_list(controlNo, 1, 1, edgeLevel, minJumpDelay, (unsigned int)(cfg->m_jump_length_limit*m_kfactor)); @@ -495,7 +495,7 @@ void RTC5Scanner::UpdateSetting() unsigned int minJumpDelay = m_ScanParamCfg->m_min_jump_delay / 10; unsigned int power = 4095.0* m_PowerCompensateCfg->CalcPowerCompensate((float)m_ScanTestCfg->m_laser_power) / 100.0; - int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue(); + int controlNo = m_ScannerControlCfg->m_ControlNo ; double markspeed = m_kfactor*m_ScanParamCfg->m_mark_speed / 1000.0; double jumpspeed = m_kfactor*m_ScanParamCfg->m_jump_speed / 1000.0; n_write_da_x(controlNo, 1, power); //设置功率 @@ -515,19 +515,19 @@ void RTC5Scanner::UpdateSetting() void RTC5Scanner::SetScanSpeed(double fvalue) { double speed = fvalue / 1000.0*m_kfactor; - n_set_mark_speed(m_ScannerControlCfg->m_ControlNo->GetValue(), speed); + n_set_mark_speed(m_ScannerControlCfg->m_ControlNo , speed); } void RTC5Scanner::SetPower(double watt) { unsigned int power = 4095.0*watt / 100; if (power > 4095)power = 4095; - n_write_da_1_list(m_ScannerControlCfg->m_ControlNo->GetValue(), power); + n_write_da_1_list(m_ScannerControlCfg->m_ControlNo , power); } bool RTC5Scanner::StopWork() { - n_stop_execution(m_ScannerControlCfg->m_ControlNo->GetValue()); + n_stop_execution(m_ScannerControlCfg->m_ControlNo ); return true; } @@ -548,7 +548,7 @@ void RTC5Scanner::UpdateSkyWriting(bool islist) long laserOnShift = 0; unsigned int nprev = 0; unsigned int npost = 0; - int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue(); + int controlNo = m_ScannerControlCfg->m_ControlNo ; switch (m_SkyWritingCfg->m_Mode) { case 1: @@ -599,21 +599,21 @@ void RTC5Scanner::SetSkyWritingEnable(bool benable, bool islist) UpdateSkyWriting(islist); } else { - if (islist) n_set_sky_writing_mode_list(m_ScannerControlCfg->m_ControlNo->GetValue(), 0); - else n_set_sky_writing_mode(m_ScannerControlCfg->m_ControlNo->GetValue(), 0); + if (islist) n_set_sky_writing_mode_list(m_ScannerControlCfg->m_ControlNo , 0); + else n_set_sky_writing_mode(m_ScannerControlCfg->m_ControlNo , 0); } } void RTC5Scanner::SetDefocus(float value) { long ds = value*m_zfactor; - n_set_defocus_list(m_ScannerControlCfg->m_ControlNo->GetValue(), ds); + n_set_defocus_list(m_ScannerControlCfg->m_ControlNo , ds); } void RTC5Scanner::ListNop() { - n_list_nop(m_ScannerControlCfg->m_ControlNo->GetValue()); + n_list_nop(m_ScannerControlCfg->m_ControlNo ); } @@ -622,29 +622,29 @@ void RTC5Scanner::CheckAlarm() { if (!m_MachineCfg->m_IsIntelli->GetValue())return; - n_control_command(m_ScannerControlCfg->m_ControlNo->GetValue(), 1, 1, CurrentOperationStateLowAddr); + n_control_command(m_ScannerControlCfg->m_ControlNo , 1, 1, CurrentOperationStateLowAddr); Sleep(2); - int xlowstate = n_get_value(m_ScannerControlCfg->m_ControlNo->GetValue(), 1); + int xlowstate = n_get_value(m_ScannerControlCfg->m_ControlNo , 1); bool IsInternalVoltagesNormalX = (xlowstate & 0x20000) ? true : false; bool IsCriticalErrorX = (xlowstate & 0x2000) ? false : true; bool IsScannerAndServoBoradTempNormalX = (xlowstate & 0x8000) ? true : false; - n_control_command(m_ScannerControlCfg->m_ControlNo->GetValue(), 1, 2, CurrentOperationStateLowAddr); + n_control_command(m_ScannerControlCfg->m_ControlNo , 1, 2, CurrentOperationStateLowAddr); Sleep(2); - int ylowstate = n_get_value(m_ScannerControlCfg->m_ControlNo->GetValue(), 2); + int ylowstate = n_get_value(m_ScannerControlCfg->m_ControlNo , 2); bool IsInternalVoltagesNormalY = (ylowstate & 0x20000) ? true : false; bool IsCriticalErrorY = (ylowstate & 0x2000) ? false : true; bool IsScannerAndServoBoradTempNormalY = (ylowstate & 0x8000) ? true : false; - n_control_command(m_ScannerControlCfg->m_ControlNo->GetValue(), 1, 1, StopEventCode); + n_control_command(m_ScannerControlCfg->m_ControlNo , 1, 1, StopEventCode); Sleep(2); - int xstopeven = n_get_value(m_ScannerControlCfg->m_ControlNo->GetValue(), 1); + int xstopeven = n_get_value(m_ScannerControlCfg->m_ControlNo , 1); - n_control_command(m_ScannerControlCfg->m_ControlNo->GetValue(), 1, 2, StopEventCode); + n_control_command(m_ScannerControlCfg->m_ControlNo , 1, 2, StopEventCode); Sleep(2); - int ystopeven = n_get_value(m_ScannerControlCfg->m_ControlNo->GetValue(), 2); + int ystopeven = n_get_value(m_ScannerControlCfg->m_ControlNo , 2); - int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue(); + int seqNo = m_ScannerControlCfg->m_SeqNo ; bool isAlarm = false; stringstream ss; char buffer[256]; @@ -716,7 +716,7 @@ void RTC5Scanner::UpdateScannerInfo() { if (!m_MachineCfg->m_IsIntelli->GetValue())return; - int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue(); + int controlNo = m_ScannerControlCfg->m_ControlNo ; n_control_command(controlNo, 1, 1, ActualPositionAddr); Sleep(2); long xap = n_get_value(controlNo, 1); @@ -989,7 +989,7 @@ void RTC5Scanner::HeatingScannerRun() sqlength, -sqlength, -sqlength, -sqlength }; - int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue(); + int controlNo = m_ScannerControlCfg->m_ControlNo ; double markspeed = m_kfactor* m_ScannerControlCfg->m_ScanCfgWrapper.m_ScanTestCfg.m_AutoHeatingScannerSpeed / 1000.0; int sqsize = (sizeof(square) / sizeof(polygon)); n_set_start_list(controlNo, 1); @@ -1027,5 +1027,5 @@ void RTC5Scanner::HeatingScannerRun() void RTC5Scanner::ResetDefocus() { - n_set_defocus(m_ScannerControlCfg->m_ControlNo->GetValue(), 0); + n_set_defocus(m_ScannerControlCfg->m_ControlNo , 0); } diff --git a/PrintS/ScannerCtrl/Scanner.cpp b/PrintS/ScannerCtrl/Scanner.cpp index 36aefe7..3013862 100644 --- a/PrintS/ScannerCtrl/Scanner.cpp +++ b/PrintS/ScannerCtrl/Scanner.cpp @@ -166,7 +166,7 @@ bool Scanner::BeginWork() DWORD WINAPI Scanner::ScanProc(Scanner* _this) { if (_this) { - int seqNo = _this->m_ScannerControlCfg->m_SeqNo->GetValue(); + int seqNo = _this->m_ScannerControlCfg->m_SeqNo ; if (_this->m_MachineCfg->IsDataSeqStragegy()) { EnterCriticalSection(&m_SeqCS); @@ -243,7 +243,7 @@ void Scanner::Clean() EnterCriticalSection(&m_SeqCS); if (m_ScannerControlCfg){ - int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue(); + int seqNo = m_ScannerControlCfg->m_SeqNo ; m_SeqDataUnFinishBit[seqNo] = false; m_SupportSeqDataUnFinishBit[seqNo] = false; } @@ -320,7 +320,7 @@ void Scanner::Scan(void) SetSkyWritingEnable(isSkyWritingEnable, true); SetScanSpeed(laserSpeed); - int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue(); + int seqNo = m_ScannerControlCfg->m_SeqNo ; g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserSpeed = laserSpeed; SetPower(laserPower); g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserPower = paramSet->laser_set->laser_power; @@ -480,7 +480,7 @@ void Scanner::ScanSeqV2() { if (BaseCtrl::IsStop())return; EnterCriticalSection(&m_SeqCS); - m_SupportSeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo->GetValue()] = false; + m_SupportSeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo ] = false; LeaveCriticalSection(&m_SeqCS); while (true && (!BaseCtrl::IsStop())) { @@ -640,7 +640,7 @@ void Scanner::ScanSeqV2() { } else { EnterCriticalSection(&m_SeqCS); - m_SeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo->GetValue()] = false; + m_SeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo ] = false; int sb = m_SeqDataUnFinishBit.to_ulong(); if (sb == 0) { Printdbi = m_ZeroSeq.front(); @@ -680,13 +680,13 @@ void Scanner::ScanSeqV2() { SetSkyWritingEnable(isSkyWritingEnable, true); SetScanSpeed(laserSpeed); - g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserSpeed = laserSpeed; + g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserSpeed = laserSpeed; SetPower(laserPower); - g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserPower = paramSet->laser_set->laser_power; + g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserPower = paramSet->laser_set->laser_power; if (m_CorrectParamCfg->m_IsDynamicFocus) { SetDefocus(ds); - g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserDefocus = ds; + g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserDefocus = ds; } EndList(); ListExecute(1, nodebug); @@ -853,7 +853,7 @@ void Scanner::ScanMass() { } if (BaseCtrl::IsStop())return; - int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue(); + int seqNo = m_ScannerControlCfg->m_SeqNo ; EnterCriticalSection(&m_SeqCS); m_SupportSeqDataUnFinishBit[seqNo] = false; LeaveCriticalSection(&m_SeqCS); @@ -1005,7 +1005,7 @@ void Scanner::ScanDataBlock(DataBlockInfo* Printdbi) SetSkyWritingEnable(isSkyWritingEnable, true); SetScanSpeed(laserSpeed); - int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue(); + int seqNo = m_ScannerControlCfg->m_SeqNo ; g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserSpeed = laserSpeed; SetPower(laserPower); g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserPower = paramSet->laser_set->laser_power; diff --git a/PrintS/ScannerCtrl/ScannerCtrl.cpp b/PrintS/ScannerCtrl/ScannerCtrl.cpp index f24be56..ef6190b 100644 --- a/PrintS/ScannerCtrl/ScannerCtrl.cpp +++ b/PrintS/ScannerCtrl/ScannerCtrl.cpp @@ -88,7 +88,7 @@ bool ScannerCtrl::Init() { for (map::iterator scc = scannerControlCfgsMap->begin(); scc != scannerControlCfgsMap->end(); scc++) { ScannerControlCfg* cfg = scc->second; - if (cfg->m_SerialNo->GetValue() == s->second) + if (cfg->m_SerialNo == s->second) { find = true; break; @@ -97,19 +97,19 @@ bool ScannerCtrl::Init() { if (!find && flag < difSize) { ScannerControlCfg* cfg = new ScannerControlCfg(); - cfg->m_SeqNo->SetValue(scannerControlCfgsMap->size() + 1); - cfg->m_CardName->SetValue("Laser" + to_string(cfg->m_SeqNo->GetValue())); - cfg->m_ControlNo->SetValue(s->first); - cfg->m_ControlType->SetValue(m_MachineCfg->m_ScanControl->GetValue()); - cfg->m_SerialNo->SetValue(s->second); - cfg->m_HadMatch->SetValue(false); - cfg->m_IsEnable->SetValue(true); + cfg->m_SeqNo=scannerControlCfgsMap->size() + 1; + cfg->m_CardName="Laser" + to_string(cfg->m_SeqNo); + cfg->m_ControlNo = s->first; + cfg->m_ControlType = m_MachineCfg->m_ScanControl->GetValue(); + cfg->m_SerialNo = s->second; + cfg->m_HadMatch = false; + cfg->m_IsEnable = true; cfg->Init(); //m_Machine->InitScanParamBeforeFind(&cfg->m_ScanCfgWrapper); ConfigManager::GetInstance()->GetScannerControlCfgDao()->Add(cfg); ConfigManager::GetInstance()->GetScannerControlCfgDao()->Maintain(cfg); ConfigManager::GetInstance()->GetScannerControlCfgs()->push_back(cfg); - (*scannerControlCfgsMap)[cfg->m_SeqNo->GetValue()] = cfg; + (*scannerControlCfgsMap)[cfg->m_SeqNo ] = cfg; flag++; } } @@ -125,7 +125,7 @@ bool ScannerCtrl::Init() { int index = 0; for (map::iterator sit = scannerControlCfgsMap->begin(); sit != scannerControlCfgsMap->end(); sit++) { ScannerControlCfg* cfg = sit->second; - int seqNo = cfg->m_SeqNo->GetValue(); + int seqNo = cfg->m_SeqNo ; if (m_IOCfgWrapper->m_LaserIOMap.find(seqNo) != m_IOCfgWrapper->m_LaserIOMap.end()) { cfg->m_LaserRed = m_IOCfgWrapper->m_LaserIOMap[seqNo]->m_LaserRed; cfg->m_LaserStart = m_IOCfgWrapper->m_LaserIOMap[seqNo]->m_LaserStart; @@ -778,7 +778,7 @@ void ScannerCtrl::DispatchDataBlock() for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) { Scanner* scanner = m_scan[scanIndex]; scanner->m_JobStartTime = job->m_FirstStartTime; - scanMap[scanner->GetConfig()->m_SeqNo->GetValue()] = scanner; + scanMap[scanner->GetConfig()->m_SeqNo ] = scanner; } m_DownSkinStopFlag = 1; @@ -1258,7 +1258,7 @@ void ScannerCtrl::DispatchDataBlock() sstatus->m_ScanServoTempX = sxy.m_X.m_ServoBoardTemp; sstatus->m_ScanTempY = sxy.m_Y.m_GalvanometerScannerTemp; sstatus->m_ScanServoTempY = sxy.m_Y.m_ServoBoardTemp; - sstatus->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo->GetValue(); + sstatus->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo; sstatus->m_JobId = jobBean->m_Id; sstatus->m_LayerIndex = layerindex; sstatus->m_ActualPositionX = sxy.m_X.m_ActualPosition; @@ -1275,7 +1275,7 @@ void ScannerCtrl::DispatchDataBlock() if (m_scan[scanIndex]->GetConfig()->m_ScanCfgWrapper.m_CorrectParamCfg.m_IsDynamicFocus) { FocusStatus* fs = new FocusStatus(); - fs->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo->GetValue(); + fs->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo ; fs->m_JobId = jobBean->m_Id; fs->m_LayerIndex = layerindex; time(&fs->m_InsertTime); @@ -1399,7 +1399,7 @@ void ScannerCtrl::DispatchTestDataBlock() for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) { Scanner* scanner = m_scan[scanIndex]; - scanMap[scanner->GetConfig()->m_SeqNo->GetValue()] = scanner; + scanMap[scanner->GetConfig()->m_SeqNo ] = scanner; m_scan[scanIndex]->Clean(); } for (size_t i = 0; i < m_scan.size(); i++) @@ -1574,7 +1574,7 @@ void ScannerCtrl::DispatchModelDataBlock(int partId, string scanType, float powe map scanMap; for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) { Scanner* scanner = m_scan[scanIndex]; - scanMap[scanner->GetConfig()->m_SeqNo->GetValue()] = scanner; + scanMap[scanner->GetConfig()->m_SeqNo ] = scanner; m_scan[scanIndex]->Clean(); } @@ -1812,7 +1812,7 @@ void ScannerCtrl::RemoveScanner(int seq) { for (vector::iterator it = m_scan.begin(); it != m_scan.end();) { Scanner* s = (*it); - if (s->GetConfig()->m_SeqNo->GetValue() == seq) + if (s->GetConfig()->m_SeqNo == seq) { delete s; it = m_scan.erase(it); @@ -2017,7 +2017,7 @@ void ScannerCtrl::SendToClients() { auto iter = Scanner::m_CurrentSerio.begin(); while (iter != Scanner::m_CurrentSerio.end()) { - lst.emplace_back(Item{ to_string(iter->first), to_string(iter->second), iUINT }); + lst.emplace_back(Item(to_string(iter->first), to_string(iter->second), iUINT )); ++iter; } diff --git a/PrintS/additional/Calibration.cpp b/PrintS/additional/Calibration.cpp index 9974b5d..04e70ee 100644 --- a/PrintS/additional/Calibration.cpp +++ b/PrintS/additional/Calibration.cpp @@ -959,7 +959,7 @@ void Calibration::GraftRun() float mminy = rt.y; float mmaxy = rt.y + rt.height; if (mminx >lminx && lmaxx>mmaxx && mminy >lminy && lmaxy > mmaxy) { - matchLaser = (*cfgs)[lindex]->m_SeqNo->GetValue(); + matchLaser = (*cfgs)[lindex]->m_SeqNo ; break; } } @@ -976,7 +976,7 @@ void Calibration::GraftRun() float mminy = rt2.y; float mmaxy = rt2.y + rt2.height; if (mminx > lminx && lmaxx > mmaxx && mminy > lminy && lmaxy > mmaxy) { - dataLaser = (*cfgs)[lindex]->m_SeqNo->GetValue(); + dataLaser = (*cfgs)[lindex]->m_SeqNo ; break; } } diff --git a/PrintS/job/H3DFileProcessor.cpp b/PrintS/job/H3DFileProcessor.cpp index 575674f..98c28de 100644 --- a/PrintS/job/H3DFileProcessor.cpp +++ b/PrintS/job/H3DFileProcessor.cpp @@ -121,9 +121,9 @@ int H3DFileProcessor::Process(string jobfile) if ((sf->dimension->xmin >= cfg_xmin) && (sf->dimension->xmax <= cfg_xmax) && (sf->dimension->ymin >= cfg_ymin) && (sf->dimension->ymax <= cfg_ymax)) { canSelectIndexs.push(laserIndex); - if (!hasSelected[cfg->m_SeqNo->GetValue()]) { + if (!hasSelected[cfg->m_SeqNo ]) { metadata->m_FieldRefScanLaser[sf->id] = cfg; - hasSelected[cfg->m_SeqNo->GetValue()] = 1; + hasSelected[cfg->m_SeqNo ] = 1; hasfind = true; break; } @@ -278,7 +278,7 @@ int H3DFileProcessor::Process(string jobfile) } if (laserCfg) { - db->cno = laserCfg->m_SeqNo->GetValue(); + db->cno = laserCfg->m_SeqNo ; } } else { diff --git a/PrintS/job/JobMetaData.cpp b/PrintS/job/JobMetaData.cpp index 62da079..67bc753 100644 --- a/PrintS/job/JobMetaData.cpp +++ b/PrintS/job/JobMetaData.cpp @@ -796,7 +796,7 @@ void XMLCALL JobMetaData::EndElement(void* userData, const XML_Char* name) } if (laserCfg) { - job->parseAssist.lastDataBlock->cno = laserCfg->m_SeqNo->GetValue(); + job->parseAssist.lastDataBlock->cno = laserCfg->m_SeqNo ; } } } @@ -1033,9 +1033,9 @@ void XMLCALL JobMetaData::EndElement(void* userData, const XML_Char* name) if ((sf->dimension->xmin >= cfg_xmin) && (sf->dimension->xmax <= cfg_xmax) && (sf->dimension->ymin >= cfg_ymin) && (sf->dimension->ymax <= cfg_ymax)) { canSelectIndexs.push(laserIndex); - if (!hasSelected[cfg->m_SeqNo->GetValue()]) { + if (!hasSelected[cfg->m_SeqNo ]) { job->m_FieldRefScanLaser[sf->id] = cfg; - hasSelected[cfg->m_SeqNo->GetValue()] = 1; + hasSelected[cfg->m_SeqNo ] = 1; hasfind = true; break; } diff --git a/PrintS/job/MetaData.cpp b/PrintS/job/MetaData.cpp index d829874..b71e19c 100644 --- a/PrintS/job/MetaData.cpp +++ b/PrintS/job/MetaData.cpp @@ -458,7 +458,7 @@ void MetaData::ReCalcEvaTime() sum = markMil + jumpMil + hatching + jumpdelay + markdelay + 20.0 + flag; datablock->scanTime = sum; // milsec += sum; - layer->estimateTimeMap[laserCfg->m_SeqNo->GetValue()] += sum; + layer->estimateTimeMap[laserCfg->m_SeqNo ] += sum; } double max = 0.0; for (map::iterator it = layer->estimateTimeMap.begin(); it != layer->estimateTimeMap.end(); it++) { diff --git a/PrintS/output/Release/log/2024.hbd b/PrintS/output/Release/log/2024.hbd index 65ce3663ca7b322b3f0e9a5f16e2c8eabc5b102d..2ca961924e80526e3e9f896c8f509c0423a8f26d 100644 GIT binary patch delta 28918 zcmV(lK=i+WzzTri3V(yxUJ)5ueeMuKv->swSxstf4SY@epV4AIwR`CAFk?%p`_YZr5EQ2(5g^ri#FQZI4H{Eh=Vd_UYoNuHB6Js;M9^k4k|TDb;A=} zPylnv{;9vB&-`qbEXOTts#`>tYe%DP7DcZkb1@gg+7N$6cz>jH*&%U4Q*xB$Om!OK zqsqRenCwzRpU<*pT?9h*IJh_d7jKI@evr{T3>^>0Ad2aZymAg zXVNzBfvm+Ph)w_~OrNC7hkU{Gh%|mS8{{q7txj5xTz{Lu*_bhql~m_`9^O0_`4O8x zIXG``{rQ-H%4VBWZy+7+$E^hzxc zZKt#B(Mh2ya3Hl|%Xo=N+PIUqv40cP`Jj@K1EBzV0mI|EXK)a+MlSX&tZT$I=GCJ1 ztGI6C)_-7&Qv{-Yq1-%cY}diohyN9K0MMrYr6KL-@ zW)|KE?W$bGv_PVIf|0NYI~oGDS#ULJ()z7X=6}y#%Z+~j+m58GkjLNDlyAkV;`z-uRwEdBNvfnOyW4OKnC@pliLgJ#z=VmMH8op zRev&at-pMaV)!SC#Nf`tT5<*q8^lY8s2!Z-8>|8aMrNH!$m5Yk?U;q3>`k`|*WJ&t;HJs+crAVoOEuPle8&PgBS9) zA!a#V1<@wlU^Q{w2jv6w7W}vFRg1LkcJ8UP*re!ZK(Et?_Uu{HVLq{2YA38Ar_#GDmKZf$5I)AAX zV&Ve5phh*SnZ;7f5cT~mkx{cslhE~}4^Y@h$Y;BV|5E?uNCsz6)`N*IONbZo8v^7t znYv~(GTQCEMc)l`_}O_%yRlb|_M_q*Bc?EE^lq6SFYs`h3u#G_u&|Dv)e+@G5(6o9 zkz$tSs#C|ba%fxLpYQP(6vYbCz z_TovL*8kn=T@;90+gfT0kICp!bt)AJZ{6vvMW!U^nLC1qea*lVJ#N<$|4Ztw1@vI0 zE(k@_G~sBKGJhDM1l0xs76X)E7FV&+ej)Hg^?H0QUiwikbxhu7ekw(-{eRmeu<+T? z+N)bs9u*jzz-0oD>Ww{W*aEo0IQlFE&b$ey5mb#jxG}Lg+{ON(Mx}okDzEN(#C^Nq z12ru0nRMN(>~T87>iXAFtptpX$nJf&$tk9S1@tXX&hJUQNC|-@&C~dbi^`Vdq)}}S z;ZEJln@)^q;v)2j0aL(*4}S(ZFG6thKEEoW6xQ3g7C1&Mv9>Vu+S8r_H*Z-9-#Vhg zfDGmBkIRezMi=LnI^SaDDI=0^`MZ_MO*hl9&@Ms}0VBOFEncj@n9&#-Ya}?e+G35aUQTV%8yyDKQwt&;kLVvjWzR$@OHRN7k zd2%ofMJE2|j09f`A*cRp;~EP|oeUduHi{|SmCHA&o>Ke-JlN__3yO}xRa(!peJI&_ zp=~v>2hhnqo_X__yY+A~CJB~z89a8<=nJ5k-tj-~V_Rq~>S$7lokarf7iOWKUd7L&VSv}DwzV&FNz2^0hwz*;I8qo+B^EZXl0;|+Iy{GVRy;P==9)7 z^z@hT9i6fFCUKM3;*@`aex9tEhYq!xl-oqIaB(k3uD6H5tMiaf#qNjnXfjPQS3I*N zvDtWe6ggMtGhB5$99=qUkhlafq(vuICk$;{3y7zfHFxX@=sS| z{f|*gKrt*0-GaD2b9)gR@Grh%1^2uC%BIU6lULa&-?||{Xa}-2jQS^A%Ej-qb)J&YzonNZ4HL68Mb9MX)N-M zsCP1?(v#J+06gU!UnwVK^#*1kPz0BAux!X9YqRYL zLxTp#m*D~(qo2q%(sWc41oRgrIz;ihAb&7S*KJPgQP}jqCgQHX3(A~UVD|HORYWf< zk=ACp*o;Z=%ipgxn?}>F$?Dw$%Z&`*Vlv~vte~J9szz2BlL959qA~`eajX5CbJI=CL?{_(jXlfZ$aLN@Yqwx4gccZd<=je$ z9zJ?o{QxA;=&5v(mkt~~5jHh0?0-Em#-;WQc>W@sD}tiKg}JK@8;X!n^wb4}2X10( zl|3oW8TK#LM2VZQz)GG)p3GJj{DBG8K6-bz`hnL3e`dV_Zki7;XjohI8~sG}7YCxD z%+X+*SqYjI9x4`eC4D9Ltz1^7S*&@j4J>i9O*8g6gE;iP8o?GoA=kh-J%8=wG88;I z+kENuPu6nfF}nznHuI4;<`uE8RcaP}@;36$rhXX(z;L+9?cM{4uo7}cOMe|LV1s_k_Gqb+%u6rW?2nxq1yjbbKjAwKTq~CbC1;oX zj|Y`6VfiR_gH<(7-oy?sP_Rqjqjow(rvCHG4vXmJ#N_4*+lirTf;>{3aRc#4v{89k z^-{`^UVeR^4+55{q)4pms|xn=%$Q;LTw@)(K-nO=H)mP3JPrW<|9{5RKQaPoV8k`T zag^R)UuSi=Vc|(K)_?68I_y!Q?9$}2BlF|1*OnDr1Ss>HA_=OcTX>s@$Cp%k8eVl@ zD`K~ktV|P+_e0PG44NiYD4)XJ8#-6+x;rGJ%2S^x0Q+iTa$*>LsKY?rsF2OT&*(bu z#;=wFYj~t}8{uRJeXg#t#I0MIH7*m2@J@!9&wN=|`Qn2H`+pfi-MDK94A+X<23W$) zGDbMYHJ!P--{Oof!+R~O25)pIlWJ!?Wm3kh8zz6o!2-b*Ns`#ca)SW?DoZnq0D$Q| zx(o}u@jll(J0z+f2+!_DVPYRU0V4fD8yI1nfdSQq2QS)#W-7tp6H-oE{yp@&%wBxV z24=#EResn4K7Up8QO*G1ZqN?q1sF;UeqA%r>171Q{Wi;Q^YcpD-`UW2&)KBeIxse8 z<=tGAA%g&A4A6-hl36O4SLs3-YB4PdtHYK3!*V|8eKotjb0(B6EuGuOac^zKs|p8$ zHmsO7=J0VJ_7-zkE zqGPxGyWY68pGyTLMLB|_-M7yjg98u2g8)@c6Vns6p!Z-r1rM*1F*||eu%l(}+NN2b z?nB1T{C~;%OFP~J@x&Bm87?@mAMO{+Tixe&TPCN2n=r(q$1K6P-}-J5)FkXG8>5$D zUoWAA`CP|JYPvs~kO8>d?$qB!22M3CMU@%)S3HoS*5~4;??Y78vK#OyzhqeUQ|y`f<>xEK|9 zp$;id_N_7jlt9A`j-DmU$nwEO?=dVfuW%fsVPM3^XT!8q zLLgJ@p^4NkCdssW6(QPXnLhjmf49I|<^d6f&aZ1J7OkQX5PxnQ`b&w|YFrk6gX2B@?rGI_q!9f+M?5%mj_m~z)GZ1#)}A6b{ZCx{ zK6i?Db2=ii?;(G|vGsDL0jjAdOPrK!Od7%*&->E{+p^kUFY+CHjNj)|7U4w{w?5B+ z+`uZ(M!lr@=T_yvN5vWOX>R1gfKJ~&!nTCz$L07|FFMMmEfBmyA{qAYt=~6!kg+h1 z{-S~>f`13_!z6x!W)8r4z4J$b`E;O~6lcIWz9r?~^vmF+$V8y4-OKcv29@PB+kpx5 z5ye<;IId3PjyhLuE?wIRu>3}p=~(%7U?mcg+(nIGC&|R8kB!q22(G(M0UzW&jX1R2 zKO8NzFjv1>RwXVvhbaFMlNX+dQRY@Mjf6t8gd@|V|2UaQZe{PiRiGYdIK+`%ly9QOA;$>ecEI)4Dt z4?Po_LBIJE0U&q?Ubpek<{r~F3em&$brid_TQR<=xh1LQQx7Rqm+22T6nJT)c2rA* ze}5uV4?Bqq;zA`W61#q~wA_A$iIo`6+ZG5Y{eES>V&7Dfr|=gq8^43qX@@dwzlgNK z#9JaC1)n(!Rqw8b#+oG|jcljg@7LG*Mg63P@ZTR$O@W0be5(MZkMGS}yy%YQ(2#e$ zXaf$6!DPS9c@JY0*Dl9rYFhvl_u;qOqJOjqX2J}**8KD$wFffFva=1Ume|{UUnk8( z*U-;uJ}FQbY?umrW3+vwB0f70O3c0yUS>Ejzmy1pP0?^Ps&3%vu}L)Yo7K<(-a|5F zCzA+D6!C?HP4SwFmN_be5iAye%PuJCsqEWPwh8M_WnjURd3rCenI;~1(3X&L+J7V# zwy;bpNOSH4CKUd+?b|Yt!dx5fM?D?gf~5<`di}7}lP;@|!lYxiHwG1*D_xcmvG(r*Zo`643&Y zrWE8V_c5z&$|avEg-BKQKcdH9_kR=hW<~cqW?yVW`r;2u29zLZ&e~lt^@9ye(-~KE z8d(@ZHlpWzr(KB)2ylvo@+l&JAd<+V2x#m-ur_b|!bt?339G$Lj}@qx)-7T}9Dl0g z3#zLiBabo-;R2d`G@kS}&V68Rrf?HAb93wkVNdhL{2@HDX8i@oSJNHsv45_M6Vx^R zC^Lk)v!!+2;Xz?a(ZJkPY>wF2`u|;MpIDJw2D&_2?iW^xCF-IC#igZhay%@X)|OlI z3%6)6uwh`g+~W^)v_v_qTnc8zOv^O?V#%~Z-iskF+OMbV9q_Ij+-c$ihFCH4#*2v( zHRE#hTFXeELNeSrCmX2T`+si3LPfy+Tbh-(K#&6&Iy&9d?TkC>hjS2^Ao%qXQn<|+ z)0H>Qz|hfZ;?yydrq0B|#;3qIGZK(TE*WzPzZXkC6Mo6yG(bwwiD?SI6Tor@5ZK-1 zAR;K;L}3~o*wur=PDw3XHA0SXPQQm5EE7zLIb2vE_kVQ1gaDNGe@Raa zlz6@gElhLGe8(gW83sx~;L_>)%B^{qVk%?sR5jI=2!4c!F5;Z=fi{z2_<#zu{$cUJ zVd#Y6`*%P2x-|L3sI6uoVxt@5QK6ipc9rVw98#c&fZHQomuA#9BY3^Glq7G)?kRm# zw-~>MU|ie=TPrJ{I4e{k~^4)Db9oja)7^FSMNz_A&* zi0y7M!GJ;n=m@v%pG(lzwRW2aAD_{J<5L8_l_-#%K?KbhjAQoXS!Uh+c)^Yd>zmQS zz9>Ll;T@KpVSiG|OBaJ+aIKFnlP|z) z-tA)9?j1CkG9hJLe!vGT_WNug`p%;H;F|#X4tJMap>~O$ z@YZKD2k3TpzkgtT`KC5?xnWaf`oWhK{#EB}lj)XiUC6-qgI13cZ^nN>Oz|DVLR?j_ z(_Ny^W9?o8gB`tQ-E=m1kJ`Ul8@4BiOOz)`x|^)NA-*^iuY4#R&EGz!e4|s0lH<4l zMc(j9$3ljsJpH~zi>w4CP;DTiD{# zhprS!y7lpjolRJ5#Gc_RaUgYwq(3%MIgX;D>3=4-)j?ZGw+Li8Fph%T{*h|5m`CRj zj*_^`h^RM9%yC#h+t1+SA#@v0k*6hp6^)+qlp_R3Tt>_eOGV>2Gm<;=h5m?P1Qp00 z5Fu9EyBO}|V6Expq^fU%=$r|gIQ^ezlNQ|U%|kXLZq2*-q4Qg?xjOo(fI11h&~Dit z(tjmxZ~5vfx1U->eplO4H&Ov~pBIUPM#`c2`<`-iVXLjF9?#ek4+w;q(o!miWGJH* zC;nAmSG8!6>Gw?!B7K$n*se94v^KwviJ2WF0yIk!|K0}?U;xhI7an1iy=}LfYX7Z+ z=}n<7``<_Wt>s7RlcM|}(Ds-#soqr?vJ(lAWK_C z7g6XA1y!OxEdJgV7;ui|iqjyDWi?4Et@T49l1=D|;;xRXRHYFh#UwLbMtszernx26 z(1`!|19H;ZmgqhQVS?xxH#A;~5>i(wNBv0mq&EnUMfBwA5e9KuZx7vUjejT}+t>n# z3Vm_mFr)4pmR*R3IV3>poUef?9=C(;iB*Sr#p;zI%9uaH2g}L#Z6 z0>I)y=igTUJ=Zeb)6fGrA%7(ZyXcfPHQ@>`j+y+Jx zge;5aH%$_IOaMhRhm@S7ST(G9?Ur}+)7GsT|cnZl?@Tyxp7PW2+hVq zcDC{pyDHO*<2tX$2753Evl_V^AivoKN_)`3-av@79hgn-`SOXJwtxQ^D+oQ4mwruA z9tPlb!EgW^4m}-GlhK@p)vQvkPF+>3;XfJJz-n|6S|Qp5rCM5eQ=h3U%~KguLcUf_ z1qc%XFVYZ4Kx(6|YKGUp>ZTUNzrhyV9i;OIr5ULcW~-L(4WP<_ynJZD7uB!|*Fj?I zK1dgLH?M-)$6)&Qn14MR{7a2e+RSW(`JBe2MM4tSx+{s|Wb}(_{H&gDZT98ZPTCt# zJ?ZpSg|70{2{zaa`7~}{Z#)nwv`BG1TQyurRtKLxCuwYvR#;!e{(;+~PpMFls!8%} z_n_-TC@n%(u(I&f;?`miD$w>x-bsJPwMnrvgx-RF__X5!ihn7M%?hLe7PM&wQ>;HP zfyi1JdZL9j6oQ~f@Z{@T5?&Of%}?<4;m#~UUeY8a6~~1;H~3&Igai4X$=e-oBs0~y zE{B6v^0jyXPD(Th;`o{tGAqjG5dWrrrVEFy`y$k>Pq@lFH#=?6Vt+uv#35& zI2%_HChWBts=5;QI7?nX+9d6Ui&dJdw?#m8OsGCjk$o+S=$K zLzgtoW7hBnx=vCx^XAlO(G_jBqk4mXRp{&!>WN{fORWkL|5!Gpgsro@X?3SP;!ju1 zO7r_}ipwF*Ca0q9o5F@!x(Qe3wyf*pa#OMt(L8C@cyKT3Q1t;$?&a?=N}P5UZg(5< z#Cd6BG=Feo+)l3;g;*NuEOwn^S80m}H(JJHF%srERP(n`uWKfHA_82+TiY9p(8(K4 zAFm5R828P}KR%s)mlf~3T;U9h+_nJiF|KQr)kRmeQH_mWSWTu2u+AuANqEiv_AU1$ zy(Np!4R$$T>}{qX=pgY3pKim9*n!21+M+G=+ka|lHl^hyLZ}aXU(w2E#W^Sx8w9{m z#W5vNx7qs4dqKC7mI>w~Wm-~oyykmXebH(U2;NbBu-LC=*l$&QG^ulp_*@p&fhESn zkV0j+wSVPZ4{HeGu+fyZ8{}TNL5Y^En~pYuRTgHgNa5q)8B2;HRf9_*UjmJsQmLNX zLw{4gz>G;TNAjoQfs>Ck5O#q^Y$kt_Llo`sZ4u* zCt7pkO|(lJUj>Gt2sw7Joz(`*o0pOyjFpfVTq*ew^Cl)e3<#nfh%y zjSjnU)+{SB>>V+c<8csIheVrM;k?P7i{&;z*^-B3uIO$U*7bMRG`~P1k$s}w}b2wH0}E2KdIF5v{D0w$Q|Ia#l1v< z-EIJWa)rbAsijqC+go2-jI;{j8`poqOtV+;Of=yhoR#2|+GwLn|E8(o?(7_pBowg; z`lVLS)V>VY6AkV4azrD%jD5OVxKN=+n~{=d zR@1rnz9iP@zE=-LG}Y^f1myW0$cgNoM7rkCr^%GY4oq}|+FB%bt#wxBx0xhV!Wht`Zv9n3MUASgApwBNpxy*TA&p+S5kQ8Oa z6$U%_>r!INwPz1-<*SHeTYuWr)yXy#Dn~jP5e&!RR%l%ww5cDeOLUXN|D?y8Sv-LY zr#1Q5A@D7CzZ4oZTH<#+gM4E2Hj8&9P8yz5s5o#3xv!RKHf6L+Q(C)*fUrT8ere15 z{!5<|m^@hGmf1Zp>T>7SZaY+%k~2{rv9h=IC~pWNBp)`9Tw6S#@qfAY_ni7u7>?bn zFov(y0~@KVile2O8u(U0XAH@6%g!?q0u4J$p)RIK_CSG=K61urvGqv$Aj1*Y22@OO zDatDr`JVx}fFT2XZOOlfP*^T7t=;0bBF>|=Kl`veFey3g?52F7ib#|stLLNBSka&q zVj72Mu^2x97qW&5eSdTJPSOP;Ac4r<#NT+eAOOLj!Xa-*Ch=;%oji<4qw(exDSCi& zT|y-WI-QzVXzmVv6@;^LlUB0H-AukG1YdLu9|I#J#AaQNjv`*boJwPHTs9Jxe-C#g z;pt%HQ&|lj5Z$&Vw>1EMUBjf>PC zH7vg@i>`HoSbtCJf&irvW=PewU<`2pynNu+a|-lA5DDkKA2-FW^J-hOD-pde26boG zY|q4i7nssW-{xqm7^yj^hpjDTKHz%=zOCvtSdnR7PUmcVHIWt*hS1wuk5W$GG_QEp zR@R1A)smo}jBz6vn&|(cl|eIT#s|?pRYIh~Y@)}=BYy;&i0*j~pU3!XY=hVn_UquF zddyWGs^HWYk4K1MLNgzu_JMk5{cZNq$*e35O4J zlac_x4GWx)xS#`eDC240AE=I@c#@XY;B#lk)hca{e!<0*|KnN=N9^DWE`I=!2?hXw zD+;L^*n#ODFkbseqpIQ_RfkEte+vAz+*!k0Sd=dz{0Im>?gp56NJ$K3g;*-az1+LGG`-3uJ9A2W(& zCqXan7w3nVR{fbNMjVr<*B{HRhYR?zy{GfnSLu_?^)O+pGzDyZE4*YoyF;7(Omddp zK7X|~mZXTRb?a@$JSw|_-haOy>dkfSiAOe{C(7nVMnlcV!^e>*%mbPk49bxhf8v(+ z1L+})$b0KT5>dT3jksPIC5^B&k2P41d1NIrUVj+7q0$pG%iDh*>G~!`KDW7Wrc4Nt4V$!` zb}=7+!v`7*eI=%J04;=)({*Dz40G~wePdTZgD>b-4ZMr?0=twZJPA9j0^A+zGDWfF zH@sy4{DV4?N37j&2kJC=xPSb-uCMSL^W4?6(k`kldk z52j=%tdf}S6D7~F54}|jD=$|t&42k(Si^?*33z8&y0lVyhS~fk#d@xbzdCa zrHbq8ZE{wlgc}w2-0#vVC~ejEvw|3{Ig;!%_-S4i_1%RuNvUvB$89oMu|-iC?fs=4d&E+iim(3ss-_RC`hJRXib%s|x zM@`To*&15pwfRClyHUh(VvrU_(>$C4rjG7>EA`^&1RjE3XF5pNm7u!>RCS9#zaDk1 zi;pieI-?3{5Y#A-A-iajQJcG-_ZgtUsa_+L-lk4dBy#m2@=fDzVg7E?K7_oaDsk+PRYfcp^M7a}K+p}_qsOF9fsu|rA%NBgA=hurIcZ9$gaOX$0feLF zwJ%PRo|3Xq-($D{*{*Lw3ssHdk}kU=YVSV_Dun&I|b+KFci z>99h;Xr8u6@us>`^fHP9;y|J#wNdXtWkv%u-Q6Os-QeRy;(@lew-`Z$%93=6SW^CU z4G)j0bG}S+8%5YE2qT1lV?`^L@rkQ0;NhG;*<9vg10$brvE~ji+-Ke8Fv&e1aSNEM z<0}KoJEBf`e`I9PUw>+g#tlFIwjcJQ6}S?!w>05?A*6%@JIMe5Bmg~&OJ?!S8=m=q zTm2u=!j&mdKQN@WlibBOnB)stO(6ad{t<}3pw~r?L4P^bYFdH}&Z0F$hnuEdv9G?k zC9R*Np)gdFKfm||5I>ZRS;VLO1mHrRa5mLz$kCG7CuKGuI)6`wz|e;29z`chQWl!=kcpl(|l8Jdaq! z#BoA5e4g(Qjepf&9Y0h2lYQ~Ejf+$FdYbhP1e;oGgZ4}B*8!hn3s(;OJ+(@WmZr5m zAms+nkKlq3!{hk6LXu9gXeMia+@?zWo-e6!IU3eC=E`PQxvTLpGocn94;JPt;z&#&a zd;zXD0te{j6(`c@_m9M)5qH__XZ7q1{*nTzNISh_D(2Fig+fa{w zL-L$+`hPeCDs(5WK_x0jP(v6f=>ygVE4J4eYVzex(;V=K<*5&+MH2;>M@ZcGGZ~ArK?eR=90omAMXNGH zkAMC^1EXw_IbMkT!r777(W9K*9S!4`WHGLrTEmU~!BGX0saVInvvHAPuv8y0G@ARR zie`C}AZ!XV@!=RH*v*JKNu?a=XIzf7AWmsNU41L%8SW7Qjw<*y~^3Dq*7T zo@}@Xj51oXJc?^!WK5@bplGHz=R|Ilpw9EFdQ`w$v0lVp!}`FIX~Acgzk?0XjDJ6L zkbX=pWd?txdclYUCo()aUHbFQQP4?#gWs5u{g{aP=9C?=+af)4Ro1j+*U{qLRR;pL;7NZ8$^P+p_x0+ z!ISm!@rd)S58%x{ZE)6Lv~;m1_r2Z!5kx50r*#5q7S^Xd_Uk6`?blS>+G!PK<8gp) z6^GdvVhhr)FgLGsy;#vM(>DyBc$w+m=z-SP69yk_Xx|tCz`!w;^%z|S8&74lWw8O&^0Y2vff1C@%@0f>|+o6&8qb* zxhNGugPi8Rn$ca1c1Vxr5P$7f56~2pE*xluTS=D3Sgao-Qn~@nKa!2Ty*wDC^9L8> zIH#S5@)j78m1MDPXe6+cwl-#QwqBH=_7Bd$v?j@F%Nk6*S=J%8-jt#yT5^!j4WJ^l zt5b}&iGphp^S!+|f?gnq`XmO1ui>H(6Q=g*WUc^X<+h^J=m8<-cYhhN>sYaBAOuF# zLL+`Kud6uzC-rqqmX~BWI2WMA?^|XYX-6u9;|e!lX|U$hWLVApfX{o+S=5_)We*?} za#4ud+w8;iP2a{x@%1Vzi_CiYl)0e8ndEG(0ExO-F^6svC{*@ROd(XtdPj^l4kEul2)g z#BkexIY=WxZiMcn<8qq7WC%VL&o?051^O1m5pG+N{$qhZ!&PmPcGSRIE!0OtB=3LM zgGnV_hBrXmGiGjks3;h8FoqA!!Pn~okQ_bxR=2U&j{a03g!@`hc-Lw)=L|i|GAYBg zOj$k=8r?gC;V@4xeAuNP=eHpS&oF&H78=5Tg4HD95IvO|R`6*YJ~q)yk(PoINQE>~ zZKNVOtix1=3V~F|m)V4fTf~DWjXvZi&xB(Vj{CLzujJ?uQQEE1q3|aCQAf7JZga@d z<#D9wf-c6xv>X#mD~1}>71fD0##_x{#QWaPb8!~U%@DUHI^oHY4BM3(WbwYO8bZx~ zvPruYY87?vYz^|7ocd)?;GjKNzs7^5B^@DLTBB;Y7ZHl_+AGt;gnYpn6U?_2+Nmva z_{h|cY6M%HDzq+Yd;u4HCx&uruQIoseq-tNj>skiMw0Gy@wz1_U%8`MHF8VFu1-+o z1LJCaks?7~7RwBXM4WR^c11aZVmq^cSwVpsFH5zo8^Lc6Z3oG35A)}lQM7(ST%&j& zTo<7w0Q|D>Ncgf-@gxMge`habNB3b!J3`N5U0;049as|a+mJ4;sgehA-^1}Y4Znm9 z8@^nr9w~TvHM5@se1uO1Jq>#n4vf!}O&>i>elGx->NS2W$G_q1RY!ZuoBT(A+lC}B z=;ZRi+c*oBK@C28k04HV2;f25@N0*9By#yAUiadQNk(&=*wb1tAO>tj&aB4Uu0`W) z$pBu?s`_LZ^~LWU&SIsXh60_=PJK62Frq9MnmA}Va%()z zAf}3+k@?RO<=7sye^9UTG0q4}0Uk_q5RyP@BW;3KvuCdMQA>dCW695gfH+K?4Dk$? z(V&w5`e$VKcMy%k)(<>G``_2Od!p}qq5hM`y-V*x(!4qIg(|c$g0OFYOeZ^N3KFbw z)2FXY5Vs11h$dC8OAp0)WRd^~R|MmO98~W`HRa_mItD>WE?b(E2C&6@nY53K1hb;3 zFzNpAe0Dhg9z_5pgjaf$%Hm!Se}qH+g}M_5_^lI1||O-c)Lq z8hz5t^5*h;L8KPGPv2O5O>t0n6gtLu3862yg2o5ApI@ar(n*4Ud1YL|0qTt8Hti4N zs`Tc8%8*1nkHW;PDG<`bE4$MS?H@H55riH6u^%;vW8a>uG&yb(YB3oqXa#^sZ>s`S<`780{Y(#7^9C;P#LP>U;q2D|#Ao%c_hlOL|7+_K8MOYx*6~ z?o}bjNNBq(eXV zPPimR@Yr-^?zOPN={EBkY+&_2zGdd4?i8fQsMUw5nMmK3=q$0UpZ3))1pI(B152yS z$&@DKV%8CI+^O%1;SQmK3U8$Oiru*bcdUsFi15r#TSVi3E44QK?L*LU=hbo15KpQQ zg~l?>?hAd-{*wJ^RTEUFPmo1xRsrMI1$$LF9I9mfAd?rcI)@LH$#X{1Gc3ajxJ7Y6 zG=WxXmu_pKkYt+azj>j#!{DlKAm!FeV8eB!$Fo7^&Wdj`0zw?a8)ijAV7|V*u9)m! z?xY?_4`GLY>|MuJ?inhT-qA37P&Ujn4YBU<0bRPg5FV$bNtC|oP(*#L&ivoKsTUnb z{rK@+$GHILStvDKB1Y%~hV8&qzeF&Y{~{y7v7ZL<{0Y6MS8e3y*`3sTYFT$}t}d@o zFyp-~o9}tGOEF!Ca07EV37c0V6bQsj6o?j}l^Z^P6fUUF`Hb0`as-J4rct!-jx0Z_SpITKS7Cwjp^E&fpU*FJj)`}^#Z+(UKh$5MU3IfDBBGK2|2SRW z?AE$8+~{g@K5riQ*_^RC*AGPp7GLV~_s}dbvf27s(e85Xd;^dy>`f0HS2hzeK?~_G z_$!m|C-JuW{k1KCq<=!F+MgK<%V3av{kf@sfu8-=TsG5$VH8WLLOe-T1Qm2PvEKAZ zZk9*ya?70hGjke^8yci6bUqo^Qrq7;LoK@D-Q@bq8t&}I*RhKA_1|sMBY7filexo=powHUzUrhF#ZxB^f8@q^iqv`!Eh+x*TA;_VLrR`6{kO40e$t zQ4l3HM(g-1*1H@2K1`n2qWtzkcW^kg5MV0=5%UbQfFDu-zu?5k4!6UFBiL8y+|B_G ztiThM<$l3a*2-_Z?9}>0Qa8P+^!e{q{(W?straW!9UpK_1m^NMJ02E;X~SoKtL3bu zOl^~eiUwSQ3Y?Yl6xX+ud`N^RCHLX$Woe^@$0{rK2f9JTf+>>8vG>mYE)c@>Dz2@i zQmVB8x%#_$BwSJJMj4#jMFXk=JG-W{`HFnjjk#8mH^YxmSn|42}?)p~IxLwbG)@m=h&|+dJHUfa`f6*&VQ; zMXKQcXN&wtj%vwd$jiqNj*&DNR^YnQh+2T1%z9;B49d#oe*;UTJL6A#8|q8VE%XsO zM&aiexE;W@-Kq~}p4}B=GZBjD`WrlO{xXmJAg9%rr%ddJ)=d;3&BH68p4S1+&pR74 zmkb5a5c|Zpc|`wk3)9elnE~q>i;MWi9F${mfxxYZoHfTjnlsgw7h^JWtk;*%?Cof8$U4=n9J%~4p5`j<0-3eRh zb@Gc*Xg!E}QF^V-GLqP51S?o{>w&n@^IDLuZW&BF)7pJ8uN(=#1bqNeZJkkRd0YbH z9nfH0VWYu+HwBLZ!S5^*$nJvFKUKRTTmhC`+n9@Z;2c&XrW`ypFLFRbh7R+{aR#p| z%*?eHNc>t8yut6C^N9_iG=>v`u=w#F;D;u!e=kUOKMU(;@Fg1=plvFH_rfE<#j(C; zn?u^0!T#Y~)G_};3S734IX#zf#OSF6oovV*KzD6_>+^AZyz*p;Ek;*(PWW|l7GX`) zQ~!4@iA8ekL?cIJA9DiMS@FBfnV-E`lnZ1ewJONFkNuwq>^A zpL%>)!P{ObG9F|DJQisdQc-s`vH!ekS>T-*ag4ol=LbpLLt1Pbe#zm`HK}Dj9eds)7crC=J+?tDME7hmybpz*`bpLSp&9e|j>U z45`cp`kAw0Fv+8Ly9kz%2igrgXQ<23Wbu`Mg3M5t|Jb?_l_GaEwUgS0{k$>mZUkK+ zX*7ias~Z|lVnHH5*`A~`iSp%pLL7xBV)^9d@Mg(s&UL!|e3o-`vo%}MF|DWewAlC1 zs29lh{0*_HhMsQZ^^)zJ0WnMKHxf-Od$w(G0bwG|i^-g|izB|WE|(`AF(@alK3++G z3CsF-d`Zm8LVREKyU9R7YRM(C}CjPd`;f$2*b;f*j_y_Fzp;^`N~ zG!r9G&bakxno^)E1DonRw#IwxyMXw}aUmMbh|&BwirY?TuUD0J9$h1BC?(G1(PMHG z8QRow1R8;Ew0YvtRXAC$rHvqvDQK^MvuNa~BGNoE{NM$%9kb;;uM286%{H3Qgg64h z1C;rIWXQev(;knu9LyI7n=T!9k^A(?QI5uPiYNpU8w0Vp#O41n|3uq5FS9$YZO1I_ zLy^1>4>o2(wjLSyG(ipJ@wy!JQq?^QT*eB{IRWH&b-Ic*TU=J9=O6fX{4)E0Dh`jd z;x)OTt1|9J_L+w2(1D3Jc)W5q#=rsVFci<(==WT&46Vo(8DWO=sTAr&1I2^}fVTEZ zv0Hu6|JGCe1a#y4a^mu+-#rDv66c~5CJYAM7LTc<11*Nt+Ka%u1r96Ip*qD|Y#X8b z48R{8sn`l7|1ZR|PAOTK5f4~d5~d%LVo~Wq=jGtPk~{2!2-Z6PRAxCbn#8 zRJo2ipMm;2e1OqG{T2k<@ zT&gdg_MdC|1sBZ^$~&^nqO-=Xe_qQ%b1T}!N^yev``^b+eum{Bk8irg@PABF#ler# z*741%5;MX&yKV%j42x%({E=nTvU3Vy;^BJk<;EuyKuJU5ILSTMTTQ+ zw$aRO2fFys`4UdFIHfzOYizu}qqVUcj`_tQ?pe>ySy)Dz7Yd zc0;xh_5MgT+cTdG-kTSwSD_>(%?8t0gXrKibt8KEaw`rV0(*{VPztP_M5Su9L8N!n(fM2=m@1t&aI(FaoConuyl$${MC56g(35uJk4$SE9pdyCLBfEM% z(J;bx0rInfj(EKcF3pv|@ze{y%*3|D^zEsj>4 ztR$3vU@0cU3B=4=GZsiDt@k?Px8|CzV)7MWcOu$0Sv=AeM9V84|1Y7O#3oWzqelr0 zxwO+e^o5>QKjyvR18rv|l0`35U>i1t=Oe8nZs<0KSrkq|$k-A5u`a7`fPc)UnraG9 zakf&=*R`nV{58@2e*#k-;YC+-UgWDMsr!2X+aGb^15(jcF@Lr9{~8Crav=OM+pyr< z$R?Mf&km7Ah<%&09TLG5>awo-FC$9K(@9nxu320fFoMgYdg@=fI`s1s9aC^pr9Y%A z*rV2%sohW#!~|ZEW~q_qrBPmsxjBS|{%VrHE1*FPk=lRvf0&t-3KFv$grS|ze6uh5 zE|!S(UznYf_VCsH0Q(81SH@)$KF{|3BA*OwTx9h|2KangwLQ5h5ItMNA=aO$)k{+F@#qXy^ z**^k=$yjHce_}&^j-}9EO-d5){g0A?*jL>qI=FTsV!NLcLQCH5wMRZD4W{txSnalg zxgez~0oDzDksRLxpaj)#^Ki-J9dCrw?W+_qJOW1I=|wcx=$G#gx+-kLt0s`&-4N~wGjn;E`tiCB(8p91;+N&$r5R>se+jVo+8;iIQ{ndGxM_6Hz~3Hk z<31mUi;y!pi{_^#0L>@;I|6Cxzn=${qUWdH$J2{rJ!;)qw%K8?ZpdtR2$6_}WN-e| zRpxa$!Ku6nw=;}~c+{7!l}!=+^q;In+$-92n@e&F1%d zqJN?*f50|{u*9I{a#sPg%EjS2yFT#s>9@=a2-;hqauJb5Hy;@%%TF`Ug>*Kir z`u_cN9k3!%03l;d5f;Znp{+#U|XI$_^^E ze>=lCU+kbn`vc>M zawldp--!SM-FOAkw1yBWD>wk^YkG=~JL#{vOn zVos>|O`vUxP9k9A8PvZ0(3`%?{$uTq{lyd zsQ=)7PLu+znvJ71+3@IHkSALa>pr{%p}FWw#?GpFW)wbj1GO5{BKOCjJToW`e=Bk} z=1KDo)t9TQ2zwHANkY>{EGdSN5P&p3B;Ohs;)AS;G|0Jkwp76-UV1zjohke* zgTvBYxByrhx_U*foD%P(^;$Qmf7-_+iD3^Zxgx|Oj3`bY`1sDsS|T$%^sp3eIrepm zYh6JR_!3-pIPYOS#*X5s4YPW6a~>r>r+0u7g|-t_@ec0prEBGDWrFc}Ty9Nudr8&> z=Cr{8=Mdw=rNf^G?}{f}2nO5yf6258If z9^vVjLplyBL)3Lz^AdjT)!3GmeKjjGSQ#lSlW%&JH65X$M z!C~d+hbJ2qD~b^r`{&PIs-Bxix9MJ}3#Og5_vH|6b5CB~bBW-n4}oN=CXq5lf7vT+ zCoY1*4Q%%8iWRsyH14&D$XpVfJL&VHLn!>>w|F9M)zK9@QwG>aXDEfmMzW<9vW492SS=$B>Tl#_?2NVf6k5<>$1I*0`z^}HjhQBr@ZI| z0RsXF6EuFYdeT~9KXs-FoLX&}=5&4Wr1@B1##Go^dW(|F+5izm)PW2nX`=~RGV!eN zoA^Zq$8hF$`G~q7B%lHOl(7z#U9SLw{xgupU(kl76<;iQeia*dT8m3jN|w!%iwkk2 zRKd#z_3P*3RL50og=$#9KW;I#BL;VbBX&;H8dsB&0z7DWW0jQ9;PULL|r z&Z}}RX3jbpfD08e~Em>VHXb^YNU zSrCo3x^mc8cs4$FHtCfnQx&?9zW&D&JDr=+1j!26ewzjNX%)%pW}>;OT$y7%E|)4( z4F%Bq3$l1S$_SsJwj1O^c9;E5>^+tC>B^Sz_9xo@nR%WXbQW;#{seFr8AT4L8?&3q ze}kJadx3aAfxm6GWiXc1#4B3W6R7t>u!*e3eB3*kiZ zBkIn4d!uMD6=DWo#K6ATudp0M&TkEwhTO6~(zllPO^VLEFSd@06T8~9mFP((zD#23)f5 z51_D9A_%11l~Pd2hz&oNuAyLw>4U$#wgB;1k1Jnz_N|3|4cu3UD)58C*n!HJSfGwWinWk{ACkOgp%_Fkhfn6-)2-&%v)u93) z=xfwEH6M?gSf`fTUDY|y8G`JH0y~W{D1TZSJsjAXz!+fO#7behrU;6pe@;|5erqg6 zS$Mu6!=pqru|L_Hkp8#lgh?Jt3-*TXsyvw6qx*akYVa?J0xKh%2^&5lX?Z;kl0~Hj z#fo+qs^zb4B{-U>WeN;(3FrQ00R`B#XFl5npu_D<@?j56{30v;XKX=TD~3 z(-IPD?D2N|R~Uus3B}&ne=grs@SwAO*|S>JV!C`pE!?|>=x!SQHzAr^mbKJp3BUv&%IckH|f*qR9D=oYl5J8c;bClPbKmPrs<_;jQQu)by0~oeQk;k{!J^YmLxb^MOIdYLLfO8 zV+a@z7;6&wj{8`^{~|N@a;$yXognfD87P4=U}0Mjl_aQ~CS}V)d{~CRj{{3&Q>I`7Fn@Cl1HU*TWU0pS66Pm06_2LgqsC=m zRXep0@;{H83!{uV@bjUew~0= zd)l=0?(;ialiS1)wb2Z1`tY2jgUY4MIom6Z51kYY&3gGzRYbs=*y%*DF~!@ z$A1Oq+SS}==0%ndtFv5jaDo%EogVYHj~M1IW-_V(Y#Z6ej<~>*s!pg8NNUw;pfWt3&5HVK^H#LW-&z;}$(Td2Gk9)4L@ zZI;^k%+*1=Rkt8HoINU9k48G{@?G)BBe&6l!-}vhkybm4)kE=oZrTzZ9x3j0nb}lV zJ@4Mbv5nL(mLw`Ff+9rT*!%A)8E3?aM0!|WGa+XIh1&uHKo;@~ z|G)THG4|xY;Eo@P@f?nalVFY9;WmX7?&oS>v?Y&P5Q1y^E*xFF`$mGCYwaq$hxGSl z=xeM^Uohb{jF!+AKqPCI5NitGUVlAAXLfxiJWE=wUG(PEgHRi}%NQ?Q=2PXW&F%*p z6xqaoW5x`)8MM5cMhM=~lVBa}JoAM(#aSH7aXM55@~c(Ef@%z*n9s*+5A+3d8!gLX z2i|c{cKiKAlxHSnTeGK&-&cBgM~IHlNTJws|MJG{6*S)Vc>4`nawrx5@6Io)O4VJkJbv(bn15WIyQvrb8Txq9JT9^|#`N2Q zb=p8NZI@^l8*n{nKX|SbyDmT)e4X%!yKqmIi~+!#H+h!}eKFCMuKcQ^?{(npFn*x(SI5j~I4_x}_$eabnVJ3lJS$$uGq67jka_%B>& zpcIMqrYIgIG-o&>>{+x>!HI_8+*n+L+`VpZvUgpju8x%DBJh9VBN2k$$`hI#04E`E z`W$-$F`SXzzp*i`bNW|G21z&otj=zpO(zs8j_%+5&jp8ITzu)&D57UhJV+rm>5Eg`0Pjn1C@I_8BcY!jMrCaiCu_uM5)IS6>4Zj+#FzH zCTFg=FJn{T%4mMXhZN7CWy+3%1*&w+@EF#0*5JI`Dc$hSb9|Q@Pj@D3zK~AqLm;8& zJnOj?>4>;!3OYAG;2btT;sUf!aXdkCS`g3(#zClff6xmZKY!u3<(soF6a|(BNkrw9 zhjp^SWp>y=^E@-o33)rc32||fvs{I9*|Bg*hWTMr)!$6WvEj~lSwKiiWA)utfY=6^g<&3QZMhvQ~!XJ@3Zy{Z$eDZHKImU=LKcPj4`y=9eh;fEqq^abd z;;n7!ki3(m2qM2X$%^2cF!ilxU*wo`oADks$N~Ta^Usc(551SG#d8nr&K>T3$-(MvB^#1_I@b4;jlT^IT z@FgV;KY!=Xj|CP{>2IhVfR&TOSnXCqm5t!a*W9agn<r+
    6 zlsU3?FQmlnFwOqi$3u6WZ)Wv%a*E$r6s?%?VGiXCBM>SPov! zD>$Ndno;AkM-iS9VVhCJZ4Rb2e5s#z{3q|aZPKEQRp&zZX1*8J8{B`c#eb+vS;D;# z7dOiM_i)ySV!ApgkCXB@J(*oF@bobd%4412As=g6S{t0v4AV>4MZcq<;Jlnxcj1TA z%`5njJM~1*i>%V0WHgO%B?#rB@~q(4?_z*ESYhz9-)9F8V^T6Ox2yIf6W*E!Qju2F zPAy8DR=JQH^7igRT4kf*bbtHsD^mcJV}c0GG=7NQmi%-gFOQUnLtV1}ic^#8%OR{4 z7f2(RxnUruw`VW{&uQjfTS+Q%RY-l;|I;fzwR`{GJ)*BqV+ zRnzG1^{UZX!j&!#!m>6PEFYkWZcV&tudzHtsvAPCvzutja=RGgd4Jjgnn{fB&uw$z zxidb$1D#8LO#SKzG2TCB!>?RD-Cu$mRf9lRwPcw3d$Y0Vqu(X%8FJ3SpZhn+_)F@_vRp|F znm0<}2fk$Ae@cu~D}R7q^I*HTg;q`it}2}#27G+W$X5i8!Rw_T1rhbN_-x2N+OGXh z`;eEo3%9nKf(}J8qH&T0R;Vf=YsF99<$V6C_N=D2W>XQXmva#fs~##JxW_I)s+t;> zqMXYcEKpCWah9BZ#X>Yi{F~?q4!6{cK2+O`hHic-N{pnbC%J!eEOu&Tvw8ya$*d< zx|t^un*RXT^-5${htaHpA(j(g*iQ+e@=dKcL9fL>=>W1~#QXjiT`�I252nMcZTs zZ+mkFtx(q|RVu&g!tE@Dj+0i&b2n-8btLjbQ3T=8m^6Ca|(SM91bw4RyxWDQW|ZZ|H@ck_}oDHL(uE8L=W zsek-BW~i6Ox6G`C5n7OKp#UGC_grQ9J;nkE1ydg2WG(g8B&ypKXOKk{H4GwDIdh7_ z;x>7oLAqIML@Z+y2IQ3;{dX3FHYttAq!7&Z$?)Vh9RPg%>hVq@&Y4M0{lAcSJx)>< zAvP7;J5@Xp&%>;%MS$F3hW(@!_csUf<$p|3p%_>z7s>NrIK!;HLjga_Xf+pn0@LIMaDel8ckXnuI@!5v8J8$2bYZ}`V*cKyiveeDpJEGHfe zOA=i$A`xSQ@7oR-P%uy&7kgQjL_NkPV0j8t{hiRcGoZ8rkAYP%hP8-v3 z+P72Zi_9^+P%nQg>z!^p?G2|HZRGQ*U32!;IEmlUuNV)&krCEXnRR^6z^Zdqkdv7p ztl*5iuga+WWt~oul3~&ls(%2S7ua;`1k#{Q%QGyy{VO`Y>EOW1L|?)%X9-dgTvO2H zZa>GL_K1FC+Y^yp4MZhGk>pTW7vB~zyc|N6?c?}2VqS~LgQB-?JsSC|PnpZF;Z|T( z(w>sgN;=DAMku&;Z@_mtAD|>mbeNY@k^jF8ZDDMXM7%w^=sY3D1b@VyJehb665<@IAlZml0)R9xtI3QQ-YBNd~sr=5Vv5I1PEGy6Qo)f-4OU^CL3%}gLujw z!CZ1KT7>)J#J{YhnSYoa1}Fn(dDzQBUe=9`@O1Ed*{_u0?oxoGs332_ZFOCu%o~&} zUj;KEWAFw+0sg~J^6qybZTehEvrSu*w|(XymsQQ`_vmi9i=#~T&ou~NJp-sn?`K`N zpy))RGxgnJgSchbc6hr}p6}G1tbGo+t6W5>7sPD7h}k%^ihnqtoEX<30Z+@ZNGcF; z60Vez@HYg3tY=u|Lj+y|yP^S%nilhvs94SejPBtju^r_kL#crEe&bSoZ1w{#wof0) z_o=-Tkwu`LEp9H>Wl%x2)mu6IWvW}TeMdl)T4>W;KxX)^zm{Y2cPi3ckU>pcz991c zWG9&&8=V%>BY&bg3xJl%xmhE3-k@&y7M=>u8Qp}?EY=Eni;f~Yfj$8I|K0LHCwMIA z&2l%!nPY9F?I=q$!uVrq6+v(I8osWj+y!>}H-V|R_^~#CeErhp&9v$uu{0FB&1(j^|gQhVJc^p?g_nB;slJV|&CZz_i0@!c) zt6jp|$U)?FlghMOWEh9ft4pA$4@BKhVVvKgt@QCKZLh*b)a3C4g zoRR0%&8YzRD;Z>9HtMjY{`pmBznp!9eygq|@qf4XGk?Vh5Duy1@Y@p|b`by(q3ZB$ zXf1h4$F?K7&ODTF#dBhlg~+P!AO&QtKv;hnMGy1LH6!o)s7-|7+?EI}PkhHmJ1Ql@ zgm4Rx(~pg}V1RIzpnl4|GUdqCsN=>;^4EpO(Uu!hRKE>i3~;(wR%|X=&vCF2120i9 zdVl(=QuZ=ZQ<4#bT0O)ywk=p$*UL|;8$1!(Uq@(Qr5E~dobs=VkdvJNzeQrlJ6vSA zj^M8XDN2Z%n8vv&v(v+BFyGO?oX&iLl#ecpiJn~|BQ~l;?O{GL?dQzLq5Oq{W$$H$ zYbwds@AuFjuJ;?!!XV4Q%2O*a5hBhpwSRuN(BGizY6O+vzsTZijz#u?D5VL~@Zz&H z#8;iTkM4(^vE0gYCl3lul($3bylzk=!-ZQ{I#kwUJTH1UlO(&$y#Ogu^0JsdkIVZ( zb4NzUpJW%SJeQUYETwjiVCluO5b8$adBi>zMyaW3XzlpD_5|e-SrmwOb z=DJhG_*S0#w43^lPRj?}(sBDboMZCX`q2DsawEzd;~(FQ-NNga6n=aU2b@F^MINSD zsurN1SfC=LfFiR~S>qzGW?%Z-eOv8CB76^P!I+mpnc#P^nOu+8{25}+bbnBImL-Tt zAnS{7;mbi&oM(+-n}H}rH>=d%6h4H|Qz#gQF>{}>>`WlW&Y!krNa#}`O08=zD3YBj zSa~eEj;?c+_@?VXHAJ9R-6YloJh8aZ9yQES?W`1MW9!WgV9^X91506fu#ZhOwN`T& zfLy&#m&ptL1e$k58{>6{sed!BFP{$JC~`p%rSQ#LM(vHol32W&j{S2IsiX)jd>&wb zxxsoeT&CY_V9VX^2D%nXeT%OS{{HWp867J^q6X;<6m=L5qSAD@{yiEmo#+Kj;+Urr z((*5Q*yJ9)wik;z>>>Zl`l1AMg{n5KMr8aB>$@3I zkcoMTD171xr|vJgg@3?IvGefF?Kf&6>G^$VB|eW1?7@({=TsH83kmpN^CKAePyo3yp;{cF7KRL)LM{79bhV=@ zQ%WzjPn>C<8%^i~%>q;o6tUj7{m#qq42Qo4HK;|+IK_TiCV%uchU7&;SF7Lq6m1nP z%HMh_AsN^t1gN!?3YT4EsdoH(UPky0iDEjcq{o{?B;e0!R&_jV6QCPm_0D@tt&KD) zAF(&uu=}=lMH^x&a1mIFWByb)cA|0IqxYiE<0)l1r9=x$o z;+wKU#OJbp9e?@#^W4=5#Z9h7_rh^?kB>qAXQJutH5*EVa^gXu`J9D^nQoH$)Dn4lDK`Xc_Su z`)UV??K>?;#A^Fd%|o0HMCptcu5Zsyc?aAKMslF9Gk^J4vw3@*UapfdoMDv7@pF*` z$@IZ3t4k#88Zj?Ns~Ur;1rsI@8W|uxOwum0R4uEGTGXd*K>u6 z>XGyCkh#;iv0RvC!jHU_G&LBJgKMl_7!!Y5=>?H20WtnkQFOuO)t4J2!lIf^z(tbE zhF{;0kbiI2=MX}A^>O&hzTy1|5AP-jW63U&-Tl`UB71|#5p7Z`SYt{2H<+)jiCHGr zAD|b^H#5Qh$ou)Ulj5$Qu9`5x-u->hNJ&4-=fZ3m<=^5!$9B-gYlUZn&6NSHmhhXr z-^Ul4<@FbkO-ITw*D!B^QAq9#)#R&BdiCa0t$!ekaBCyUsCTBcWYKB4^pYa$`cBgI z^#3h_p57i^Qfyy1*0KYQs#z>Hl0tDk*UTl6Mx(JO)Sej1%Z@?r*IdspI;@%a1W5o8 zr**?UgA8ePk8$P7+G|&p!BP?WN7=_(d{yzj#V7fw4c&`-W|r=#mSf5lS2tmWjc|fu zUw@7t%C9kF8g7tr{v{ zO4qC!#{BseXeb2_aO+ch&GK5P6l*v85PzR5x);bJnhwGE!<(F#qv#5=N?u?HwF9Tq z-7bTedG3W46qm|QWx8W|xiKEbLr!-)>W>2cJ6&m|6Au}@;T_k#IxE6|H{~}C6Uya& zkG1zUwlr5p(%@S&hx)}cE(X?JezI}&qJG%pENBN(3q*NPS4AXhksGi z%!rwiIO82?lp7oe5>ZLoHzWk}L8W5mn-L9#)F3mX7(l|Mb2Oy5lmD^bR@AZs^C2r; zY{#XaU>C&UW?!=nKhVieksWP|-jMrEcu~VCDO)0I=;HAbIL-g!50C`0dwExa5IT>U{w~$+tLK zKuoWnVjB5)OAo=*g0Nl2$W$q_kv~<-6XX1-%r}u>7WTc~5S~{pD*jPl2>u}Up&$s) zk3F6l(?}jXv$;NldjV9!H#tTkKkHKxyko1N2Z)>rkAR6JPXP@@%dL)AFMr5RGH9-{ z(C%RCy8U5I9ca-<@%e85^(>7x&gutx6t?0H;OwCNPOM>GcikPX=G*;`^INbcgA9-p z)uH@NUEClWD~tPsfEn^}5gb)gEnjuZy+zO!{?E8#j(%ls^vAVpF73opCD!`mpu__Q z!R?Q!qRMqq7A8)XAxGIy5PzfN$}22&Q+Y8tkcGkRt49BVYUd(oBae}F`h7Q5doZN1 zCkdXhWmWY$PVDb2eZA?UG`G>%5Fu;P5J#IMbX)JFshXc{LTWPQ5@S<2qot$qK=NPW?e}K;pBDiOb&86=0z zz_sCW2djUO<#&28Yl;a2^9JfKGQNO-sCuPq>(M4(M&gkK_}^Ll6FnKJg49VPDN}U^ zT4->>V8Z|Xl5om|uzyp)JfYkbGU?#Q;Kay)Q7qjI4}tCi8c**#+L0($ zN?0gbu)M`@h?-MR?Lw|Pw%RZ6@+_<;Bc<>WIrMjK=ZZJFtAAKo06B(dU?}`mhxMph zG)1?t{(hf)(jbL$CYM_6x(PDEcOGRfs(V9@1Z(g{ASz=SvH6G<8Eb9><@2w3rDnTY zIs5qKtiy`>xARC!G%0(^g1u6oxPbXlXUegfj149M0k4 z83soO*1bnKE`;hlma?#%OXS=pN3rSv1g7gLtrusjeUu56f7bTQv?wRXcw1wZ-IAxH(}}X63tE? z*IEn|0X@oc{`JD>3`wMFL*44Ihh#C1Y+agQH3 zM{%T1OQ%poY~M}{LVlHBA%16$UUVGH7@fK`=`%g;3k2k>6wmLmQJ-kq43?wuk_@qfb5-#IRrqld>{d4=JV_{IY2m6); V69NSHoQkUPoO$f1PKm{?q_&}*5S9P{ delta 24790 zcmV(nK=QwU;0l1i3V(yxUJ)5ueeMuKv->swSxubIVa}Pi-ca=oA5T;NA}L6f!mrc- zM>+>e+7$W6bX>to>b9kg);Fde0{Kj+#yQ(>*F_1FrYbLE+P>9XxK&2|OXflqzf`8| zTF>>!djoVSntFT~;djudklHiYO*+hY7$>xHu3$hi_ zgKdnHs64N3UcD#-{tzS!lwtBTF8i-3l; z4xB6!JVcfXiXvD?7%O#tD*lOr9H|EsbKWrN9%U zfJCtGE~=OoE0p7+!-uKo#+z9(-&b}=zOYie8hWsgJunSUze21_^%CYc=?MmYqjviy zPTTz?1kOi|N0Ln>(VGDf~a@`=4}Vj^7G zY268=A<34-gy{ke`)Oo!9)Ijh1A895@5RM@ds=i+Y8&vGky_6W0gm3HK3al}y`?iAkbXvQ2#eGa;7v{1TRluOf^AF`w{X1cp3p+is)J`ua{~QYY}EqHKgY zZhwAmJ=~-gXA9sLsCX-O?~PD=*$%|F<)7z@+@e$w#!8B(XWwO504-$C1Em`*(oPe} zLK7^h8%)gKW&G!lf9BhrTN+zrrU>k75x=HP(GU&^Us*MDm>!{Caw&DN-K+t%NF41w z5a$i3D<5?ayIsP!a1FvcePrDR>NfH5(SI!+G7kX?D}0B#xjOxQC?94E8zJRS+|72) zCkJeHgyMy_%n5)B{d(Q+nEG1zPH>>|L5+au_g`W?k7S8oTzz6|G{M-;`y$Zsf;i=b zsvVEn#B`O`x&(=$PGb6f75H+S?FKH)(W`0C#1Srw9*tO-w4buF*C)%H;im&`)PF$q zHFHFICs5n1RXF?;DZ$kVrp62swqznhx=vt+?jmolU~JrTQGT&@GTm(lhi1b$(NMrpatino{_?o;@8-0>S!Q%XZisGSq3XdW=snxSEGS@j0=RvmNb zEJZ|Ne+MZ--Zlib0v;)4@jT$+&VPQDFdm^y|2D82`YDWHy7lat$C{avEIom8YQ8B=sM5Zckr2i%}BV zqlBdks&wk1>%7cIim9(}ljGS-Bv3$iw*nWbz`lKP>EcKCFqWYsPiH_*<7dP!w&)Wc zoP?v7v3vPJAzt}LmVY-Qt(}e7D~5~<9Qg5wzk`?31j8WIgFyfXj$Cki4CoSkeqF$S z><57mu`lx;Zi3y;*9Zoz1}r1FbI9?1yq56%Ov0kA!QiN6r+|it?my_5hVR8xPRqcx z2`N4h@>SR9H?Yd&I%==yCPPe=X-VfIf0}uO{Tlc{m2dOJUw^u@uuF%?v)&g;?f`g2 zV;(V#UHr;}#CnZCTx{7FaE6QLbjHqTC9AnAraC5QG(p6qsXWexy8RT$`67hhmT zs=b!XFRJDxbt(DTq|b%&#yH1qiv=kJlwHG}FnL)qhULWfc==(Q1+R+fHF5o-=J; zeNBHKLtQMDO7*y_WG|TNCC`xc25(b*(0#4- z%dVQxdnf<7#LFv|IngLWgksFBOvA>$p31P)BcDu9i}G@^V<$K6WVinF4}IDXPQuM{ zQ&MjbP}s&U`~+$MGW)WXnh-oNTE-KGHr#`GK!0%WQ_CSl8P}DC55~5VS>G83^)LG* zi8LAhXO?)MxFDbyoCx3;z4ujP z|F@JZfPC(RPCpds1LymhJ?=q`ME;J3MvfaE@{!)6t zX{P`(q{qTVta7}Pd|^f*r=2Fp&Yl0Sh}S-OQou2-<26WldZ1(F@S0GLIo%Rg-~?s+ zz%Q82WUpP^PR&DZveXmZgZ9hYQdA}lKP-MOQSa?-Yzr)@@K!TK91wdY?Qw)GhJUGj z7Q57Ur_#$DcETM;r0)-t5)*CfB){=7+s zk>cL;tY6Stks-Ukp+!sSxgZD-)l~K?SXkK*WIm*Q^iZWLI)#PnVGOb2_bQv@jq#*p z1<807TI&f*&Gi2D1-I_r~ zsoh@6*6H$c%4rrKtKk5#_#W59PnQ&7NXN$FM`p)rq@K7O>v9R#h~0TX;N}FqiHFT6 zzdDb*(Ie7p{s-IEL@=V1>w3)?Ef>D$m(4x$N+t&VK=0D;b^>^ri`(MJ3~JaD0Yf)r;*nSh7w9sTAmG3YgF&8H>GT z0YF5wGI|HK=UleMo(1vT`&S<42~_z!Xc!)|rw=EIx^ovZylzkWkB9mw2aNYgmdUQ> zSED(%2h!m_>VbitflN|Vay?#?(`P(Mx_hW&jHwSXel-_`Cx0AG#`N`lvL7fd&=*wG zk|;tq;{x;7SVV6jn#LXYs{Tc$!GA`R|EJyW4cmowut@J85lb zm%EWK>MS>CzD9i>Kcza@2RwO%7TJsvLE>+`1-9PTH zU2e`}UJVzUor4O&2$^qvdg+5y(?lp0Gl%1%b9qFJa;lI{DUAjs967Ch@!Ve+6z$wo z^ANMU{5~ENB+vto_>s+?v5^yM@o{AT=ut&8%4K*mw13;>H?*w#wEj!VYP8MjdMVU$ z+B#(;!=tIM)ZT+qMTDB>jI6?}W?QFzUInr5tHE;717P#N_MK!@Ep?GWAjf0yoF&d2< zgELPxyKo!E^iYEwFLW`^h40X9SA!e6rEFJCkbb)gC@JPhK#X07dIg|IBg9Mb0rgSd z+sAMbAuOP26lZy;hb<}K^2Gc&6BCf(3?hZsO@HifjjGxuG96sOUX+7?M==?0vqscf z8V{qETYyMpLc|W{p|^fq=@^LqmD7}?7}9c0i}Mfd0mH#FfoyX3RJ?S}QA|9|aZazx zNBZxnn&*zG51F1Q;i1P@vywl&13`B&)L~-IINTHt8+|8+@PCU4w7JhaM6aKg9FLOa z&LH`on#haA;#-YpcKFsmD5DlUg?I6DP`O~dL2>ShZH}T45P!Ratw%eYM`kawRpP`| zr%*}{^IZR(<=K17SCAKRMo>hsvLWt|ks7Zp`La*gqGK@e4^!oq3D3P?f%goW?!lO} zNJN8^&9%1p^BCJuH0ACxqA+PdW$Z{n@yBX@0lQ{z*2S|EzDAfEaZ|SJ;CYp@&sCVVKs;nuyf+ zlB5vNL*d_O1{U{J;sl}`Hc%TuokBZl9T28A?c_(XieFz}OVyL|dx z=3{61=6~4JMUOU-UK%>UM(KIuQ+;m1#1lzszft5o16}qEArNU>`=;^XhClgzv`K9Q zm}w4r}I3& zxmHDn0;5*nG{v&6_pQkEeyU|gPmmG(r~+`u0V==&(xya7QM~=cnEn9`nt?wV;U|?N z8Gmu0w45Rb<+n9f>8<0rC0Mn3lh_<8P-ETGeaJ%H(!>70CZ@4wS}8D(py+x~9t&gu$E-}Yb5g3gLxDU?hhknu0)DD|B` zA;QhAqX+)(8l#?l_yx^wS~uCjSg%J+eP=p*zHusLOVD5lvI|JO^W_Dsra$c!+GZ0IR))~h(7U1* zh~;`9Pm`)E8*{icn-tqjzI@BBp*)dKsbO)l3E`GuiI%ufr6?AH#!1&ls?B+eQA*U+ z(PXJNKmP{6Hxa3DgXL_@(ddtMWPkT|#Du)P3Y^X%aq>9(BeuUB+v_g#lh-y4L3CAN z8bQ}ly;k@A2X+ZTu|TO!=01u07%*Coip+^%l$t_eMPtl&zJGUCIzZU{^;pYEaraO_ zybd5$Et$+u<-nNfsGc${4>|XPV~7NMtns6qivGJ}%emt}^_G&z>Ov|Q=YRGW6XPer z|Ga1-1x;UnaGarB;SkR09%4^=H@d|(g6h)m6SC`5QG512pUUQ|%U~QNZ{{H=?}Q^w zbU$t_;NY=^n#EB(CZdv|CdZ45Rup*u`Xs2tccVQo4x5|N1UVvCrGL$pF}`S4y;POV zTpt0~T4+9wXAS@`#VGmsgXV$oE2aEET!7o7>9Sq=lkN+fL_dWrz8X2_x-D|&2NOYy zeqyrwR1dE=9AvltZg6k~Gs_~uAWLco=N+faZ|2mvYa&h8&^(vmodpG8g!8A~duK6- zt44CVrB&~}P}-7QwttH?K);^LhaKo~)(seQ0VBN8;wNWiVQG&qh@#^}HGhp+QlsOe zosvPG#>$E{nDf~R=pGdkLQzvg7=}JA$Agl(>VB%lk>6kn6K(34OdKvU4;7-8NxQ^Y zeRW(>)ix!jpSLV9Uaoy?+#~iB!YBT5!Iy1s{M80iumj%$@PGLKeoeE?bBu*4&Dc4z zdwQPJEALnz2*(jyQ``1V>ZQeMEHek>dtVH2lljzwQZKJ-TkB!JHK;;c`a82C;|n7; zEu9wV=U(!TJM(-(s`~sp5k!-L)fprL}{nN&l2V4JJ z%*{XWaexJ7V1IUed4jKB9syHTx+sz+kQOx1`vpO3(wto)ulfpd)69IEn309^^L4iR z?mY8ofI|xnaK*QU&Lw|lHu5uJK67_j>(p`>ZnXC=8 zjVXeGtzfUma0{f_9aS|*Dr9p_S9u33f96Jx#|oYAR<-5ia)hs5-iD5K-R1<+pIefJ z2diMeISeMqK3b)8>@ut9Cdp8wtPFh|_!Zf6&Tf;@I|4`;ZgSSJt-3}V9x{F=y!>_; zd66>-EPt5p8=nQjZfpp6m?-Hic+&>BZPvRSf^&hIoiiH!*wWx8%B)lj6Og~7^A7wN z*7e=(zG<_ycRg`W51STL7nxbWPf5C`%gDn8O8g&Oad4gnfiy0pWmp^gbK#n}tBBGVe7!8$uke2Z>iW$VOuyVycXea@)=3>iDe z)?W~&Av~&pU3PVK4Pb}~AYiVZ0uv|66Hu%}SLT5df%3C({{i+g5q^n7MTHhP6Lg88 z$A6V__}Hsi004=li|~qK-do%!a6|CT(y#Mhm&154ox8dhgZ3n#wYrMr8%D)XGFfZZ(JWf#e`9{ZrE$YdAG!hgd~ z{J**-ZeiOpN)j5=;FSOsNPinaiovEkZi4El+)g7l*7sHoCImCPxpsfDkd|mn?>$dp zTrY}(r+rhXHKr`xVT9sxO{c4&%}zVcs(S4@emBxKu%okuvn=Vn=guGxy^_GEvtt_i zQm_%B)77Aw=O%Lhz-v#IZA{DoIsZ-6Se2PEKUWpvS9w&)X|jwPF9}DQ)zAVPy?reu#&=@n=4Be( z2^5Db2ih_+MiH2y1dB1pI)5Hu=GRLCvsg`eWMGQQkO3Zwn8jDMJ63sTG-Y3J)kNF1 z9T{o!x)ImVGdm$CBn1OdEWxwdIm*PwH3ya2_v4Zz!sgIzFoFC5326H@^7%9sIk3;A z=2C-BD$DKqa)VZG#J~(!qdnL&+DT%l&1BAAj=_!&wf&mPGB_ z%`nDk0jLHp-yd~Mm9DuF+x~%FX51gut?A_P1|6D?@i<&qHmqi+|LvJqmHU>a2d+UJ zuU4JO>g~prsfn5b+immnORd1}mEP~g+llsl%b^*cJbNnklTssA@cSk-S#sd9_BOcS zyB2b}vvy>%Kht2a<$n>Kco;j=i&mHz_=fF>KhNKCAnt-x`~z6&Yv0-*W=ta7l<~u} zYHBcYxbk#;2yIjGDHJi`b2lut5nHfE7_}1wU=u8Q1NBSzdL%uNVTvXpoD96Y5sCml zc4Lr`y~eM%hIE&V9e)O@lo!Sg>p|R^tii5C_7j}XM%j_Bg?~~`c(x?~Q%`VnHPm|4 z9#bPYD-LtPFW3>}KOR|9e4Jl6;J4fBjb`m=YV6^!7e}5`0WmgCzeY|l<7UKnfR8b- z{;GC3NCqN}=W%b`^`c6kzf@2_;DOPFy!1-RfTi66MGC06L_<%QEp0}9BuLnu8%5OJ zXg;Qv(h4iGFMsbfNJr^p*KEdG!DY~19k^NY6xI%uP)&+z!&CZ=jL%1tr?fMJs5Oaw z%ei+?e4|_nv**(`z4LdwaG`2{>@ugeBzxdkZUq3p=1GIiS4kqtxI(avgP#iP4Ro-LL9=4K-sLnF@Q^HLUs7t6RK(G`Bij$_4{?#t~8anxV`k- z;%lNDRNebDl!PrRg2R6o(DDC)oNXAQ7daOG%-r>9$F!Fler3^ny`Myi^7DF@X<5Fb zcJ7eVHGc^PmYdy?e;%pbaZ)+7cr84A8u$f$+hb;Ii9|}i^y`_*WC{&%iB!bt*qPh{ zj)B}LIi_2mg;avwtSc~Eoo`#ZihY9B@sNL6449dil{2p_w_76oS!pw|j9A~ZeFF$o z<5|fn9Mm8qhRZxS;=O+3!NAzSxuiPrnB9;#tAAU8KoIPVieVIc+{4ex7v3az7fXk1 zoKevdhXw^I!d#Y~+C>ue`OXfB)vm4kUht2v?U0o9D#LM@TKKV-c;3DiLW-a;QP~+K zR?&#A+hOOBY|?r!Qm8l^q{&#+@4=ya@4~D_!`^Oh=d#@N>mcRpUvn8CvFFjQCj{NhmA>Ve9MZIQ}3`tnC!v?2k3Jt&vgl#+F*Oj@kAT$GUPk&rHdR#^{-Gh_x%i#( zMv=ke=NDGG5#!YhbWx!QzI7rMy)C5$i@L9*84Ews8| z&T*_V85=z{^J5=gtW3-IVG#cN)Qi3w*m482o?5St5C+!>ffo!uzXmtQ`(tz#1i!NlRo~h6} zw&(mGGF>|)#_;isy*G7dbEFYsInP^$T6K<;D!ePG=>^_iO<8DT8yM*=byOUMbUkR* z(+vT&_GQtDvXSW);2yVfLx9kHB}upLw3E|o6qjryvj3<}d_or$mw3!?>VE@B8a9Og z=#7$RWm5pY9<7ZseQhwqCG?{&=8b8FzJsE74==;?QfkUr zkVNYLs4_y@0lDp!z=~AfSqKa(YBp*e3-hsxgOj~acKz)8&opQLhhE882h4)y)vLdn zVdY6Ez5JSDKlNg_X7po0jDO(8*4gl_)Gtpx9;tthbfJ!*%WzKL^7>-tw4|LHrx?io zS(0jPWm>rHQ7r;{lZFhCJ&#glzub-ICyhiyQfE!qUtXlfX4J}WdtWvtX}6!`C-=eT z)y5+_H*7x_{O3Hw0{!G}y*&S~15b3PCPm2=}rc-bD&lDV+E8L>y1+KIFmf=QRQ#3qNQ_zsFqI&4lK6 zk_CGekIr@T7%a#L>?LzAc=y0lH6r$cD57-_c~LYj@&-m(a?h2$F}#lODnq_Dv!JnU zjPk4UlDWMG1_+(ohkqQ_EYAA!S)HNgIyu0KYSkf*PzUjxl@Q_ru}b(``A>+PRkr9@22&+%}>GCGrei#EOAKx1t zS5B6#9+(-miGTXY_|h;$DM|kKVtT1~N206|Wye)qLf8|p%O$)nM_PAYxhj6FvxxUu zW3oYiFCVHm%1p- zG&^DC5AKJ$4wIaaq$C{4G<+Ive4_g*f+Up~jZz!gB7bA+$bxp-YC0%wO`b*_Ls8#6 z_|rsFR6_ossXYb0G_24}ed77+HT`RknK(((JQa5U!$zZnw&kK`&v$uGeK#C}8r;Kr zjVE}K(OnR{JW}LeAbBVXN9eoh6v~$arlLcagtfR zme`@c@>WSzkH2DX_)Z!MiQrzgc69-YN>SQ@5Pui3(Kc|sC;muXLsaNYN4k3r<_jwl z>?oIwM;-u?nDFeLg6+|}fLv9N&6z6yMakePI>u;!yMWJlf%8Qqvp=BuIyT#%u)l>l zX-w;bA8FmfcxFdjd(#_o9auX#OSeRa0<9&YEWF}8=F;01OwfCLK8XG7Z5>)nfnP&M zYJU;I5%als^OzHQCQT*mJAZH$qnBwNY>(SA0h@jlcrz=exd2z=Npg{8kO&~51{UY%QHj9?^-TPn1LUefO z{{MsaW~gz{Uyb{SNZjp`=8^|rLLuM}MVvM?%Gr zNV!3E!k!2;4wz*qK;!^&5z^E_;Kye+Ib_?rE-l)D0VAPYSD1~&GqXZ1)T8H zxcgyIzu%g1Vg{0hTk!L!Q6x7fjS+O@l?}LbWW!<*hpDuZbSx%aOlLFaxJv9B>*;WitVfp1r$X#_{0t7k^z>j9{Q?CZCKs zAnsN(B4GQHi{?KS{eE_L`p$4CjvpMV&k5B>H>}9we%H*&rrpz>>siJ&OhM#l4|Q^S zug(KT>zUM)_%_f(y&%UVl8{^XoPXqq>Kjt7V>3mb^k|qyHNkc{&8)Bz;S$IafR*dx zG4A{Cew{JjLi_?Rn}7Nsl$U`8Bo-h0_BA@{ccdog0zB6vn0d6%pCX2+gEuNbB_WTq zm*H$Uf6Q!>Y+5Vja7F>%5t%P;N6($1$=^}9gtr$zVJ|f*!YJ!>&*4MVQax> zD7&7KvN#qgy*C6-pJCHhBx0aJ3vN8sjzf2sX_F781J2s@#@SH^j8O=kZ7m?ma`=Ok zRkF>U{{ui=fAkjLW8?yc#;DQ`=n!6rucSe%;#$qU`Bg0Js8#7_ER>aXW&K_r>fVN2 zE;+ZZYj9pYY=6%>*~=NtBOqmlvjW<>@n?6w67&U9c@GgH~o2E*qV znIDUqSo|97)|=H_Uv7{{Td;oYe0Ws}9&#ouX2noryMOA3;=$YfonPqq4y*bOHT4IN zfv5EMaoFGJ3>vQ#gvWn{PK!rj63c=KVHqIvK6ERPOQ#eQokhF31@QJoEkx4!><<_CG82H&15>Tb# zWhM2GFBeXTk%?YW0N{1P9CzGHt6H{OfEnKt=zj>=upz-mn4O^2jpBH}YV3woBxpGJ zz0p4ifMr&U&J}3`-pA}u06N^;ddM;^U~Ok6TIHoDN#O=YcFq zDMB#R8nRc74j^FIv6e02Ycyl#e3y9b!iJk+Uh+G$U9hlJTWN~>X8~e&BxbG{zV?ok z7=LyHWC(u1-Ec#3<=_Jm2BleE?<}w&jo9qJmXk)P&lh{5-A#e|!f+C~7y8 zXtfQ{8|@n=adk}2qk;0_c}XLrczQnQZQ3&GByva%%du}j!DwbBFA_|thPJiuD&k{F& zR=lXVD)^N$t&7DQ0pO6jLeK`Jim}NuG%w8w1#n$h1_CMzKn?UrH_8pgS(-2kC?^Hc zfi@EiX@p>g%tJ$Tfdla};DsuA<1VEfYs-vkD{{8HCsVv36iL+mW23U%lM5F&svu>+ zwyMB<;xj&0sq~Q)eDu^MR)3tw_wbodX6e%suCB6@rwObRP+8PVoo8BDbJz282x4D0DV-aCyqR5iq$r-f zN7Eeel6fP|GY6wi%X-F{wT>vLWbiD5AN}GTl@g;ke=GrEmEBmYG=J8Zk+}?xhQ3T3 zJ^Bt~=fj3f9wQ#}`B165dAKXYlyRTa{cQ!k0*$6gi0Mpc%?0O`s4w%9V>F^E&aalR=#UwfS;L5G*GM-jZ85qw zTOyP2vpY=Q!;Q{}NQNnoymE;J%J!c}LSK%QoGune$&|9f?qO9xXS0OAkY;#W$z}*l> zZz}kL+UQ-R7>zT;#^P?lH);ur;0|5LmkI+?kD%r6r1n7&Z1pv&MMXSwiVOZEc}bJh5& zu~I~^nKYa(rzy)?Aq6SvRR}NZ*eVn?ayTUNavatxeb04G&jSoFPoMapb|7J9X~7_Pj^)-D(T71_8a#?V#LyaW-yTCm9^c z?I;IxxhPFuI9XHZhIji$J?Melm&UNW@j6V(NNQ0?cg_qGds#vIut!?{D?Z_Wug-h3 z0=q^c0h=*CqN4W9`rd_Y!e9HK--ofG_tbOIj)V{w@|0p*DDWGUG{jqA zT(TjZ$;O5j;XG~jYpsCqQ)+R1fe9;!65%*2biVyvfE&RZLM>wnDML$`M43qehsrR4(lr9OgFqTFyAx`E%n?yxI z7{sS{OB=+=+^YiN@NujP{QwjjIrjvlWg$bz!IKF0ukOolJ?*P;&`VLl4MF19?67Y! zW^G{;He~d}wP8}~bAp-h3iH^(>CY_R1vhI1s>E&xkQiO_F%+OSQWGYB5uFlw`)1NR z{5^q)kcf)aK5Ar|A67Sg;x-vpdRLRQ?91c_76?C@#e0YNgTWD3ueESzq@$E!0q+vg z`pf|g^}k{(?v(`m2)#)Org@_>y~ugRIW0nNCpr%QeuJ2jc?!r5xyU9_D&`iP9vfmc zOiF{__R$Fi;s=PmNkv(IyGHhSGV8r)q=K~Lg+9awl!6sz;(AV}LWKYt5_5$&4b)gD zGTc<=VR+5=8y;?-^TQ)bCEPCIQwTVI={?D588unl^Ck6#yvvJGxKN<;UOJ&BgBcZ* z)N)qKe+_;m7%9+|7@a7my+~UW%R&TrIH{Bebf6U>bg-w3bIX-~EKGSuU4VeP@$>u@ z!tMJfdsC+7I68n15Tx=eq)Y!nm-|IgT~W7=Hb_yr;Pa0(iR4|3G)8KN&_nT!$+MZa%PCu%yPH@(!hBxWX<-BRk#=ezmqcpmdtTYq=dpNFd zk_ywqf?5YRT+K&+8)lTyrX*M*YC_(HiyQu39DOT8QAaZ0eh#U#>^T5}Di^=$+?d#B z)4S6LT6Oe8#+Av?BC-@FBC2rHd#(daVI*V6oxs?1Pe|3LEbEB;w-6j{ftuwU`9kMo zn+*ifaleZmZQp(VM3PHTbDY7TrYuu71zje+z>aEM;AV$0K%Kgqg3xd> zo~Jh?fmTD~A9I^7QO6$ZR|w|%26%hAV?9GgF&v<4%gw90(51XACEvURqX8fP2Y>{G zhTAbuo8{zxQ3;Q3QS;4rTirpL2+XofZfhH@Z?6j-A3g$KB>iSID^vdNl=^Yvv{4+E zu?TVBUmC$*O>G@%p>RAt$QGXqyvdmpnE)T(e0ibkOCvaSArnYVa`sg2RbU(% z?X7?bV2FmT(_*#Lw}na~1B*;}nIEskNjv{X6fBB=eip@1&rB~_70R6(3EVr2pbxcnoP0OYisT9z1@S`4m^+`TOei z-C~b`G%kTJLi-QD%~{@3WMJ4sCz4}((%Z-Nr;<-~b6mvtKwy03W^D1=5=d7QgP({; z5C$H9sDl6;ElEKicBR%CWr|#pCzXBIanbhL=k@H6Ila>yeHBw;h*^ow;!YE1^(h|0 zSX=CdZLdM+9M@#VdXnB>sWbct9&?%f68C=#y(31)(}WVMFWr#@8ek&`mO{Wwq^A{j zNI7Gw6Gg;YC9USnN;hrdDh#U2=HzSy^DYs89!k2M5dCBApkL-W{#WyxQDEvN0SRx% zLYhU-<*w?xRerXFA%bHvV{(Jep=%KPKT}$av;bQ;SoF1v*D=A*=^*psHfMXqD)9K# zYfmnA=h8HgCJ^@wTaKn)gRC53?aFnw{Y`Wfl`%)-Z%=S`+X-}4^O@5-u;YoYMODs! zVZL5we*1S?+hTB&ebD(cizKN_8WJ^8$+4*EFXXiT=*J#n4UFa|3y0bn-dG^97#ZOI z!f0E_GC(Pw>ut9&Hc4k_GPHe;T&+HV>ni&thVR|k2rw)Kg$uFD33tc9$=g|Sy_y_S@5{dip3B6AdX&gK{e4ISD4FLv!?zMXb z&c*-0^ioQM(wi?~ybGkDtNFDTG;KZbcP|(lCXPfQlw0I2w|dTn&EQ5OEa`z8HA}_`!{LB*y4OJKt^bOJ7&gi`3C45Dmo{?$a z?Cr;oJvWN-%6Wj21oslez-DKEfZzBn_ippj*6}1-N+mCD2J4|iv+Vc(7xK_!VL?7% zyR36`>1U&JZ#_$r^zP~!IR1|yt3n2z0uL7wSj`BN?_HWM@g;R*TF%h#%ovO+& zzp_(_V$g^T6@fNPNpXCLu1#v+-VD9kIxUKa8U&M3Y} zE}^~=G|N!785P(3fewx@;|0zGJPqKkOPkBrFx>OHDS>Ini-!h({c(Rcnl&ex>3k{q zOlzfg_4bcf<}D62FA>{2sm;dvA1hk2IyKiMFKml9y5^{ac#Q*;n&&&N4YtustvwB- zCL#@O0TQcDV@O?A!D7?v`s~C<3575 z>Th_IqB16EU2>6sZ)Bs&yWVs|2o-@1g!V}hjZC~kzw4DijZZ+2kWdR$h5nG0pz%m$ zM_H9*eP2hc^E2%fU+XrlEl`5=dzG+qr*ZWecjBQKCkzS7>?1F#ON3g(Epqd2Zk!Ou zV5Ay+8q;J_${F^w${q2}Qj!35Bt7pnl*m_>(f)0T;VChGmO zuyeoF$-zneLlLsKid`oq)Lt447Lb#`4Y@pcOV{l@TUbW72AqLXhc>1)l3=Lb!{1yw zV(LBT<+1dC6kEhuF;z*pLfyD+&taJ4}&fuQ`&!J8JxnyZw zJ?nOhG$ELKkE}zDOqw?2Izli~N9uL;NpNR{P+>)X**&mMGde%y*T%*Kqq$-X{}nNk@p2k3#?O&! zy748sbI@O-SWms}>oW+SS7$AzZCjQqWaHOvzI6zVVW>4NlMuZl@_o!5sGYrrm zm7+h~T`g+ek@gRWb6tg=^){8a+_In2{LqFsh&A=Fqz@aq^=J&Wf#wt7>}#Ei%x3=D0$p-{5WG;)mi8)vz9-;T{E9%)64KSRH)jSe zOkLY(1cV6~&Oa_f8e*q(#v?*yb^Ql54#jiHxbmEa9|Lfhw#r@L6tJgpQ};fMi`K&8 zBxB{{@mk0z;3G}C^m$ASB2G>X_}$4@YC?HJEYQsEujDTMc)4Tvh`6^(HUV?=luaIg z<$e6$&*}0;bajD{MFIbkP=?1No=e>(K0XF~#HkYN=Du($2?AejLP1tV08EO{Nn?Yw zT=rB(UdzOZbTfSYzFBOS6xNnWDjTe7X>6|O+D)TDI*;|1kzTzNoe=)6nC*SmrqA++ z$(&c+b}gcGmz4(4!^WIWL?@YQ51ns+N>dInwjLh_-%)CBFBt_u2Mb?m0Nf z4;3yHn2lq&o^~VG_*fY~J6#@qHq0AP0m&dX->u)RN6KL7=CVt?F8izXuqz~&$&t?F zBCC(s`1(XEsA+ZluM*p@;OELE=*O37GUwZg`rjF2k5I()t~j?-DAy5Xsxb6=m4lz4 z>>cqH5Y)O3mQSI)FiVrxHF%K2d*L_We`i?RrfXM++^Tw1vLstNmg~-i7!)=q7uuXT zg(*l@{nld{A5Zm!+J*D9k=uEX7U-~UYllIyx;&oAN`X~3-{3^$+?AEM6m8FJf`DLs z87=AL9TGc5adX5YOtMH@mr(ag%O}~VqSL16W$p-XD<~`-+lEmYMNV|T8=lAue=mHY z6sLUW#62X02W3VaKydc6pV3e+4YeAqj~xlcZ)8bo=ksKs>I#*-mz@rr(oY~TpwBGU z(djE>(~57Trs*izRc8Qf9R>bMe-YX)lSC04A=4&HdEYs{E{~;J(rD`X7!Pdo&JDpf)ttG7?$3%_c-e@%)SMMENNI~jfP2_RwA;$jO2pT$1fmlzNLVfKUL zjQYqwjW%cNIG)UnuEYN4j}Ra$wxyY3@CAP@uxJrLfo*pVnQ-4+wl#cotR*AI^!*B3^mGPdGelu;?WM2qk&oK6-WO^=f_| z^cG3fq_Y1|0-VB&CLL}Be~L}vlM?`NfW6VPPJZS*2$M(M-|dDatgh>j$kZ~nT99Ms z5VMoW#8jtcoD}YK%am82n-x&6Oqb9+=r_g!t`f$P*k7R>H)sd})(NM;Y0_w3DDGFK zZd*iS$i;m&cc#_f9Bq(6-rGxb z>)6Ce6maRhnKhCn7)+7it`uuq?OJ)4{nmxLFW5eklovqo{FApr|6vv!Ocfo<3*EtC zx0)~s8lu5z0W3=tl$iPC0!3F6Eg%l2fK?5vp#qm_z5W{2e-I%z21)Ql9!v2SrrFT9 zQ2}2_Y|xjTq7)JxDoJ28ETTAJ{lrqNO}9bz+?z%cb2f4azxOA3M?gyhz;>4iCo0MtjfW+s)TxXyi*=IV$oo57Osgtl`bhhc z#rLf0ZC71^?X!DdE0B3)6wrIX-B` zd9C1Sj_(Pvo$6y2{!RzBc)GX9l!`qVy7b-HfY|Go4#i>Nb2ApKZ!q}HjW%|f+t*ZI zz^z_N26;|$7o35-6JARL9(8izsp2%|VTIR@iFIKmi}MamSblv%y@_@UNG#_FQ=}V1 z_$P}be*#XN4F*DkeP!i&AC}rY7NxvkBohUiG-`w-j8aSD3IgXNvqHe~F6 zq#71)hru*uayomGO1h~HNx;s)&f%JR%@xv1f0>1edRW3c3Fmy6Io(xZJ2t?~)MvEE zNGljYJ!ry0NKLWl$N3?@1Y;@b zJ~^A_km>!u$k_3jf?@*{O|R@ai4*WTtE10Q8qGYGCSPo#vYF5~T ze;xR|Tqjs6bU=g{R!Def=0UmhTw3ToQ!da2;sJmvTTPY{-adRmPN-HcFMJ|k-gHh@n zDZ9wO%FQdk(E2QrK)rE8(Pa?5R749XvF5H)u9b$>FPg9GZNjcgt;dUs%f8rxf2^JK zd0>@?-hroByTw?vB+PFEWHb=fbub7YKQAgb%fX*%VjobP$(e&SYMtQCFWMy1V{8I0 z+Yve2BlO$YLMwx8vykgK9%!@bun^YxfH&3;vL>GZnY@ZGhGAJr_Y60AFfT~q9@0*C zKqw0gfM3ZHXC3XI)+Wt`Q8m`bf2sO7VOggg{{Z$6oJK-mu{CF;BG5W~dQ`v*!DQ~LXEh{p}(+I-(V|PAl7=b&x11Ab{`B~aa)3RelJj+E4gg#&SFY3e|G_K$(vi6 zoF44e>Sa#TPcG=S~yOS*#WR51%}`2#)^XKVE)^c zPJx@_iF<(cNWj!koS8PFVC+Fi^u7-em^7}$Y^AMc^(rgPO`A0<5&KXFuk_dp{ypd2 z*o1MuGD`Jna{7O0r~#Osf76P%;hC^|@~0_@I`n5GM1qp$MWNgTWnE7I<1*sKO>nME z>*O_*3)nS$fHjz5iDQ;$v&ImeGk>nAVRsK-SRp{R z0=!9v@rv?jSHEIzWx^at%jTQ1uRRx{>&u2%E%FO!cLDK|`4hlef5GA^QTXO@KLgkZ zK)8*iFa@2sk@hh~FA1n2_#7Dh=3UHh@$~?5AnH)-v9gEj1p&w;r5$JWUbi@-mmEq5 zA>iu~6)ZPlUAqJc23;QLKk*tWq2MZD0@Ig=ac?^XmlzCRQJnOASjieqc$B$d!#38K zm&`h)>h?S!ldeNyRrdbepS6%GewTxG^h_9lZ#o<{IleC%C$*NT9;LplC zHkcW*fy>o^XAv&CU~#hx;2mXS{mKcME({9r)PI=H$!OC=cL+|j+otL0M{4Hogvl~e zgC%Hg*Zb7naK+F9i&HVf0rQL0f%t^ zR__QpYDc*6S_~X#lS~}B(5)&;GlI}+P>ArZ*9a- zZrfgD&)N5^#qIv&wR|d5{CaLr+zG$E?<+ScOScKziK=1Ha~?(z;^k(}?sDgp^~#_N zPV5>DEFqF(e+w8w1%Rjp5A7`nutbZ-^&z1R&1{Gp@SPtW6aVT0CUW&ZWCkR~lOW^z zvl%bSOEIRE(TxE>SCB>m~mFo>(`JgIr&37AP% zOxAN5vW&A+r>e(xZnHq1(Xlt;M^Fv=s$?Af;|-&{f95C@Re&raRKTq?P_eAFB*7>$ zpQ)P^s4&+g&)E&B7!?k`r%2P$?C6Wee2Mgp)HIw;66~KnJ0&8j;MDrrTY4*DLx#Do z$bWCo&5~ib7PfhjBgMs#V)3%xxvFx{T&`+k855F~eQYG+C^Ac;HXo*C^8>sQ8j3ul zwXSg5e{SNkDKwxRA>KgpXd+*-df6OWVvFXeq@|}wp1j|~f`!qht+t&5?s74oMyf!r zn<$57=HF7ik}4Ap*Hub(RXt5@n3-^PK)0Ghw3SoAk*j|hBHlqzi*$AJv*JZJ?9*D8 zg;8#6W^4-{4?7;j1k77knij0f9y4?B~9WrUpQU*5I+J&?u78})w5}N z2dYoHrasZ&xE?f}Jt&nen*x)L+kPJ={a*(=3V3mPpus%h@z`}}5B%GQ zt2t=HHG;g*oc7mC6QD!AHTfp!CAai1Pk~YLDf0-#+L8uHqxBWh!>4A7*Yt)ac ze_e$jj4o;Wa*!k0E>%U9UE6oomUNNM%vbr*6;D*Hk-*zd;I%8m-A=#%rUj<=27`|O zbrm$?QB<3tdGj-z4yH!9)YD;AC<=CM2$1(xFSW@k{U-l}K)P|cAHHmqSrAXF$-5*x z>S?(ED-U=;8!y*l>xz|R-_Mlp2yr!!fBd@>j#BC;E`eR7vq_xMG1|Co=*o2SoD{QA z-&HNG;rzQ(IX$sxzMx9d2KU@4fPr`kiS|B%lHxK9W7+v5@J2^z@( z4xoazbQ@|(VE~;ZvK66{Gyw$7PDu)Bc}_G3O2Ci=S-6c5jn>j16jRsy!2df#f3oIJ zE8CrHGMmgTWc!%VLN>ObXx1IB(R0WNvBWIg#~1<#sAvpT>qfD&EFx!3K`NWxM~r;2 z(1R2I=GSpz?_G!=Om!MypyH2GTEim2+4f&u1NxVB5UbG}qL|aEOK6eK7KF)1*D_TM z5&ygwiF5tIzdU1mOUAfzghGyxf0aoB{lr_k-U~tPe1A|n6(tMv9lMbn!quoM$*q}v zuJ!=y%;U2TMmwF>Tjci%*O5guTdN&6fxF~k- zqN)<6hTOm4DpIQ^Zec!Z^ha4b6s-Xam8v|ZzU1)wa`ud_J#PY*#)Zbwiv`v!9WO-Z zZ?1^EbEPyaK*aMYtw@@M`ubpgZUemkmj~4yok3v_=4myixU~fPGx;wz#uAkS_Ca<2 zshUB9k~&U=57_%CUhl_Cf3_$=ZHf_W#w@+m+suMulcb+37$Q%u1}OhgVW>RUP?B4r z{$QHlL*vT9@zXS~XRYw*@3?j3`TH04pqOA;<`L9S8QhFnM`QT%0DQmELk7Iks|8vj zZe+i8(cc7GEuTRo+JyibH~O^%qP+1&8K^)wA|S!n`cGtNt1Pkff1L=u)pd12f5lM3WOErV4vot@?%6>yEWf z(68n^6mb2;_+O<1o6OQwM5dm?^T@W$CmKF|eP8~8=Aep}bh&E95wFd!UOtq$bxzp@ z5Qo!#H>y#(w}8FkKt4|cXAWpGmEd|>yzYMmKZQiQs{NKDdat1aVVksjt4Ha(a})r= zVM-?`3dn!b{hZcw^!B{65gTk|S%eTN1*TvEFn?rSn+2!mCeKzP0)sd#4`FeMNN?LB zLI?)gYZ0b$o^W*%fd`K|y?tH&XEJqsaMULOj-A@H3G-w6R}ZJ$pmkzsN`oEe>=s}g z2Tapl=rC|;a{-tIJ~aOYmEkz%Vr_&;T@T|?!eGU|9XB|_kQl4gA#-8^F?UT}ODNL>Lp&V^y9(#vQGCMk{ zTIigMyb2kg8_vG_r)xN^=+q}+>2B!xGBx;xL)GBJu$Pn$7kx=9`<_qcn+P-YZ?l%? z4LXg1S-eQo5V*(ve2Exk_&MW$C1T<-3V*xB0Eo)~()+iJxFv81-G~`B6<6Dte*2F# zfdQQ;nN)Rk9mav@s z9@QrsAD&G5X`{xUV&#OG8fA}vg8})xz)5$WVf)z4(WD)#$ENX9G89&szqczxwy^Nd^>%dZ{s9+sh22!O2-4z zPR}iEH~965z9R6HUmtAiX9G|3NqQQn7^ER_s)c}KD1Ra%JMt2}fVrJ8GV51*M}`NT zcc3Iz8axwv>n3HW7-!OISY7gjsegV^bi@2udc6s3V`r*UUG*?D2hT@&gIT|9Q76mX zteqF8oWh}jvKZ%tk-F_9>r^x?*TgzkOAkTPM?l05#6rHU~7caYRUFSoO&(S9`^U&41pIqO>bG zv&Jlay*G_NIv++se_T|UB1?%#{;LcF26#?0u{G*C@=A}q92TGB<@V07&f7IG9U34Z z!KBc;m^5@=BHwh4IG|(`W=4W{V@sRGh}Nx(lS&ojk%|SbBaY(U#fhm1N!wB%&2Y_5 z$PnB1dz?#IRH-DB=LhCfSAR%>Ri7IM=}66MW#J|!j>%uYc@H8kI$W{}6p^05qNiYE z#ZDNz(L%TE|H&^R?M|vAXBJ&yia?{YiPIpBE4~NvDx@bt<~T6p^!!V&V}yeM<_(I} zx}gZasK#<GwN4$L^Suw&HM0BrP|AvHD zH2PK@ZH7!UA?vr51yXWdfR;XW$ZVBm3ym7OSHy3!a7)Z#lE%(dMR;`E zkZjfv)hJ0eF+OFX_)j>XU%pGe5w#QM$q_KRZ_z9yFkacoahoxLRFB?V~nTSlQ*tKGrGzN=*-AI~stamw2E_1Y$vOYD?eIt@&#Ex1f zjxB7r9!L^L5lM{Y!3u{86SblD&+7k`dkDkd0nzvjpV`{TH9i>t37+F`3uH0*^v3mRC=0D!UlcFZcN{V0Wk zE1`_gZPLh78#+$fXtrm}UX*v>AbxXJrejjqJZHuf)EQ7?dWW@8%-nlT4p5W}KhFhv zm#D5i3SNG18Qm3-ywE~*B0z`TUNvDFYJzzQ|0cKD;(tlFZw!?T2H|;LEwqvbz_ppc z)jee3#Iy(o8}1rYn$ogHL|Aj|;`swd%_r^6!7qcA1pWiXy(a>WXNqm_c`)Wt+FUoO z;0Q0gWlVCwab^G>%Z~8s@-D4bGH7`=GhLLAgJyKtmg_~!L1ulFQsc6JmKH-Q}E-jC-p zj8v}42dSBPAgTQ!v|{krbQ{WnRi7F(c^@MybXMW9KHEr(H1EONmroc5RZ*qb3$sfm zUnGnB8eW<^4&$b{oeO4VyQdFh%T?_@qs96{3b$evSvj8703SL>8Fs zeTEy^;D}YrIWzP%^#%ObURACpVnSE7Fak)LX0csPH$lqqSvBND`TDwSYC^Gf?xR zg_q^R6a5L6t6@2xf}p~^mS zZH;o&9QIriJbxUmQoF}wTN=DYW-(wqRRakNW;PNlRBg6O`}sLd-6 zw?xP)ra5IVlOtuxt74}xPB1-h;S-AW(one`GD>4;d9r*%={Yk$oEsc$kF zXVRTu8<9KK{$;!7ZL^{XR)YPV;A^gBq2nFrT35oP!V#U$;ncaxtSjY$cr>#T5XDFY zmK@VdlvDq=uf&V$h%>&895oalX-l}qQF+wc5PE;U`+SD>`&u2knb6Hz-H6q&u@vqV zE~&`b9Y|uO7KzY0S$CuTWn*0hr8>4^U;Q7G$3(4j~VWN>cBKMfB9u8 zR#?a0SWZU*iDHy&-DnAtj)TofYYTzEXB*Kg3S zJ&eoh+w2U3qEfMKx$LStf5)hC!ox55@&~HHmVfN+P%cuIdK)|oTj&0Dd*T!XI6MZ| zAI~m3iY;WD#l=jB&#Xv&oej7=6)GL~ab{xOty8p*(Pw?bh7(9oWiW)qgS|NcHKb1?l|(m#p{Z)~HiI8^(mwu=k|G=a|a!TC|%VmXVyqn}bbm70Mma_u%ywtr9Zf{IswZHXLC)S7H_KY>BG zsPiX@F_>uZKDYP(i{_&Z`h9_i#~QYikew>1(kJ2-i;`+1fW2o;OaHm}l*4glW!`hc zURxhe;S>BmIH$UV8^R+@q@+HU|ETSek#*LUdW_kF&riZ@WkG*`)@Xht;YQp3C78L+V;tsWsH;6O`q$=HDR zkbgt!*a8(+E}#&v+n!m)?+)7&DJucv9dNc3oMRWEOw#BcL5^d)^RqG<>HfWI#$HzW zGV_WS<=w5=`6?9)0xZ{y^R!E034U)94ZuL^JLC9XB5roj?AKDd#0MoNeH4*ie+78lz&;PzCxfIs`soaDQ2pW6t;e;8ZVX5IF#Wc`Zs&$2Z7lUHof&^ z({W{iR*n;3FP`^?Qe}~swB!T?1sBq=cPW2*kQHWDN`Sjn(0)k$@Wm_?c~x&|7zXsmjz zye#$#eJt1U0&Bptlha z{UkYd^(pK`yu~$HcTqX^iNuD$YPYpZTN+5hS@{P{g(O+7A;AbEJ~j_KXEaOOB?3r_ zmUbqyw4!?ZqFc+Se6Qw1t|80sbf+VwiN3k$>F~v55SISh^JOHMfie|P4}avm+X)Km z?L)lr?7u3LG#RWWcVJC>1>buyRd;vqm|UYGg7#{$F1TPJRGpU?Gs@~acJ`+d36Gsk zg9OC;ZLt@ODa3gW)h&V92v0MC2O}vDoa)D2TV+6adFM4-dStu$`9bKgjDEv0qmIv( zt8j|g+ccXcc`=A&d0~oA&meGSwyPvlHcoqoPFp>%jr8@V8_p)0sakvqd$mXY1D;=- B+CKmQ diff --git a/PrintS/protobuf/stream.pb.cc b/PrintS/protobuf/stream.pb.cc index 4f1ed96..e7673c2 100644 --- a/PrintS/protobuf/stream.pb.cc +++ b/PrintS/protobuf/stream.pb.cc @@ -36,13 +36,27 @@ PROTOBUF_CONSTEXPR ParamInfo::ParamInfo(::_pbi::ConstantInitialized) &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}, }, + /*decltype(_impl_.cardname_)*/ { + &::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}, + }, + /*decltype(_impl_.cardip_)*/ { + &::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}, + }, /*decltype(_impl_.valuetype_)*/ 0, + /*decltype(_impl_.startlayer_)*/ 0, /*decltype(_impl_.isenable_)*/ false, /*decltype(_impl_.isalarm_)*/ false, /*decltype(_impl_.isshow_)*/ false, - /*decltype(_impl_.startlayer_)*/ 0, + /*decltype(_impl_.hadassign_)*/ false, /*decltype(_impl_.endlayer_)*/ 0, /*decltype(_impl_.powder_)*/ 0, + /*decltype(_impl_.seqno_)*/ 0, + /*decltype(_impl_.controlno_)*/ 0, + /*decltype(_impl_.serialno_)*/ 0, + /*decltype(_impl_.controltype_)*/ 0, + /*decltype(_impl_.hadmatch_)*/ false, /*decltype(_impl_._cached_size_)*/ {}, } {} struct ParamInfoDefaultTypeInternal { @@ -264,8 +278,280 @@ struct ComResponceDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ComResponceDefaultTypeInternal _ComResponce_default_instance_; + template +PROTOBUF_CONSTEXPR ScannerCrtlCfgResp::ScannerCrtlCfgResp(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.scannercfg_)*/ {}, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct ScannerCrtlCfgRespDefaultTypeInternal { + PROTOBUF_CONSTEXPR ScannerCrtlCfgRespDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ScannerCrtlCfgRespDefaultTypeInternal() {} + union { + ScannerCrtlCfgResp _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScannerCrtlCfgRespDefaultTypeInternal _ScannerCrtlCfgResp_default_instance_; + template +PROTOBUF_CONSTEXPR ScannerCrtlCfgData::ScannerCrtlCfgData(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_._has_bits_)*/ {}, + /*decltype(_impl_._cached_size_)*/ {}, + /*decltype(_impl_.fixpointdata_)*/ {}, + /*decltype(_impl_.powercompensate_)*/ {}, + /*decltype(_impl_.tpowercompensate_)*/ {}, + /*decltype(_impl_.cardname_)*/ { + &::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}, + }, + /*decltype(_impl_.cardip_)*/ { + &::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}, + }, + /*decltype(_impl_.scanparamcfg_)*/ nullptr, + /*decltype(_impl_.hatchingparams_)*/ nullptr, + /*decltype(_impl_.borderparams_)*/ nullptr, + /*decltype(_impl_.supportparams_)*/ nullptr, + /*decltype(_impl_.correctparamcfg_)*/ nullptr, + /*decltype(_impl_.scantestcfg_)*/ nullptr, + /*decltype(_impl_.skywritingcfg_)*/ nullptr, + /*decltype(_impl_.seqno_)*/ 0, + /*decltype(_impl_.controlno_)*/ 0, + /*decltype(_impl_.serialno_)*/ 0, + /*decltype(_impl_.controltype_)*/ 0, + /*decltype(_impl_.isenable_)*/ false, + /*decltype(_impl_.hadassign_)*/ false, + /*decltype(_impl_.hadmatch_)*/ false, + } {} +struct ScannerCrtlCfgDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR ScannerCrtlCfgDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ScannerCrtlCfgDataDefaultTypeInternal() {} + union { + ScannerCrtlCfgData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScannerCrtlCfgDataDefaultTypeInternal _ScannerCrtlCfgData_default_instance_; + template +PROTOBUF_CONSTEXPR FixPointData::FixPointData(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.id_)*/ 0, + /*decltype(_impl_.cno_)*/ 0, + /*decltype(_impl_.pointx_)*/ 0, + /*decltype(_impl_.pointy_)*/ 0, + /*decltype(_impl_.duration_)*/ 0u, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct FixPointDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR FixPointDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~FixPointDataDefaultTypeInternal() {} + union { + FixPointData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FixPointDataDefaultTypeInternal _FixPointData_default_instance_; + template +PROTOBUF_CONSTEXPR ScanParamCfg::ScanParamCfg(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.edgelevel_)*/ 0, + /*decltype(_impl_.edgelevelmin_)*/ 0, + /*decltype(_impl_.edgelevelmax_)*/ 0, + /*decltype(_impl_.jumpdelay_)*/ 0u, + /*decltype(_impl_.jumpdelaymin_)*/ 0u, + /*decltype(_impl_.jumpdelaymax_)*/ 0u, + /*decltype(_impl_.scandelay_)*/ 0u, + /*decltype(_impl_.scandelaymin_)*/ 0u, + /*decltype(_impl_.scandelaymax_)*/ 0u, + /*decltype(_impl_.polygondelay_)*/ 0u, + /*decltype(_impl_.polygondelaymin_)*/ 0u, + /*decltype(_impl_.polygondelaymax_)*/ 0u, + /*decltype(_impl_.laseroffdelay_)*/ ::int64_t{0}, + /*decltype(_impl_.laseroffdelaymin_)*/ ::int64_t{0}, + /*decltype(_impl_.laseroffdelaymax_)*/ ::int64_t{0}, + /*decltype(_impl_.laserondelay_)*/ ::int64_t{0}, + /*decltype(_impl_.laserondelaymin_)*/ ::int64_t{0}, + /*decltype(_impl_.laserondelaymax_)*/ ::int64_t{0}, + /*decltype(_impl_.minjumpdelay_)*/ 0u, + /*decltype(_impl_.minjumpdelaymin_)*/ 0u, + /*decltype(_impl_.minjumpdelaymax_)*/ 0u, + /*decltype(_impl_.jumplengthlimit_)*/ 0u, + /*decltype(_impl_.jumplengthlimitmin_)*/ 0u, + /*decltype(_impl_.jumplengthlimitmax_)*/ 0u, + /*decltype(_impl_.jumpspeed_)*/ 0, + /*decltype(_impl_.jumpspeedmin_)*/ 0, + /*decltype(_impl_.jumpspeedmax_)*/ 0, + /*decltype(_impl_.markspeed_)*/ 0, + /*decltype(_impl_.markspeedmin_)*/ 0, + /*decltype(_impl_.markspeedmax_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct ScanParamCfgDefaultTypeInternal { + PROTOBUF_CONSTEXPR ScanParamCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ScanParamCfgDefaultTypeInternal() {} + union { + ScanParamCfg _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScanParamCfgDefaultTypeInternal _ScanParamCfg_default_instance_; + template +PROTOBUF_CONSTEXPR CorrectParamCfg::CorrectParamCfg(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.xmeasuremin_)*/ 0, + /*decltype(_impl_.xmeasuremax_)*/ 0, + /*decltype(_impl_.ymeasuremin_)*/ 0, + /*decltype(_impl_.ymeasuremax_)*/ 0, + /*decltype(_impl_.xposfix_)*/ 0, + /*decltype(_impl_.yposfix_)*/ 0, + /*decltype(_impl_.scanangle_)*/ 0, + /*decltype(_impl_.scananglemin_)*/ 0, + /*decltype(_impl_.scananglemax_)*/ 0, + /*decltype(_impl_.fixangle_)*/ 0, + /*decltype(_impl_.fixanglemin_)*/ 0, + /*decltype(_impl_.fixanglemax_)*/ 0, + /*decltype(_impl_.xcorrect_)*/ 0, + /*decltype(_impl_.ycorrect_)*/ 0, + /*decltype(_impl_.xcorrectmin_)*/ 0, + /*decltype(_impl_.xcorrectmax_)*/ 0, + /*decltype(_impl_.ycorrectmin_)*/ 0, + /*decltype(_impl_.ycorrectmax_)*/ 0, + /*decltype(_impl_.realxoffset_)*/ 0, + /*decltype(_impl_.realyoffset_)*/ 0, + /*decltype(_impl_.factork_)*/ 0, + /*decltype(_impl_.defocusratio_)*/ 0, + /*decltype(_impl_.defocusratiomin_)*/ 0, + /*decltype(_impl_.defocusratiomax_)*/ 0, + /*decltype(_impl_.iscorrectfile3d_)*/ false, + /*decltype(_impl_.isdynamicfocus_)*/ false, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct CorrectParamCfgDefaultTypeInternal { + PROTOBUF_CONSTEXPR CorrectParamCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CorrectParamCfgDefaultTypeInternal() {} + union { + CorrectParamCfg _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CorrectParamCfgDefaultTypeInternal _CorrectParamCfg_default_instance_; + template +PROTOBUF_CONSTEXPR ScanTestCfg::ScanTestCfg(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.debugshape_)*/ 0, + /*decltype(_impl_.shapesize_)*/ 0, + /*decltype(_impl_.shapesizemin_)*/ 0, + /*decltype(_impl_.shape_size_max_)*/ 0, + /*decltype(_impl_.laser_power_)*/ 0, + /*decltype(_impl_.laser_power_min_)*/ 0, + /*decltype(_impl_.defocus_)*/ 0, + /*decltype(_impl_.defocus_min_)*/ 0, + /*decltype(_impl_.defocus_max_)*/ 0, + /*decltype(_impl_.laser_power_max_)*/ 0, + /*decltype(_impl_.is_cycle_)*/ false, + /*decltype(_impl_.isautoheatingscanner_)*/ false, + /*decltype(_impl_.cross_x_)*/ 0, + /*decltype(_impl_.cross_y_)*/ 0, + /*decltype(_impl_.z_distance_)*/ 0, + /*decltype(_impl_.autoheatingscannerminutes_)*/ 0u, + /*decltype(_impl_.autoheatingscannersize_)*/ 0u, + /*decltype(_impl_.autoheatingscannerspeed_)*/ 0, + /*decltype(_impl_.mark_test_start_x_)*/ 0, + /*decltype(_impl_.mark_test_start_y_)*/ 0, + /*decltype(_impl_.mark_test_end_x_)*/ 0, + /*decltype(_impl_.mark_test_end_y_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct ScanTestCfgDefaultTypeInternal { + PROTOBUF_CONSTEXPR ScanTestCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ScanTestCfgDefaultTypeInternal() {} + union { + ScanTestCfg _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScanTestCfgDefaultTypeInternal _ScanTestCfg_default_instance_; + template +PROTOBUF_CONSTEXPR SkyWritingCfg::SkyWritingCfg(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.timelag_)*/ 0, + /*decltype(_impl_.timelagmin_)*/ 0, + /*decltype(_impl_.timelagmax_)*/ 0, + /*decltype(_impl_.isenable_)*/ false, + /*decltype(_impl_.nprev_)*/ 0u, + /*decltype(_impl_.laseronshift_)*/ ::int64_t{0}, + /*decltype(_impl_.laseronshiftmin_)*/ ::int64_t{0}, + /*decltype(_impl_.laseronshiftmax_)*/ ::int64_t{0}, + /*decltype(_impl_.nprevmin_)*/ 0u, + /*decltype(_impl_.nprevmax_)*/ 0u, + /*decltype(_impl_.npost_)*/ 0u, + /*decltype(_impl_.npostmin_)*/ 0u, + /*decltype(_impl_.npostmax_)*/ 0u, + /*decltype(_impl_.mode_)*/ 0, + /*decltype(_impl_.limite_)*/ 0, + /*decltype(_impl_.limitemin_)*/ 0, + /*decltype(_impl_.limitemax_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct SkyWritingCfgDefaultTypeInternal { + PROTOBUF_CONSTEXPR SkyWritingCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SkyWritingCfgDefaultTypeInternal() {} + union { + SkyWritingCfg _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkyWritingCfgDefaultTypeInternal _SkyWritingCfg_default_instance_; + template +PROTOBUF_CONSTEXPR PowerCompensate::PowerCompensate(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.cno_)*/ 0, + /*decltype(_impl_.percent_)*/ 0, + /*decltype(_impl_.value_)*/ 0, + /*decltype(_impl_.value_min_)*/ 0, + /*decltype(_impl_.value_max_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct PowerCompensateDefaultTypeInternal { + PROTOBUF_CONSTEXPR PowerCompensateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PowerCompensateDefaultTypeInternal() {} + union { + PowerCompensate _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PowerCompensateDefaultTypeInternal _PowerCompensate_default_instance_; + template +PROTOBUF_CONSTEXPR TimePowerCompensate::TimePowerCompensate(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.id_)*/ 0, + /*decltype(_impl_.cno_)*/ 0, + /*decltype(_impl_.startminute_)*/ 0u, + /*decltype(_impl_.endminute_)*/ 0u, + /*decltype(_impl_.compensate_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct TimePowerCompensateDefaultTypeInternal { + PROTOBUF_CONSTEXPR TimePowerCompensateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~TimePowerCompensateDefaultTypeInternal() {} + union { + TimePowerCompensate _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TimePowerCompensateDefaultTypeInternal _TimePowerCompensate_default_instance_; } // namespace stream -static ::_pb::Metadata file_level_metadata_stream_2eproto[12]; +static ::_pb::Metadata file_level_metadata_stream_2eproto[21]; static const ::_pb::EnumDescriptor* file_level_enum_descriptors_stream_2eproto[2]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_stream_2eproto = nullptr; @@ -289,6 +575,14 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.startlayer_), PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.endlayer_), PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.powder_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.seqno_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.controlno_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.serialno_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.controltype_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.cardname_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.cardip_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.hadassign_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.hadmatch_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::stream::RequestInfo, _internal_metadata_), ~0u, // no _extensions_ @@ -412,22 +706,252 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::stream::ComResponce, _impl_.data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgResp, _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::ScannerCrtlCfgResp, _impl_.scannercfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _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::ScannerCrtlCfgData, _impl_.seqno_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.fixpointdata_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.scanparamcfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hatchingparams_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.borderparams_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.supportparams_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.correctparamcfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.scantestcfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.skywritingcfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.powercompensate_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.tpowercompensate_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.controlno_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.serialno_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.controltype_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.cardname_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.cardip_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.isenable_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hadassign_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hadmatch_), + ~0u, + ~0u, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _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::FixPointData, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.cno_), + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.pointx_), + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.pointy_), + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.duration_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _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::ScanParamCfg, _impl_.edgelevel_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevelmin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevelmax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimit_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimitmin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimitmax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeed_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeedmin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeedmax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeed_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeedmin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeedmax_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _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::CorrectParamCfg, _impl_.xmeasuremin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xmeasuremax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ymeasuremin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ymeasuremax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xposfix_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.yposfix_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scanangle_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scananglemin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scananglemax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixangle_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixanglemin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixanglemax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrect_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrect_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrectmin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrectmax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrectmin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrectmax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.realxoffset_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.realyoffset_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.factork_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.iscorrectfile3d_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.isdynamicfocus_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratio_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratiomin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratiomax_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _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::ScanTestCfg, _impl_.debugshape_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shapesize_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shapesizemin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shape_size_max_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_min_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_max_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_min_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_max_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.is_cycle_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.cross_x_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.cross_y_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.z_distance_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.isautoheatingscanner_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannerminutes_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannersize_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannerspeed_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_start_x_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_start_y_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_end_x_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_end_y_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _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::SkyWritingCfg, _impl_.isenable_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelag_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelagmin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelagmax_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshift_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshiftmin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshiftmax_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprev_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprevmin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprevmax_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npost_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npostmin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npostmax_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.mode_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limite_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limitemin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limitemax_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _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::PowerCompensate, _impl_.cno_), + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.percent_), + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_), + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_min_), + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_max_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _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::TimePowerCompensate, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.cno_), + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.startminute_), + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.endminute_), + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.compensate_), }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::stream::ParamInfo)}, - {18, -1, -1, sizeof(::stream::RequestInfo)}, - {32, -1, -1, sizeof(::stream::ResponseInfo)}, - {43, 52, -1, sizeof(::stream::ResponseAny)}, - {53, -1, -1, sizeof(::stream::LayerData)}, - {66, -1, -1, sizeof(::stream::LayerDataBlock)}, - {80, -1, -1, sizeof(::stream::VectorDataBlock)}, - {92, -1, -1, sizeof(::stream::ChainDataBlock)}, - {102, -1, -1, sizeof(::stream::Point)}, - {112, -1, -1, sizeof(::stream::RegResponce)}, - {121, -1, -1, sizeof(::stream::ImgInfoResponce)}, - {132, -1, -1, sizeof(::stream::ComResponce)}, + {26, -1, -1, sizeof(::stream::RequestInfo)}, + {40, -1, -1, sizeof(::stream::ResponseInfo)}, + {51, 60, -1, sizeof(::stream::ResponseAny)}, + {61, -1, -1, sizeof(::stream::LayerData)}, + {74, -1, -1, sizeof(::stream::LayerDataBlock)}, + {88, -1, -1, sizeof(::stream::VectorDataBlock)}, + {100, -1, -1, sizeof(::stream::ChainDataBlock)}, + {110, -1, -1, sizeof(::stream::Point)}, + {120, -1, -1, sizeof(::stream::RegResponce)}, + {129, -1, -1, sizeof(::stream::ImgInfoResponce)}, + {140, -1, -1, sizeof(::stream::ComResponce)}, + {149, -1, -1, sizeof(::stream::ScannerCrtlCfgResp)}, + {158, 185, -1, sizeof(::stream::ScannerCrtlCfgData)}, + {204, -1, -1, sizeof(::stream::FixPointData)}, + {217, -1, -1, sizeof(::stream::ScanParamCfg)}, + {255, -1, -1, sizeof(::stream::CorrectParamCfg)}, + {289, -1, -1, sizeof(::stream::ScanTestCfg)}, + {319, -1, -1, sizeof(::stream::SkyWritingCfg)}, + {344, -1, -1, sizeof(::stream::PowerCompensate)}, + {357, -1, -1, sizeof(::stream::TimePowerCompensate)}, }; static const ::_pb::Message* const file_default_instances[] = { @@ -443,51 +967,143 @@ static const ::_pb::Message* const file_default_instances[] = { &::stream::_RegResponce_default_instance_._instance, &::stream::_ImgInfoResponce_default_instance_._instance, &::stream::_ComResponce_default_instance_._instance, + &::stream::_ScannerCrtlCfgResp_default_instance_._instance, + &::stream::_ScannerCrtlCfgData_default_instance_._instance, + &::stream::_FixPointData_default_instance_._instance, + &::stream::_ScanParamCfg_default_instance_._instance, + &::stream::_CorrectParamCfg_default_instance_._instance, + &::stream::_ScanTestCfg_default_instance_._instance, + &::stream::_SkyWritingCfg_default_instance_._instance, + &::stream::_PowerCompensate_default_instance_._instance, + &::stream::_TimePowerCompensate_default_instance_._instance, }; const char descriptor_table_protodef_stream_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { "\n\014stream.proto\022\006stream\032\031google/protobuf/" - "any.proto\"\311\001\n\tParamInfo\022\017\n\007nameKey\030\001 \001(\014" + "any.proto\"\331\002\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." "stream.TYPE\022\017\n\007context\030\004 \001(\014\022\020\n\010isEnable" "\030\005 \001(\010\022\017\n\007isAlarm\030\006 \001(\010\022\016\n\006isShow\030\007 \001(\010\022" "\022\n\nstartLayer\030\010 \001(\005\022\020\n\010endLayer\030\t \001(\005\022\016\n" - "\006powder\030\n \001(\002\"\254\001\n\013RequestInfo\022\020\n\010dataTyp" - "e\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\022&\n\nh" - "andleType\030\005 \001(\0162\022.stream.DATAHANDLE\022\037\n\004i" - "tem\030\006 \003(\0132\021.stream.ParamInfo\"Q\n\014Response" - "Info\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\013Respo" - "nseAny\022\"\n\004data\030\001 \001(\0132\024.google.protobuf.A" - "ny\"\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.LayerData" - "Block\022\016\n\006result\030\005 \001(\010\"\266\001\n\016LayerDataBlock" - "\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\013chainBlock" - "s\030\005 \003(\0132\026.stream.ChainDataBlock\022\r\n\005order" - "\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\004endY\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\005Poin" - "t\022\014\n\004xPos\030\001 \001(\002\022\014\n\004yPos\030\002 \001(\002\"\033\n\013RegResp" - "once\022\014\n\004data\030\001 \001(\005\"D\n\017ImgInfoResponce\022\022\n" - "\nlevelImage\030\001 \001(\r\022\r\n\005width\030\002 \001(\005\022\016\n\006heig" - "ht\030\003 \001(\005\"\033\n\013ComResponce\022\014\n\004data\030\001 \001(\014*\223\001" - "\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\006iFLOAT\020\005\022\013\n\007i" - "STRING\020\006\022\t\n\005iCHAR\020\007\022\n\n\006iUCHAR\020\010\022\t\n\005iWORD" - "\020\t\022\013\n\007iDOUBLE\020\n\022\n\n\006iTIMET\020\013**\n\nDATAHANDL" - "E\022\n\n\006UPDATE\020\000\022\007\n\003ADD\020\001\022\007\n\003DEL\020\0022\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" + "\006powder\030\n \001(\002\022\r\n\005seqNo\030\013 \001(\005\022\021\n\tcontrolN" + "o\030\014 \001(\005\022\020\n\010serialNo\030\r \001(\005\022\023\n\013controlType" + "\030\016 \001(\005\022\020\n\010cardName\030\017 \001(\014\022\016\n\006cardIP\030\020 \001(\014" + "\022\021\n\thadAssign\030\021 \001(\010\022\020\n\010hadMatch\030\022 \001(\010\"\254\001" + "\n\013RequestInfo\022\020\n\010dataType\030\001 \001(\r\022\017\n\007nameK" + "ey\030\002 \001(\014\022\020\n\010strValue\030\003 \001(\014\022\037\n\tvalueType\030" + "\004 \001(\0162\014.stream.TYPE\022&\n\nhandleType\030\005 \001(\0162" + "\022.stream.DATAHANDLE\022\037\n\004item\030\006 \003(\0132\021.stre" + "am.ParamInfo\"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.s" + "tream.ParamInfo\"1\n\013ResponseAny\022\"\n\004data\030\001" + " \001(\0132\024.google.protobuf.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.LayerDataBlock\022\016\n\006result\030" + "\005 \001(\010\"\266\001\n\016LayerDataBlock\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.Vecto" + "rDataBlock\022+\n\013chainBlocks\030\005 \003(\0132\026.stream" + ".ChainDataBlock\022\r\n\005order\030\006 \001(\r\"M\n\017Vector" + "DataBlock\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\004endY\030\004 \001(\002\"A\n\016ChainDa" + "taBlock\022\016\n\006dotNum\030\001 \001(\r\022\037\n\010pointVec\030\002 \003(" + "\0132\r.stream.Point\"#\n\005Point\022\014\n\004xPos\030\001 \001(\002\022" + "\014\n\004yPos\030\002 \001(\002\"\033\n\013RegResponce\022\014\n\004data\030\001 \001" + "(\005\"D\n\017ImgInfoResponce\022\022\n\nlevelImage\030\001 \001(" + "\r\022\r\n\005width\030\002 \001(\005\022\016\n\006height\030\003 \001(\005\"\033\n\013ComR" + "esponce\022\014\n\004data\030\001 \001(\014\"D\n\022ScannerCrtlCfgR" + "esp\022.\n\nscannerCfg\030\001 \003(\0132\032.stream.Scanner" + "CrtlCfgData\"\210\005\n\022ScannerCrtlCfgData\022\r\n\005se" + "qNo\030\001 \001(\005\022*\n\014fixPointData\030\002 \003(\0132\024.stream" + ".FixPointData\022*\n\014scanParamCfg\030\003 \001(\0132\024.st" + "ream.ScanParamCfg\022,\n\016hatchingParams\030\004 \001(" + "\0132\024.stream.ScanParamCfg\022*\n\014borderParams\030" + "\005 \001(\0132\024.stream.ScanParamCfg\022+\n\rsupportPa" + "rams\030\006 \001(\0132\024.stream.ScanParamCfg\0220\n\017corr" + "ectParamCfg\030\007 \001(\0132\027.stream.CorrectParamC" + "fg\022(\n\013scanTestCfg\030\010 \001(\0132\023.stream.ScanTes" + "tCfg\022,\n\rskyWritingCfg\030\t \001(\0132\025.stream.Sky" + "WritingCfg\0220\n\017powerCompensate\030\n \003(\0132\027.st" + "ream.PowerCompensate\0225\n\020tPowerCompensate" + "\030\013 \003(\0132\033.stream.TimePowerCompensate\022\021\n\tc" + "ontrolNo\030\014 \001(\005\022\020\n\010serialNo\030\r \001(\005\022\023\n\013cont" + "rolType\030\016 \001(\005\022\020\n\010cardName\030\017 \001(\014\022\016\n\006cardI" + "P\030\020 \001(\014\022\020\n\010isEnable\030\021 \001(\010\022\021\n\thadAssign\030\022" + " \001(\010\022\020\n\010hadMatch\030\023 \001(\010\"Y\n\014FixPointData\022\n" + "\n\002id\030\001 \001(\005\022\013\n\003cno\030\002 \001(\005\022\016\n\006pointX\030\003 \001(\002\022" + "\016\n\006pointY\030\004 \001(\002\022\020\n\010duration\030\005 \001(\r\"\275\005\n\014Sc" + "anParamCfg\022\021\n\tedgeLevel\030\001 \001(\005\022\024\n\014edgeLev" + "elMin\030\002 \001(\005\022\024\n\014edgeLevelMax\030\003 \001(\005\022\021\n\tjum" + "pDelay\030\004 \001(\r\022\024\n\014jumpDelayMin\030\005 \001(\r\022\024\n\014ju" + "mpDelayMax\030\006 \001(\r\022\021\n\tscanDelay\030\007 \001(\r\022\024\n\014s" + "canDelayMin\030\010 \001(\r\022\024\n\014scanDelayMax\030\t \001(\r\022" + "\024\n\014polygonDelay\030\n \001(\r\022\027\n\017polygonDelayMin" + "\030\013 \001(\r\022\027\n\017polygonDelayMax\030\014 \001(\r\022\025\n\rlaser" + "offDelay\030\r \001(\003\022\030\n\020laseroffDelayMin\030\016 \001(\003" + "\022\030\n\020laseroffDelayMax\030\017 \001(\003\022\024\n\014laseronDel" + "ay\030\020 \001(\003\022\027\n\017laseronDelayMin\030\021 \001(\003\022\027\n\017las" + "eronDelayMax\030\022 \001(\003\022\024\n\014minJumpDelay\030\023 \001(\r" + "\022\027\n\017minJumpDelayMin\030\024 \001(\r\022\027\n\017minJumpDela" + "yMax\030\025 \001(\r\022\027\n\017jumpLengthLimit\030\026 \001(\r\022\032\n\022j" + "umpLengthLimitMin\030\027 \001(\r\022\032\n\022jumpLengthLim" + "itMax\030\030 \001(\r\022\021\n\tjumpSpeed\030\031 \001(\001\022\024\n\014jumpSp" + "eedMin\030\032 \001(\001\022\024\n\014jumpSpeedMax\030\033 \001(\001\022\021\n\tma" + "rkSpeed\030\034 \001(\001\022\024\n\014markSpeedMin\030\035 \001(\001\022\024\n\014m" + "arkSpeedMax\030\036 \001(\001\"\256\004\n\017CorrectParamCfg\022\023\n" + "\013xmeasureMin\030\001 \001(\001\022\023\n\013xmeasureMax\030\002 \001(\001\022" + "\023\n\013ymeasureMin\030\003 \001(\001\022\023\n\013ymeasureMax\030\004 \001(" + "\001\022\017\n\007xposfix\030\005 \001(\001\022\017\n\007yposfix\030\006 \001(\001\022\021\n\ts" + "canAngle\030\007 \001(\001\022\024\n\014scanAngleMin\030\010 \001(\001\022\024\n\014" + "scanAngleMax\030\t \001(\001\022\020\n\010fixAngle\030\n \001(\001\022\023\n\013" + "fixAngleMin\030\013 \001(\001\022\023\n\013fixAngleMax\030\014 \001(\001\022\020" + "\n\010xcorrect\030\r \001(\001\022\020\n\010ycorrect\030\016 \001(\001\022\023\n\013xc" + "orrectMin\030\017 \001(\001\022\023\n\013xcorrectMax\030\020 \001(\001\022\023\n\013" + "ycorrectMin\030\021 \001(\001\022\023\n\013ycorrectMax\030\022 \001(\001\022\023" + "\n\013realXOffset\030\023 \001(\001\022\023\n\013realYOffset\030\024 \001(\001" + "\022\017\n\007factorK\030\025 \001(\001\022\027\n\017isCorrectFile3D\030\026 \001" + "(\010\022\026\n\016isDynamicFocus\030\027 \001(\010\022\024\n\014defocusRat" + "io\030\030 \001(\001\022\027\n\017defocusRatioMin\030\031 \001(\001\022\027\n\017def" + "ocusRatioMax\030\032 \001(\001\"\226\004\n\013ScanTestCfg\022\022\n\nde" + "bugShape\030\001 \001(\005\022\021\n\tshapeSize\030\002 \001(\005\022\024\n\014sha" + "peSizeMin\030\003 \001(\005\022\026\n\016shape_size_max\030\004 \001(\005\022" + "\023\n\013laser_power\030\005 \001(\005\022\027\n\017laser_power_min\030" + "\006 \001(\005\022\027\n\017laser_power_max\030\007 \001(\005\022\017\n\007defocu" + "s\030\010 \001(\001\022\023\n\013defocus_min\030\t \001(\001\022\023\n\013defocus_" + "max\030\n \001(\001\022\020\n\010is_cycle\030\013 \001(\010\022\017\n\007cross_x\030\014" + " \001(\001\022\017\n\007cross_y\030\r \001(\001\022\022\n\nz_distance\030\016 \001(" + "\001\022\034\n\024isAutoHeatingScanner\030\017 \001(\010\022!\n\031autoH" + "eatingScannerMinutes\030\020 \001(\r\022\036\n\026autoHeatin" + "gScannerSize\030\021 \001(\r\022\037\n\027autoHeatingScanner" + "Speed\030\022 \001(\001\022\031\n\021mark_test_start_x\030\023 \001(\001\022\031" + "\n\021mark_test_start_y\030\024 \001(\001\022\027\n\017mark_test_e" + "nd_x\030\025 \001(\001\022\027\n\017mark_test_end_y\030\026 \001(\001\"\314\002\n\r" + "SkyWritingCfg\022\020\n\010isEnable\030\001 \001(\010\022\017\n\007timel" + "ag\030\002 \001(\001\022\022\n\ntimelagMin\030\003 \001(\001\022\022\n\ntimelagM" + "ax\030\004 \001(\001\022\024\n\014laserOnShift\030\005 \001(\003\022\027\n\017laserO" + "nShiftMin\030\006 \001(\003\022\027\n\017laserOnShiftMax\030\007 \001(\003" + "\022\r\n\005nprev\030\010 \001(\r\022\020\n\010nprevMin\030\t \001(\r\022\020\n\010npr" + "evMax\030\n \001(\r\022\r\n\005npost\030\013 \001(\r\022\020\n\010npostMin\030\014" + " \001(\r\022\020\n\010npostMax\030\r \001(\r\022\014\n\004mode\030\016 \001(\005\022\016\n\006" + "limite\030\017 \001(\001\022\021\n\tlimiteMin\030\020 \001(\001\022\021\n\tlimit" + "eMax\030\021 \001(\001\"d\n\017PowerCompensate\022\013\n\003cno\030\001 \001" + "(\005\022\017\n\007percent\030\002 \001(\005\022\r\n\005value\030\003 \001(\002\022\021\n\tva" + "lue_min\030\004 \001(\002\022\021\n\tvalue_max\030\005 \001(\002\"j\n\023Time" + "PowerCompensate\022\n\n\002id\030\001 \001(\005\022\013\n\003cno\030\002 \001(\005" + "\022\023\n\013startMinute\030\003 \001(\r\022\021\n\tendMinute\030\004 \001(\r" + "\022\022\n\ncompensate\030\005 \001(\002*\223\001\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\006\022\t\n\005iCHAR" + "\020\007\022\n\n\006iUCHAR\020\010\022\t\n\005iWORD\020\t\022\013\n\007iDOUBLE\020\n\022\n" + "\n\006iTIMET\020\013**\n\nDATAHANDLE\022\n\n\006UPDATE\020\000\022\007\n\003" + "ADD\020\001\022\007\n\003DEL\020\0022\372\001\n\006Stream\0224\n\006Simple\022\023.st" + "ream.RequestInfo\032\023.stream.ResponseAny\"\000\022" + "=\n\014ServerStream\022\023.stream.RequestInfo\032\024.s" + "tream.ResponseInfo\"\0000\001\022=\n\014ClientStream\022\023" + ".stream.RequestInfo\032\024.stream.ResponseInf" + "o\"\000(\001\022<\n\tAllStream\022\023.stream.RequestInfo\032" + "\024.stream.ResponseInfo\"\000(\0010\001B-\n\027io.grpc.e" + "xamples.streamB\013StreamProtoP\001\242\002\002STb\006prot" + "o3" }; static const ::_pbi::DescriptorTable* const descriptor_table_stream_2eproto_deps[1] = { @@ -497,13 +1113,13 @@ static ::absl::once_flag descriptor_table_stream_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_stream_2eproto = { false, false, - 1699, + 5002, descriptor_table_protodef_stream_2eproto, "stream.proto", &descriptor_table_stream_2eproto_once, descriptor_table_stream_2eproto_deps, 1, - 12, + 21, schemas, file_default_instances, TableStruct_stream_2eproto::offsets, @@ -585,13 +1201,21 @@ ParamInfo::ParamInfo(const ParamInfo& from) : ::google::protobuf::Message() { decltype(_impl_.namekey_){}, decltype(_impl_.strvalue_){}, decltype(_impl_.context_){}, + decltype(_impl_.cardname_){}, + decltype(_impl_.cardip_){}, decltype(_impl_.valuetype_){}, + decltype(_impl_.startlayer_){}, decltype(_impl_.isenable_){}, decltype(_impl_.isalarm_){}, decltype(_impl_.isshow_){}, - decltype(_impl_.startlayer_){}, + decltype(_impl_.hadassign_){}, decltype(_impl_.endlayer_){}, decltype(_impl_.powder_){}, + decltype(_impl_.seqno_){}, + decltype(_impl_.controlno_){}, + decltype(_impl_.serialno_){}, + decltype(_impl_.controltype_){}, + decltype(_impl_.hadmatch_){}, /*decltype(_impl_._cached_size_)*/ {}, }; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -617,9 +1241,23 @@ ParamInfo::ParamInfo(const ParamInfo& from) : ::google::protobuf::Message() { if (!from._internal_context().empty()) { _this->_impl_.context_.Set(from._internal_context(), _this->GetArenaForAllocation()); } + _impl_.cardname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_cardname().empty()) { + _this->_impl_.cardname_.Set(from._internal_cardname(), _this->GetArenaForAllocation()); + } + _impl_.cardip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_cardip().empty()) { + _this->_impl_.cardip_.Set(from._internal_cardip(), _this->GetArenaForAllocation()); + } ::memcpy(&_impl_.valuetype_, &from._impl_.valuetype_, - static_cast<::size_t>(reinterpret_cast(&_impl_.powder_) - - reinterpret_cast(&_impl_.valuetype_)) + sizeof(_impl_.powder_)); + static_cast<::size_t>(reinterpret_cast(&_impl_.hadmatch_) - + reinterpret_cast(&_impl_.valuetype_)) + sizeof(_impl_.hadmatch_)); // @@protoc_insertion_point(copy_constructor:stream.ParamInfo) } @@ -629,13 +1267,21 @@ inline void ParamInfo::SharedCtor(::_pb::Arena* arena) { decltype(_impl_.namekey_){}, decltype(_impl_.strvalue_){}, decltype(_impl_.context_){}, + decltype(_impl_.cardname_){}, + decltype(_impl_.cardip_){}, decltype(_impl_.valuetype_){0}, + decltype(_impl_.startlayer_){0}, decltype(_impl_.isenable_){false}, decltype(_impl_.isalarm_){false}, decltype(_impl_.isshow_){false}, - decltype(_impl_.startlayer_){0}, + decltype(_impl_.hadassign_){false}, decltype(_impl_.endlayer_){0}, decltype(_impl_.powder_){0}, + decltype(_impl_.seqno_){0}, + decltype(_impl_.controlno_){0}, + decltype(_impl_.serialno_){0}, + decltype(_impl_.controltype_){0}, + decltype(_impl_.hadmatch_){false}, /*decltype(_impl_._cached_size_)*/ {}, }; _impl_.namekey_.InitDefault(); @@ -650,6 +1296,14 @@ inline void ParamInfo::SharedCtor(::_pb::Arena* arena) { #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING _impl_.context_.Set("", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } ParamInfo::~ParamInfo() { // @@protoc_insertion_point(destructor:stream.ParamInfo) @@ -661,6 +1315,8 @@ inline void ParamInfo::SharedDtor() { _impl_.namekey_.Destroy(); _impl_.strvalue_.Destroy(); _impl_.context_.Destroy(); + _impl_.cardname_.Destroy(); + _impl_.cardip_.Destroy(); } void ParamInfo::SetCachedSize(int size) const { _impl_._cached_size_.Set(size); @@ -675,9 +1331,11 @@ PROTOBUF_NOINLINE void ParamInfo::Clear() { _impl_.namekey_.ClearToEmpty(); _impl_.strvalue_.ClearToEmpty(); _impl_.context_.ClearToEmpty(); + _impl_.cardname_.ClearToEmpty(); + _impl_.cardip_.ClearToEmpty(); ::memset(&_impl_.valuetype_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.powder_) - - reinterpret_cast(&_impl_.valuetype_)) + sizeof(_impl_.powder_)); + reinterpret_cast(&_impl_.hadmatch_) - + reinterpret_cast(&_impl_.valuetype_)) + sizeof(_impl_.hadmatch_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } @@ -689,15 +1347,15 @@ const char* ParamInfo::_InternalParse( PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { +const ::_pbi::TcParseTable<5, 18, 0, 0, 2> ParamInfo::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ - 10, 120, // max_field_number, fast_idx_mask + 18, 248, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294966272, // skipmap + 4294705152, // skipmap offsetof(decltype(_table_), field_entries), - 10, // num_field_entries + 18, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_ParamInfo_default_instance_._instance, @@ -734,6 +1392,38 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { // float powder = 10; {::_pbi::TcParser::FastF32S1, {85, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_)}}, + // int32 seqNo = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.seqno_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.seqno_)}}, + // int32 controlNo = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.controlno_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controlno_)}}, + // int32 serialNo = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.serialno_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.serialno_)}}, + // int32 controlType = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.controltype_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controltype_)}}, + // bytes cardName = 15; + {::_pbi::TcParser::FastBS1, + {122, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardname_)}}, + // bytes cardIP = 16; + {::_pbi::TcParser::FastBS2, + {386, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardip_)}}, + // bool hadAssign = 17; + {::_pbi::TcParser::FastV8S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadassign_)}}, + // bool hadMatch = 18; + {::_pbi::TcParser::FastV8S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, @@ -772,6 +1462,30 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { // float powder = 10; {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // int32 seqNo = 11; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.seqno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 controlNo = 12; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controlno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 serialNo = 13; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.serialno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 controlType = 14; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controltype_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bytes cardName = 15; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardname_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bytes cardIP = 16; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardip_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bool hadAssign = 17; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadassign_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool hadMatch = 18; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ @@ -857,6 +1571,60 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { 10, this->_internal_powder(), target); } + // int32 seqNo = 11; + if (this->_internal_seqno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<11>( + stream, this->_internal_seqno(), target); + } + + // int32 controlNo = 12; + if (this->_internal_controlno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<12>( + stream, this->_internal_controlno(), target); + } + + // int32 serialNo = 13; + if (this->_internal_serialno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<13>( + stream, this->_internal_serialno(), target); + } + + // int32 controlType = 14; + if (this->_internal_controltype() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this->_internal_controltype(), target); + } + + // bytes cardName = 15; + if (!this->_internal_cardname().empty()) { + const std::string& _s = this->_internal_cardname(); + target = stream->WriteBytesMaybeAliased(15, _s, target); + } + + // bytes cardIP = 16; + if (!this->_internal_cardip().empty()) { + const std::string& _s = this->_internal_cardip(); + target = stream->WriteBytesMaybeAliased(16, _s, target); + } + + // bool hadAssign = 17; + if (this->_internal_hadassign() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 17, this->_internal_hadassign(), target); + } + + // bool hadMatch = 18; + if (this->_internal_hadmatch() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 18, this->_internal_hadmatch(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( @@ -892,12 +1660,30 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { this->_internal_context()); } + // bytes cardName = 15; + if (!this->_internal_cardname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->_internal_cardname()); + } + + // bytes cardIP = 16; + if (!this->_internal_cardip().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->_internal_cardip()); + } + // .stream.TYPE valueType = 3; if (this->_internal_valuetype() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_valuetype()); } + // int32 startLayer = 8; + if (this->_internal_startlayer() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_startlayer()); + } + // bool isEnable = 5; if (this->_internal_isenable() != 0) { total_size += 2; @@ -913,10 +1699,9 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { total_size += 2; } - // int32 startLayer = 8; - if (this->_internal_startlayer() != 0) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( - this->_internal_startlayer()); + // bool hadAssign = 17; + if (this->_internal_hadassign() != 0) { + total_size += 3; } // int32 endLayer = 9; @@ -935,6 +1720,35 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { total_size += 5; } + // int32 seqNo = 11; + if (this->_internal_seqno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_seqno()); + } + + // int32 controlNo = 12; + if (this->_internal_controlno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_controlno()); + } + + // int32 serialNo = 13; + if (this->_internal_serialno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_serialno()); + } + + // int32 controlType = 14; + if (this->_internal_controltype() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_controltype()); + } + + // bool hadMatch = 18; + if (this->_internal_hadmatch() != 0) { + total_size += 3; + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -962,9 +1776,18 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p if (!from._internal_context().empty()) { _this->_internal_set_context(from._internal_context()); } + if (!from._internal_cardname().empty()) { + _this->_internal_set_cardname(from._internal_cardname()); + } + if (!from._internal_cardip().empty()) { + _this->_internal_set_cardip(from._internal_cardip()); + } if (from._internal_valuetype() != 0) { _this->_internal_set_valuetype(from._internal_valuetype()); } + if (from._internal_startlayer() != 0) { + _this->_internal_set_startlayer(from._internal_startlayer()); + } if (from._internal_isenable() != 0) { _this->_internal_set_isenable(from._internal_isenable()); } @@ -974,8 +1797,8 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p if (from._internal_isshow() != 0) { _this->_internal_set_isshow(from._internal_isshow()); } - if (from._internal_startlayer() != 0) { - _this->_internal_set_startlayer(from._internal_startlayer()); + if (from._internal_hadassign() != 0) { + _this->_internal_set_hadassign(from._internal_hadassign()); } if (from._internal_endlayer() != 0) { _this->_internal_set_endlayer(from._internal_endlayer()); @@ -988,6 +1811,21 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p if (raw_powder != 0) { _this->_internal_set_powder(from._internal_powder()); } + if (from._internal_seqno() != 0) { + _this->_internal_set_seqno(from._internal_seqno()); + } + if (from._internal_controlno() != 0) { + _this->_internal_set_controlno(from._internal_controlno()); + } + if (from._internal_serialno() != 0) { + _this->_internal_set_serialno(from._internal_serialno()); + } + if (from._internal_controltype() != 0) { + _this->_internal_set_controltype(from._internal_controltype()); + } + if (from._internal_hadmatch() != 0) { + _this->_internal_set_hadmatch(from._internal_hadmatch()); + } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } @@ -1013,9 +1851,13 @@ void ParamInfo::InternalSwap(ParamInfo* other) { &other->_impl_.strvalue_, rhs_arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.context_, lhs_arena, &other->_impl_.context_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardname_, lhs_arena, + &other->_impl_.cardname_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardip_, lhs_arena, + &other->_impl_.cardip_, rhs_arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_) - + sizeof(ParamInfo::_impl_.powder_) + PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_) + + sizeof(ParamInfo::_impl_.hadmatch_) - PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.valuetype_)>( reinterpret_cast(&_impl_.valuetype_), reinterpret_cast(&other->_impl_.valuetype_)); @@ -3722,6 +4564,5342 @@ void ComResponce::InternalSwap(ComResponce* other) { &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, file_level_metadata_stream_2eproto[11]); } +// =================================================================== + +class ScannerCrtlCfgResp::_Internal { + public: +}; + +ScannerCrtlCfgResp::ScannerCrtlCfgResp(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ScannerCrtlCfgResp) +} +ScannerCrtlCfgResp::ScannerCrtlCfgResp(const ScannerCrtlCfgResp& from) : ::google::protobuf::Message() { + ScannerCrtlCfgResp* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.scannercfg_){from._impl_.scannercfg_}, + /*decltype(_impl_._cached_size_)*/ {}, + }; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:stream.ScannerCrtlCfgResp) +} +inline void ScannerCrtlCfgResp::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.scannercfg_){arena}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +ScannerCrtlCfgResp::~ScannerCrtlCfgResp() { + // @@protoc_insertion_point(destructor:stream.ScannerCrtlCfgResp) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ScannerCrtlCfgResp::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.scannercfg_.~RepeatedPtrField(); +} +void ScannerCrtlCfgResp::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ScannerCrtlCfgResp::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ScannerCrtlCfgResp) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_scannercfg()->Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ScannerCrtlCfgResp::_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> ScannerCrtlCfgResp::_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 + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_ScannerCrtlCfgResp_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // repeated .stream.ScannerCrtlCfgData scannerCfg = 1; + {::_pbi::TcParser::FastMtR1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgResp, _impl_.scannercfg_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .stream.ScannerCrtlCfgData scannerCfg = 1; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgResp, _impl_.scannercfg_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::stream::ScannerCrtlCfgData>()}, + }}, {{ + }}, +}; + +::uint8_t* ScannerCrtlCfgResp::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ScannerCrtlCfgResp) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated .stream.ScannerCrtlCfgData scannerCfg = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_scannercfg_size()); i < n; i++) { + const auto& repfield = this->_internal_scannercfg().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(1, 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.ScannerCrtlCfgResp) + return target; +} + +::size_t ScannerCrtlCfgResp::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ScannerCrtlCfgResp) + ::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.ScannerCrtlCfgData scannerCfg = 1; + total_size += 1UL * this->_internal_scannercfg_size(); + for (const auto& msg : this->_internal_scannercfg()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ScannerCrtlCfgResp::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ScannerCrtlCfgResp::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ScannerCrtlCfgResp::GetClassData() const { return &_class_data_; } + + +void ScannerCrtlCfgResp::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.ScannerCrtlCfgResp) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_scannercfg()->MergeFrom(from._internal_scannercfg()); + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ScannerCrtlCfgResp::CopyFrom(const ScannerCrtlCfgResp& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScannerCrtlCfgResp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ScannerCrtlCfgResp::IsInitialized() const { + return true; +} + +void ScannerCrtlCfgResp::InternalSwap(ScannerCrtlCfgResp* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.scannercfg_.InternalSwap(&other->_impl_.scannercfg_); +} + +::google::protobuf::Metadata ScannerCrtlCfgResp::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[12]); +} +// =================================================================== + +class ScannerCrtlCfgData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_._has_bits_); + static const ::stream::ScanParamCfg& scanparamcfg(const ScannerCrtlCfgData* msg); + static void set_has_scanparamcfg(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::stream::ScanParamCfg& hatchingparams(const ScannerCrtlCfgData* msg); + static void set_has_hatchingparams(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::stream::ScanParamCfg& borderparams(const ScannerCrtlCfgData* msg); + static void set_has_borderparams(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::stream::ScanParamCfg& supportparams(const ScannerCrtlCfgData* msg); + static void set_has_supportparams(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::stream::CorrectParamCfg& correctparamcfg(const ScannerCrtlCfgData* msg); + static void set_has_correctparamcfg(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::stream::ScanTestCfg& scantestcfg(const ScannerCrtlCfgData* msg); + static void set_has_scantestcfg(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::stream::SkyWritingCfg& skywritingcfg(const ScannerCrtlCfgData* msg); + static void set_has_skywritingcfg(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::scanparamcfg(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.scanparamcfg_; +} +const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::hatchingparams(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.hatchingparams_; +} +const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::borderparams(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.borderparams_; +} +const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::supportparams(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.supportparams_; +} +const ::stream::CorrectParamCfg& ScannerCrtlCfgData::_Internal::correctparamcfg(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.correctparamcfg_; +} +const ::stream::ScanTestCfg& ScannerCrtlCfgData::_Internal::scantestcfg(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.scantestcfg_; +} +const ::stream::SkyWritingCfg& ScannerCrtlCfgData::_Internal::skywritingcfg(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.skywritingcfg_; +} +ScannerCrtlCfgData::ScannerCrtlCfgData(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ScannerCrtlCfgData) +} +ScannerCrtlCfgData::ScannerCrtlCfgData(const ScannerCrtlCfgData& from) : ::google::protobuf::Message() { + ScannerCrtlCfgData* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_}, + /*decltype(_impl_._cached_size_)*/ {}, + decltype(_impl_.fixpointdata_){from._impl_.fixpointdata_}, + decltype(_impl_.powercompensate_){from._impl_.powercompensate_}, + decltype(_impl_.tpowercompensate_){from._impl_.tpowercompensate_}, + decltype(_impl_.cardname_){}, + decltype(_impl_.cardip_){}, + decltype(_impl_.scanparamcfg_){nullptr}, + decltype(_impl_.hatchingparams_){nullptr}, + decltype(_impl_.borderparams_){nullptr}, + decltype(_impl_.supportparams_){nullptr}, + decltype(_impl_.correctparamcfg_){nullptr}, + decltype(_impl_.scantestcfg_){nullptr}, + decltype(_impl_.skywritingcfg_){nullptr}, + decltype(_impl_.seqno_){}, + decltype(_impl_.controlno_){}, + decltype(_impl_.serialno_){}, + decltype(_impl_.controltype_){}, + decltype(_impl_.isenable_){}, + decltype(_impl_.hadassign_){}, + decltype(_impl_.hadmatch_){}, + }; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + _impl_.cardname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_cardname().empty()) { + _this->_impl_.cardname_.Set(from._internal_cardname(), _this->GetArenaForAllocation()); + } + _impl_.cardip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_cardip().empty()) { + _this->_impl_.cardip_.Set(from._internal_cardip(), _this->GetArenaForAllocation()); + } + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.scanparamcfg_ = new ::stream::ScanParamCfg(*from._impl_.scanparamcfg_); + } + if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { + _this->_impl_.hatchingparams_ = new ::stream::ScanParamCfg(*from._impl_.hatchingparams_); + } + if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) { + _this->_impl_.borderparams_ = new ::stream::ScanParamCfg(*from._impl_.borderparams_); + } + if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) { + _this->_impl_.supportparams_ = new ::stream::ScanParamCfg(*from._impl_.supportparams_); + } + if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) { + _this->_impl_.correctparamcfg_ = new ::stream::CorrectParamCfg(*from._impl_.correctparamcfg_); + } + if ((from._impl_._has_bits_[0] & 0x00000020u) != 0) { + _this->_impl_.scantestcfg_ = new ::stream::ScanTestCfg(*from._impl_.scantestcfg_); + } + if ((from._impl_._has_bits_[0] & 0x00000040u) != 0) { + _this->_impl_.skywritingcfg_ = new ::stream::SkyWritingCfg(*from._impl_.skywritingcfg_); + } + ::memcpy(&_impl_.seqno_, &from._impl_.seqno_, + static_cast<::size_t>(reinterpret_cast(&_impl_.hadmatch_) - + reinterpret_cast(&_impl_.seqno_)) + sizeof(_impl_.hadmatch_)); + + // @@protoc_insertion_point(copy_constructor:stream.ScannerCrtlCfgData) +} +inline void ScannerCrtlCfgData::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){}, + /*decltype(_impl_._cached_size_)*/ {}, + decltype(_impl_.fixpointdata_){arena}, + decltype(_impl_.powercompensate_){arena}, + decltype(_impl_.tpowercompensate_){arena}, + decltype(_impl_.cardname_){}, + decltype(_impl_.cardip_){}, + decltype(_impl_.scanparamcfg_){nullptr}, + decltype(_impl_.hatchingparams_){nullptr}, + decltype(_impl_.borderparams_){nullptr}, + decltype(_impl_.supportparams_){nullptr}, + decltype(_impl_.correctparamcfg_){nullptr}, + decltype(_impl_.scantestcfg_){nullptr}, + decltype(_impl_.skywritingcfg_){nullptr}, + decltype(_impl_.seqno_){0}, + decltype(_impl_.controlno_){0}, + decltype(_impl_.serialno_){0}, + decltype(_impl_.controltype_){0}, + decltype(_impl_.isenable_){false}, + decltype(_impl_.hadassign_){false}, + decltype(_impl_.hadmatch_){false}, + }; + _impl_.cardname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} +ScannerCrtlCfgData::~ScannerCrtlCfgData() { + // @@protoc_insertion_point(destructor:stream.ScannerCrtlCfgData) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ScannerCrtlCfgData::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.fixpointdata_.~RepeatedPtrField(); + _impl_.powercompensate_.~RepeatedPtrField(); + _impl_.tpowercompensate_.~RepeatedPtrField(); + _impl_.cardname_.Destroy(); + _impl_.cardip_.Destroy(); + if (this != internal_default_instance()) delete _impl_.scanparamcfg_; + if (this != internal_default_instance()) delete _impl_.hatchingparams_; + if (this != internal_default_instance()) delete _impl_.borderparams_; + if (this != internal_default_instance()) delete _impl_.supportparams_; + if (this != internal_default_instance()) delete _impl_.correctparamcfg_; + if (this != internal_default_instance()) delete _impl_.scantestcfg_; + if (this != internal_default_instance()) delete _impl_.skywritingcfg_; +} +void ScannerCrtlCfgData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ScannerCrtlCfgData::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ScannerCrtlCfgData) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_fixpointdata()->Clear(); + _internal_mutable_powercompensate()->Clear(); + _internal_mutable_tpowercompensate()->Clear(); + _impl_.cardname_.ClearToEmpty(); + _impl_.cardip_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.scanparamcfg_ != nullptr); + _impl_.scanparamcfg_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.hatchingparams_ != nullptr); + _impl_.hatchingparams_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + ABSL_DCHECK(_impl_.borderparams_ != nullptr); + _impl_.borderparams_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + ABSL_DCHECK(_impl_.supportparams_ != nullptr); + _impl_.supportparams_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + ABSL_DCHECK(_impl_.correctparamcfg_ != nullptr); + _impl_.correctparamcfg_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + ABSL_DCHECK(_impl_.scantestcfg_ != nullptr); + _impl_.scantestcfg_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + ABSL_DCHECK(_impl_.skywritingcfg_ != nullptr); + _impl_.skywritingcfg_->Clear(); + } + } + ::memset(&_impl_.seqno_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.hadmatch_) - + reinterpret_cast(&_impl_.seqno_)) + sizeof(_impl_.hadmatch_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ScannerCrtlCfgData::_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<5, 19, 10, 0, 2> ScannerCrtlCfgData::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_._has_bits_), + 0, // no _extensions_ + 19, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294443008, // skipmap + offsetof(decltype(_table_), field_entries), + 19, // num_field_entries + 10, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_ScannerCrtlCfgData_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 seqNo = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.seqno_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.seqno_)}}, + // repeated .stream.FixPointData fixPointData = 2; + {::_pbi::TcParser::FastMtR1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.fixpointdata_)}}, + // .stream.ScanParamCfg scanParamCfg = 3; + {::_pbi::TcParser::FastMtS1, + {26, 0, 1, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_)}}, + // .stream.ScanParamCfg hatchingParams = 4; + {::_pbi::TcParser::FastMtS1, + {34, 1, 2, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hatchingparams_)}}, + // .stream.ScanParamCfg borderParams = 5; + {::_pbi::TcParser::FastMtS1, + {42, 2, 3, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.borderparams_)}}, + // .stream.ScanParamCfg supportParams = 6; + {::_pbi::TcParser::FastMtS1, + {50, 3, 4, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.supportparams_)}}, + // .stream.CorrectParamCfg correctParamCfg = 7; + {::_pbi::TcParser::FastMtS1, + {58, 4, 5, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.correctparamcfg_)}}, + // .stream.ScanTestCfg scanTestCfg = 8; + {::_pbi::TcParser::FastMtS1, + {66, 5, 6, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scantestcfg_)}}, + // .stream.SkyWritingCfg skyWritingCfg = 9; + {::_pbi::TcParser::FastMtS1, + {74, 6, 7, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.skywritingcfg_)}}, + // repeated .stream.PowerCompensate powerCompensate = 10; + {::_pbi::TcParser::FastMtR1, + {82, 63, 8, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.powercompensate_)}}, + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + {::_pbi::TcParser::FastMtR1, + {90, 63, 9, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.tpowercompensate_)}}, + // int32 controlNo = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.controlno_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controlno_)}}, + // int32 serialNo = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.serialno_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.serialno_)}}, + // int32 controlType = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.controltype_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controltype_)}}, + // bytes cardName = 15; + {::_pbi::TcParser::FastBS1, + {122, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardname_)}}, + // bytes cardIP = 16; + {::_pbi::TcParser::FastBS2, + {386, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardip_)}}, + // bool isEnable = 17; + {::_pbi::TcParser::FastV8S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.isenable_)}}, + // bool hadAssign = 18; + {::_pbi::TcParser::FastV8S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadassign_)}}, + // bool hadMatch = 19; + {::_pbi::TcParser::FastV8S2, + {408, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 seqNo = 1; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.seqno_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // repeated .stream.FixPointData fixPointData = 2; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.fixpointdata_), -1, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanParamCfg scanParamCfg = 3; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_), _Internal::kHasBitsOffset + 0, 1, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanParamCfg hatchingParams = 4; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hatchingparams_), _Internal::kHasBitsOffset + 1, 2, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanParamCfg borderParams = 5; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.borderparams_), _Internal::kHasBitsOffset + 2, 3, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanParamCfg supportParams = 6; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.supportparams_), _Internal::kHasBitsOffset + 3, 4, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.CorrectParamCfg correctParamCfg = 7; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.correctparamcfg_), _Internal::kHasBitsOffset + 4, 5, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanTestCfg scanTestCfg = 8; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scantestcfg_), _Internal::kHasBitsOffset + 5, 6, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.SkyWritingCfg skyWritingCfg = 9; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.skywritingcfg_), _Internal::kHasBitsOffset + 6, 7, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .stream.PowerCompensate powerCompensate = 10; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.powercompensate_), -1, 8, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.tpowercompensate_), -1, 9, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // int32 controlNo = 12; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controlno_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 serialNo = 13; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.serialno_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 controlType = 14; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controltype_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bytes cardName = 15; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardname_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bytes cardIP = 16; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardip_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bool isEnable = 17; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.isenable_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool hadAssign = 18; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadassign_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool hadMatch = 19; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, {{ + {::_pbi::TcParser::GetTable<::stream::FixPointData>()}, + {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::CorrectParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::ScanTestCfg>()}, + {::_pbi::TcParser::GetTable<::stream::SkyWritingCfg>()}, + {::_pbi::TcParser::GetTable<::stream::PowerCompensate>()}, + {::_pbi::TcParser::GetTable<::stream::TimePowerCompensate>()}, + }}, {{ + }}, +}; + +::uint8_t* ScannerCrtlCfgData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ScannerCrtlCfgData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 seqNo = 1; + if (this->_internal_seqno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_seqno(), target); + } + + // repeated .stream.FixPointData fixPointData = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_fixpointdata_size()); i < n; i++) { + const auto& repfield = this->_internal_fixpointdata().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[0]; + // .stream.ScanParamCfg scanParamCfg = 3; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::scanparamcfg(this), + _Internal::scanparamcfg(this).GetCachedSize(), target, stream); + } + + // .stream.ScanParamCfg hatchingParams = 4; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::hatchingparams(this), + _Internal::hatchingparams(this).GetCachedSize(), target, stream); + } + + // .stream.ScanParamCfg borderParams = 5; + if (cached_has_bits & 0x00000004u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::borderparams(this), + _Internal::borderparams(this).GetCachedSize(), target, stream); + } + + // .stream.ScanParamCfg supportParams = 6; + if (cached_has_bits & 0x00000008u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::supportparams(this), + _Internal::supportparams(this).GetCachedSize(), target, stream); + } + + // .stream.CorrectParamCfg correctParamCfg = 7; + if (cached_has_bits & 0x00000010u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::correctparamcfg(this), + _Internal::correctparamcfg(this).GetCachedSize(), target, stream); + } + + // .stream.ScanTestCfg scanTestCfg = 8; + if (cached_has_bits & 0x00000020u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::scantestcfg(this), + _Internal::scantestcfg(this).GetCachedSize(), target, stream); + } + + // .stream.SkyWritingCfg skyWritingCfg = 9; + if (cached_has_bits & 0x00000040u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(9, _Internal::skywritingcfg(this), + _Internal::skywritingcfg(this).GetCachedSize(), target, stream); + } + + // repeated .stream.PowerCompensate powerCompensate = 10; + for (unsigned i = 0, + n = static_cast(this->_internal_powercompensate_size()); i < n; i++) { + const auto& repfield = this->_internal_powercompensate().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(10, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + for (unsigned i = 0, + n = static_cast(this->_internal_tpowercompensate_size()); i < n; i++) { + const auto& repfield = this->_internal_tpowercompensate().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream); + } + + // int32 controlNo = 12; + if (this->_internal_controlno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<12>( + stream, this->_internal_controlno(), target); + } + + // int32 serialNo = 13; + if (this->_internal_serialno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<13>( + stream, this->_internal_serialno(), target); + } + + // int32 controlType = 14; + if (this->_internal_controltype() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this->_internal_controltype(), target); + } + + // bytes cardName = 15; + if (!this->_internal_cardname().empty()) { + const std::string& _s = this->_internal_cardname(); + target = stream->WriteBytesMaybeAliased(15, _s, target); + } + + // bytes cardIP = 16; + if (!this->_internal_cardip().empty()) { + const std::string& _s = this->_internal_cardip(); + target = stream->WriteBytesMaybeAliased(16, _s, target); + } + + // bool isEnable = 17; + if (this->_internal_isenable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 17, this->_internal_isenable(), target); + } + + // bool hadAssign = 18; + if (this->_internal_hadassign() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 18, this->_internal_hadassign(), target); + } + + // bool hadMatch = 19; + if (this->_internal_hadmatch() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 19, this->_internal_hadmatch(), 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.ScannerCrtlCfgData) + return target; +} + +::size_t ScannerCrtlCfgData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ScannerCrtlCfgData) + ::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.FixPointData fixPointData = 2; + total_size += 1UL * this->_internal_fixpointdata_size(); + for (const auto& msg : this->_internal_fixpointdata()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // repeated .stream.PowerCompensate powerCompensate = 10; + total_size += 1UL * this->_internal_powercompensate_size(); + for (const auto& msg : this->_internal_powercompensate()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + total_size += 1UL * this->_internal_tpowercompensate_size(); + for (const auto& msg : this->_internal_tpowercompensate()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // bytes cardName = 15; + if (!this->_internal_cardname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->_internal_cardname()); + } + + // bytes cardIP = 16; + if (!this->_internal_cardip().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->_internal_cardip()); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // .stream.ScanParamCfg scanParamCfg = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.scanparamcfg_); + } + + // .stream.ScanParamCfg hatchingParams = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.hatchingparams_); + } + + // .stream.ScanParamCfg borderParams = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.borderparams_); + } + + // .stream.ScanParamCfg supportParams = 6; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.supportparams_); + } + + // .stream.CorrectParamCfg correctParamCfg = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.correctparamcfg_); + } + + // .stream.ScanTestCfg scanTestCfg = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.scantestcfg_); + } + + // .stream.SkyWritingCfg skyWritingCfg = 9; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.skywritingcfg_); + } + + } + // int32 seqNo = 1; + if (this->_internal_seqno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_seqno()); + } + + // int32 controlNo = 12; + if (this->_internal_controlno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_controlno()); + } + + // int32 serialNo = 13; + if (this->_internal_serialno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_serialno()); + } + + // int32 controlType = 14; + if (this->_internal_controltype() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_controltype()); + } + + // bool isEnable = 17; + if (this->_internal_isenable() != 0) { + total_size += 3; + } + + // bool hadAssign = 18; + if (this->_internal_hadassign() != 0) { + total_size += 3; + } + + // bool hadMatch = 19; + if (this->_internal_hadmatch() != 0) { + total_size += 3; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ScannerCrtlCfgData::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ScannerCrtlCfgData::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ScannerCrtlCfgData::GetClassData() const { return &_class_data_; } + + +void ScannerCrtlCfgData::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.ScannerCrtlCfgData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_fixpointdata()->MergeFrom(from._internal_fixpointdata()); + _this->_internal_mutable_powercompensate()->MergeFrom(from._internal_powercompensate()); + _this->_internal_mutable_tpowercompensate()->MergeFrom(from._internal_tpowercompensate()); + if (!from._internal_cardname().empty()) { + _this->_internal_set_cardname(from._internal_cardname()); + } + if (!from._internal_cardip().empty()) { + _this->_internal_set_cardip(from._internal_cardip()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_scanparamcfg()->::stream::ScanParamCfg::MergeFrom( + from._internal_scanparamcfg()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_hatchingparams()->::stream::ScanParamCfg::MergeFrom( + from._internal_hatchingparams()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_borderparams()->::stream::ScanParamCfg::MergeFrom( + from._internal_borderparams()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_supportparams()->::stream::ScanParamCfg::MergeFrom( + from._internal_supportparams()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_correctparamcfg()->::stream::CorrectParamCfg::MergeFrom( + from._internal_correctparamcfg()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_scantestcfg()->::stream::ScanTestCfg::MergeFrom( + from._internal_scantestcfg()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_skywritingcfg()->::stream::SkyWritingCfg::MergeFrom( + from._internal_skywritingcfg()); + } + } + if (from._internal_seqno() != 0) { + _this->_internal_set_seqno(from._internal_seqno()); + } + if (from._internal_controlno() != 0) { + _this->_internal_set_controlno(from._internal_controlno()); + } + if (from._internal_serialno() != 0) { + _this->_internal_set_serialno(from._internal_serialno()); + } + if (from._internal_controltype() != 0) { + _this->_internal_set_controltype(from._internal_controltype()); + } + if (from._internal_isenable() != 0) { + _this->_internal_set_isenable(from._internal_isenable()); + } + if (from._internal_hadassign() != 0) { + _this->_internal_set_hadassign(from._internal_hadassign()); + } + if (from._internal_hadmatch() != 0) { + _this->_internal_set_hadmatch(from._internal_hadmatch()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ScannerCrtlCfgData::CopyFrom(const ScannerCrtlCfgData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScannerCrtlCfgData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ScannerCrtlCfgData::IsInitialized() const { + return true; +} + +void ScannerCrtlCfgData::InternalSwap(ScannerCrtlCfgData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.fixpointdata_.InternalSwap(&other->_impl_.fixpointdata_); + _impl_.powercompensate_.InternalSwap(&other->_impl_.powercompensate_); + _impl_.tpowercompensate_.InternalSwap(&other->_impl_.tpowercompensate_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardname_, lhs_arena, + &other->_impl_.cardname_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardip_, lhs_arena, + &other->_impl_.cardip_, rhs_arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_) + + sizeof(ScannerCrtlCfgData::_impl_.hadmatch_) + - PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_)>( + reinterpret_cast(&_impl_.scanparamcfg_), + reinterpret_cast(&other->_impl_.scanparamcfg_)); +} + +::google::protobuf::Metadata ScannerCrtlCfgData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[13]); +} +// =================================================================== + +class FixPointData::_Internal { + public: +}; + +FixPointData::FixPointData(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.FixPointData) +} +FixPointData::FixPointData(const FixPointData& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.FixPointData) +} +inline void FixPointData::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.id_){0}, + decltype(_impl_.cno_){0}, + decltype(_impl_.pointx_){0}, + decltype(_impl_.pointy_){0}, + decltype(_impl_.duration_){0u}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +FixPointData::~FixPointData() { + // @@protoc_insertion_point(destructor:stream.FixPointData) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void FixPointData::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void FixPointData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void FixPointData::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.FixPointData) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.duration_) - + reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.duration_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* FixPointData::_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, 0, 0, 2> FixPointData::_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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_FixPointData_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_)}}, + // int32 cno = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.cno_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.cno_)}}, + // float pointX = 3; + {::_pbi::TcParser::FastF32S1, + {29, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointx_)}}, + // float pointY = 4; + {::_pbi::TcParser::FastF32S1, + {37, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointy_)}}, + // uint32 duration = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.duration_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 id = 1; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 cno = 2; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.cno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // float pointX = 3; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float pointY = 4; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointy_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // uint32 duration = 5; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* FixPointData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.FixPointData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 id = 1; + if (this->_internal_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_id(), target); + } + + // int32 cno = 2; + if (this->_internal_cno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_cno(), target); + } + + // float pointX = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointx = this->_internal_pointx(); + ::uint32_t raw_pointx; + memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx)); + if (raw_pointx != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 3, this->_internal_pointx(), target); + } + + // float pointY = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointy = this->_internal_pointy(); + ::uint32_t raw_pointy; + memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy)); + if (raw_pointy != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 4, this->_internal_pointy(), target); + } + + // uint32 duration = 5; + if (this->_internal_duration() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 5, this->_internal_duration(), 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.FixPointData) + return target; +} + +::size_t FixPointData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.FixPointData) + ::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 id = 1; + if (this->_internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_id()); + } + + // int32 cno = 2; + if (this->_internal_cno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_cno()); + } + + // float pointX = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointx = this->_internal_pointx(); + ::uint32_t raw_pointx; + memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx)); + if (raw_pointx != 0) { + total_size += 5; + } + + // float pointY = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointy = this->_internal_pointy(); + ::uint32_t raw_pointy; + memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy)); + if (raw_pointy != 0) { + total_size += 5; + } + + // uint32 duration = 5; + if (this->_internal_duration() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_duration()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData FixPointData::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + FixPointData::MergeImpl +}; +const ::google::protobuf::Message::ClassData*FixPointData::GetClassData() const { return &_class_data_; } + + +void FixPointData::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.FixPointData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_internal_set_id(from._internal_id()); + } + if (from._internal_cno() != 0) { + _this->_internal_set_cno(from._internal_cno()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointx = from._internal_pointx(); + ::uint32_t raw_pointx; + memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx)); + if (raw_pointx != 0) { + _this->_internal_set_pointx(from._internal_pointx()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointy = from._internal_pointy(); + ::uint32_t raw_pointy; + memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy)); + if (raw_pointy != 0) { + _this->_internal_set_pointy(from._internal_pointy()); + } + if (from._internal_duration() != 0) { + _this->_internal_set_duration(from._internal_duration()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void FixPointData::CopyFrom(const FixPointData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.FixPointData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool FixPointData::IsInitialized() const { + return true; +} + +void FixPointData::InternalSwap(FixPointData* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_) + + sizeof(FixPointData::_impl_.duration_) + - PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_)>( + reinterpret_cast(&_impl_.id_), + reinterpret_cast(&other->_impl_.id_)); +} + +::google::protobuf::Metadata FixPointData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[14]); +} +// =================================================================== + +class ScanParamCfg::_Internal { + public: +}; + +ScanParamCfg::ScanParamCfg(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ScanParamCfg) +} +ScanParamCfg::ScanParamCfg(const ScanParamCfg& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.ScanParamCfg) +} +inline void ScanParamCfg::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.edgelevel_){0}, + decltype(_impl_.edgelevelmin_){0}, + decltype(_impl_.edgelevelmax_){0}, + decltype(_impl_.jumpdelay_){0u}, + decltype(_impl_.jumpdelaymin_){0u}, + decltype(_impl_.jumpdelaymax_){0u}, + decltype(_impl_.scandelay_){0u}, + decltype(_impl_.scandelaymin_){0u}, + decltype(_impl_.scandelaymax_){0u}, + decltype(_impl_.polygondelay_){0u}, + decltype(_impl_.polygondelaymin_){0u}, + decltype(_impl_.polygondelaymax_){0u}, + decltype(_impl_.laseroffdelay_){::int64_t{0}}, + decltype(_impl_.laseroffdelaymin_){::int64_t{0}}, + decltype(_impl_.laseroffdelaymax_){::int64_t{0}}, + decltype(_impl_.laserondelay_){::int64_t{0}}, + decltype(_impl_.laserondelaymin_){::int64_t{0}}, + decltype(_impl_.laserondelaymax_){::int64_t{0}}, + decltype(_impl_.minjumpdelay_){0u}, + decltype(_impl_.minjumpdelaymin_){0u}, + decltype(_impl_.minjumpdelaymax_){0u}, + decltype(_impl_.jumplengthlimit_){0u}, + decltype(_impl_.jumplengthlimitmin_){0u}, + decltype(_impl_.jumplengthlimitmax_){0u}, + decltype(_impl_.jumpspeed_){0}, + decltype(_impl_.jumpspeedmin_){0}, + decltype(_impl_.jumpspeedmax_){0}, + decltype(_impl_.markspeed_){0}, + decltype(_impl_.markspeedmin_){0}, + decltype(_impl_.markspeedmax_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +ScanParamCfg::~ScanParamCfg() { + // @@protoc_insertion_point(destructor:stream.ScanParamCfg) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ScanParamCfg::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void ScanParamCfg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ScanParamCfg::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ScanParamCfg) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.edgelevel_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.markspeedmax_) - + reinterpret_cast(&_impl_.edgelevel_)) + sizeof(_impl_.markspeedmax_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ScanParamCfg::_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<5, 30, 0, 0, 2> ScanParamCfg::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 30, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 3221225472, // skipmap + offsetof(decltype(_table_), field_entries), + 30, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_ScanParamCfg_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 edgeLevel = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevel_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_)}}, + // int32 edgeLevelMin = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevelmin_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmin_)}}, + // int32 edgeLevelMax = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevelmax_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmax_)}}, + // uint32 jumpDelay = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelay_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelay_)}}, + // uint32 jumpDelayMin = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelaymin_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymin_)}}, + // uint32 jumpDelayMax = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelaymax_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymax_)}}, + // uint32 scanDelay = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelay_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelay_)}}, + // uint32 scanDelayMin = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelaymin_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymin_)}}, + // uint32 scanDelayMax = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelaymax_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymax_)}}, + // uint32 polygonDelay = 10; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelay_), 63>(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelay_)}}, + // uint32 polygonDelayMin = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelaymin_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymin_)}}, + // uint32 polygonDelayMax = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelaymax_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymax_)}}, + // int64 laseroffDelay = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelay_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelay_)}}, + // int64 laseroffDelayMin = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelaymin_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymin_)}}, + // int64 laseroffDelayMax = 15; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelaymax_), 63>(), + {120, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymax_)}}, + // int64 laseronDelay = 16; + {::_pbi::TcParser::FastV64S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelay_)}}, + // int64 laseronDelayMin = 17; + {::_pbi::TcParser::FastV64S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymin_)}}, + // int64 laseronDelayMax = 18; + {::_pbi::TcParser::FastV64S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymax_)}}, + // uint32 minJumpDelay = 19; + {::_pbi::TcParser::FastV32S2, + {408, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelay_)}}, + // uint32 minJumpDelayMin = 20; + {::_pbi::TcParser::FastV32S2, + {416, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymin_)}}, + // uint32 minJumpDelayMax = 21; + {::_pbi::TcParser::FastV32S2, + {424, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymax_)}}, + // uint32 jumpLengthLimit = 22; + {::_pbi::TcParser::FastV32S2, + {432, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimit_)}}, + // uint32 jumpLengthLimitMin = 23; + {::_pbi::TcParser::FastV32S2, + {440, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmin_)}}, + // uint32 jumpLengthLimitMax = 24; + {::_pbi::TcParser::FastV32S2, + {448, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmax_)}}, + // double jumpSpeed = 25; + {::_pbi::TcParser::FastF64S2, + {457, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeed_)}}, + // double jumpSpeedMin = 26; + {::_pbi::TcParser::FastF64S2, + {465, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmin_)}}, + // double jumpSpeedMax = 27; + {::_pbi::TcParser::FastF64S2, + {473, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmax_)}}, + // double markSpeed = 28; + {::_pbi::TcParser::FastF64S2, + {481, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeed_)}}, + // double markSpeedMin = 29; + {::_pbi::TcParser::FastF64S2, + {489, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmin_)}}, + // double markSpeedMax = 30; + {::_pbi::TcParser::FastF64S2, + {497, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 edgeLevel = 1; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 edgeLevelMin = 2; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 edgeLevelMax = 3; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint32 jumpDelay = 4; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpDelayMin = 5; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpDelayMax = 6; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 scanDelay = 7; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 scanDelayMin = 8; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 scanDelayMax = 9; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 polygonDelay = 10; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 polygonDelayMin = 11; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 polygonDelayMax = 12; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // int64 laseroffDelay = 13; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseroffDelayMin = 14; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseroffDelayMax = 15; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseronDelay = 16; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseronDelayMin = 17; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseronDelayMax = 18; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // uint32 minJumpDelay = 19; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 minJumpDelayMin = 20; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 minJumpDelayMax = 21; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpLengthLimit = 22; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimit_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpLengthLimitMin = 23; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpLengthLimitMax = 24; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // double jumpSpeed = 25; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeed_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double jumpSpeedMin = 26; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double jumpSpeedMax = 27; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double markSpeed = 28; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeed_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double markSpeedMin = 29; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double markSpeedMax = 30; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* ScanParamCfg::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ScanParamCfg) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 edgeLevel = 1; + if (this->_internal_edgelevel() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_edgelevel(), target); + } + + // int32 edgeLevelMin = 2; + if (this->_internal_edgelevelmin() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_edgelevelmin(), target); + } + + // int32 edgeLevelMax = 3; + if (this->_internal_edgelevelmax() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this->_internal_edgelevelmax(), target); + } + + // uint32 jumpDelay = 4; + if (this->_internal_jumpdelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 4, this->_internal_jumpdelay(), target); + } + + // uint32 jumpDelayMin = 5; + if (this->_internal_jumpdelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 5, this->_internal_jumpdelaymin(), target); + } + + // uint32 jumpDelayMax = 6; + if (this->_internal_jumpdelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 6, this->_internal_jumpdelaymax(), target); + } + + // uint32 scanDelay = 7; + if (this->_internal_scandelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 7, this->_internal_scandelay(), target); + } + + // uint32 scanDelayMin = 8; + if (this->_internal_scandelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 8, this->_internal_scandelaymin(), target); + } + + // uint32 scanDelayMax = 9; + if (this->_internal_scandelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this->_internal_scandelaymax(), target); + } + + // uint32 polygonDelay = 10; + if (this->_internal_polygondelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 10, this->_internal_polygondelay(), target); + } + + // uint32 polygonDelayMin = 11; + if (this->_internal_polygondelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 11, this->_internal_polygondelaymin(), target); + } + + // uint32 polygonDelayMax = 12; + if (this->_internal_polygondelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 12, this->_internal_polygondelaymax(), target); + } + + // int64 laseroffDelay = 13; + if (this->_internal_laseroffdelay() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<13>( + stream, this->_internal_laseroffdelay(), target); + } + + // int64 laseroffDelayMin = 14; + if (this->_internal_laseroffdelaymin() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<14>( + stream, this->_internal_laseroffdelaymin(), target); + } + + // int64 laseroffDelayMax = 15; + if (this->_internal_laseroffdelaymax() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<15>( + stream, this->_internal_laseroffdelaymax(), target); + } + + // int64 laseronDelay = 16; + if (this->_internal_laserondelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 16, this->_internal_laserondelay(), target); + } + + // int64 laseronDelayMin = 17; + if (this->_internal_laserondelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 17, this->_internal_laserondelaymin(), target); + } + + // int64 laseronDelayMax = 18; + if (this->_internal_laserondelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 18, this->_internal_laserondelaymax(), target); + } + + // uint32 minJumpDelay = 19; + if (this->_internal_minjumpdelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 19, this->_internal_minjumpdelay(), target); + } + + // uint32 minJumpDelayMin = 20; + if (this->_internal_minjumpdelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 20, this->_internal_minjumpdelaymin(), target); + } + + // uint32 minJumpDelayMax = 21; + if (this->_internal_minjumpdelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 21, this->_internal_minjumpdelaymax(), target); + } + + // uint32 jumpLengthLimit = 22; + if (this->_internal_jumplengthlimit() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 22, this->_internal_jumplengthlimit(), target); + } + + // uint32 jumpLengthLimitMin = 23; + if (this->_internal_jumplengthlimitmin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 23, this->_internal_jumplengthlimitmin(), target); + } + + // uint32 jumpLengthLimitMax = 24; + if (this->_internal_jumplengthlimitmax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 24, this->_internal_jumplengthlimitmax(), target); + } + + // double jumpSpeed = 25; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeed = this->_internal_jumpspeed(); + ::uint64_t raw_jumpspeed; + memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed)); + if (raw_jumpspeed != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 25, this->_internal_jumpspeed(), target); + } + + // double jumpSpeedMin = 26; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmin = this->_internal_jumpspeedmin(); + ::uint64_t raw_jumpspeedmin; + memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin)); + if (raw_jumpspeedmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 26, this->_internal_jumpspeedmin(), target); + } + + // double jumpSpeedMax = 27; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmax = this->_internal_jumpspeedmax(); + ::uint64_t raw_jumpspeedmax; + memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax)); + if (raw_jumpspeedmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 27, this->_internal_jumpspeedmax(), target); + } + + // double markSpeed = 28; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeed = this->_internal_markspeed(); + ::uint64_t raw_markspeed; + memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed)); + if (raw_markspeed != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 28, this->_internal_markspeed(), target); + } + + // double markSpeedMin = 29; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmin = this->_internal_markspeedmin(); + ::uint64_t raw_markspeedmin; + memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin)); + if (raw_markspeedmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 29, this->_internal_markspeedmin(), target); + } + + // double markSpeedMax = 30; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmax = this->_internal_markspeedmax(); + ::uint64_t raw_markspeedmax; + memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax)); + if (raw_markspeedmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 30, this->_internal_markspeedmax(), 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.ScanParamCfg) + return target; +} + +::size_t ScanParamCfg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ScanParamCfg) + ::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 edgeLevel = 1; + if (this->_internal_edgelevel() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_edgelevel()); + } + + // int32 edgeLevelMin = 2; + if (this->_internal_edgelevelmin() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_edgelevelmin()); + } + + // int32 edgeLevelMax = 3; + if (this->_internal_edgelevelmax() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_edgelevelmax()); + } + + // uint32 jumpDelay = 4; + if (this->_internal_jumpdelay() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_jumpdelay()); + } + + // uint32 jumpDelayMin = 5; + if (this->_internal_jumpdelaymin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_jumpdelaymin()); + } + + // uint32 jumpDelayMax = 6; + if (this->_internal_jumpdelaymax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_jumpdelaymax()); + } + + // uint32 scanDelay = 7; + if (this->_internal_scandelay() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_scandelay()); + } + + // uint32 scanDelayMin = 8; + if (this->_internal_scandelaymin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_scandelaymin()); + } + + // uint32 scanDelayMax = 9; + if (this->_internal_scandelaymax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_scandelaymax()); + } + + // uint32 polygonDelay = 10; + if (this->_internal_polygondelay() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_polygondelay()); + } + + // uint32 polygonDelayMin = 11; + if (this->_internal_polygondelaymin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_polygondelaymin()); + } + + // uint32 polygonDelayMax = 12; + if (this->_internal_polygondelaymax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_polygondelaymax()); + } + + // int64 laseroffDelay = 13; + if (this->_internal_laseroffdelay() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseroffdelay()); + } + + // int64 laseroffDelayMin = 14; + if (this->_internal_laseroffdelaymin() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseroffdelaymin()); + } + + // int64 laseroffDelayMax = 15; + if (this->_internal_laseroffdelaymax() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseroffdelaymax()); + } + + // int64 laseronDelay = 16; + if (this->_internal_laserondelay() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int64Size( + this->_internal_laserondelay()); + } + + // int64 laseronDelayMin = 17; + if (this->_internal_laserondelaymin() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int64Size( + this->_internal_laserondelaymin()); + } + + // int64 laseronDelayMax = 18; + if (this->_internal_laserondelaymax() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int64Size( + this->_internal_laserondelaymax()); + } + + // uint32 minJumpDelay = 19; + if (this->_internal_minjumpdelay() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_minjumpdelay()); + } + + // uint32 minJumpDelayMin = 20; + if (this->_internal_minjumpdelaymin() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_minjumpdelaymin()); + } + + // uint32 minJumpDelayMax = 21; + if (this->_internal_minjumpdelaymax() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_minjumpdelaymax()); + } + + // uint32 jumpLengthLimit = 22; + if (this->_internal_jumplengthlimit() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_jumplengthlimit()); + } + + // uint32 jumpLengthLimitMin = 23; + if (this->_internal_jumplengthlimitmin() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_jumplengthlimitmin()); + } + + // uint32 jumpLengthLimitMax = 24; + if (this->_internal_jumplengthlimitmax() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_jumplengthlimitmax()); + } + + // double jumpSpeed = 25; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeed = this->_internal_jumpspeed(); + ::uint64_t raw_jumpspeed; + memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed)); + if (raw_jumpspeed != 0) { + total_size += 10; + } + + // double jumpSpeedMin = 26; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmin = this->_internal_jumpspeedmin(); + ::uint64_t raw_jumpspeedmin; + memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin)); + if (raw_jumpspeedmin != 0) { + total_size += 10; + } + + // double jumpSpeedMax = 27; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmax = this->_internal_jumpspeedmax(); + ::uint64_t raw_jumpspeedmax; + memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax)); + if (raw_jumpspeedmax != 0) { + total_size += 10; + } + + // double markSpeed = 28; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeed = this->_internal_markspeed(); + ::uint64_t raw_markspeed; + memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed)); + if (raw_markspeed != 0) { + total_size += 10; + } + + // double markSpeedMin = 29; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmin = this->_internal_markspeedmin(); + ::uint64_t raw_markspeedmin; + memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin)); + if (raw_markspeedmin != 0) { + total_size += 10; + } + + // double markSpeedMax = 30; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmax = this->_internal_markspeedmax(); + ::uint64_t raw_markspeedmax; + memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax)); + if (raw_markspeedmax != 0) { + total_size += 10; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ScanParamCfg::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ScanParamCfg::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ScanParamCfg::GetClassData() const { return &_class_data_; } + + +void ScanParamCfg::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.ScanParamCfg) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_edgelevel() != 0) { + _this->_internal_set_edgelevel(from._internal_edgelevel()); + } + if (from._internal_edgelevelmin() != 0) { + _this->_internal_set_edgelevelmin(from._internal_edgelevelmin()); + } + if (from._internal_edgelevelmax() != 0) { + _this->_internal_set_edgelevelmax(from._internal_edgelevelmax()); + } + if (from._internal_jumpdelay() != 0) { + _this->_internal_set_jumpdelay(from._internal_jumpdelay()); + } + if (from._internal_jumpdelaymin() != 0) { + _this->_internal_set_jumpdelaymin(from._internal_jumpdelaymin()); + } + if (from._internal_jumpdelaymax() != 0) { + _this->_internal_set_jumpdelaymax(from._internal_jumpdelaymax()); + } + if (from._internal_scandelay() != 0) { + _this->_internal_set_scandelay(from._internal_scandelay()); + } + if (from._internal_scandelaymin() != 0) { + _this->_internal_set_scandelaymin(from._internal_scandelaymin()); + } + if (from._internal_scandelaymax() != 0) { + _this->_internal_set_scandelaymax(from._internal_scandelaymax()); + } + if (from._internal_polygondelay() != 0) { + _this->_internal_set_polygondelay(from._internal_polygondelay()); + } + if (from._internal_polygondelaymin() != 0) { + _this->_internal_set_polygondelaymin(from._internal_polygondelaymin()); + } + if (from._internal_polygondelaymax() != 0) { + _this->_internal_set_polygondelaymax(from._internal_polygondelaymax()); + } + if (from._internal_laseroffdelay() != 0) { + _this->_internal_set_laseroffdelay(from._internal_laseroffdelay()); + } + if (from._internal_laseroffdelaymin() != 0) { + _this->_internal_set_laseroffdelaymin(from._internal_laseroffdelaymin()); + } + if (from._internal_laseroffdelaymax() != 0) { + _this->_internal_set_laseroffdelaymax(from._internal_laseroffdelaymax()); + } + if (from._internal_laserondelay() != 0) { + _this->_internal_set_laserondelay(from._internal_laserondelay()); + } + if (from._internal_laserondelaymin() != 0) { + _this->_internal_set_laserondelaymin(from._internal_laserondelaymin()); + } + if (from._internal_laserondelaymax() != 0) { + _this->_internal_set_laserondelaymax(from._internal_laserondelaymax()); + } + if (from._internal_minjumpdelay() != 0) { + _this->_internal_set_minjumpdelay(from._internal_minjumpdelay()); + } + if (from._internal_minjumpdelaymin() != 0) { + _this->_internal_set_minjumpdelaymin(from._internal_minjumpdelaymin()); + } + if (from._internal_minjumpdelaymax() != 0) { + _this->_internal_set_minjumpdelaymax(from._internal_minjumpdelaymax()); + } + if (from._internal_jumplengthlimit() != 0) { + _this->_internal_set_jumplengthlimit(from._internal_jumplengthlimit()); + } + if (from._internal_jumplengthlimitmin() != 0) { + _this->_internal_set_jumplengthlimitmin(from._internal_jumplengthlimitmin()); + } + if (from._internal_jumplengthlimitmax() != 0) { + _this->_internal_set_jumplengthlimitmax(from._internal_jumplengthlimitmax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeed = from._internal_jumpspeed(); + ::uint64_t raw_jumpspeed; + memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed)); + if (raw_jumpspeed != 0) { + _this->_internal_set_jumpspeed(from._internal_jumpspeed()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmin = from._internal_jumpspeedmin(); + ::uint64_t raw_jumpspeedmin; + memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin)); + if (raw_jumpspeedmin != 0) { + _this->_internal_set_jumpspeedmin(from._internal_jumpspeedmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmax = from._internal_jumpspeedmax(); + ::uint64_t raw_jumpspeedmax; + memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax)); + if (raw_jumpspeedmax != 0) { + _this->_internal_set_jumpspeedmax(from._internal_jumpspeedmax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeed = from._internal_markspeed(); + ::uint64_t raw_markspeed; + memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed)); + if (raw_markspeed != 0) { + _this->_internal_set_markspeed(from._internal_markspeed()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmin = from._internal_markspeedmin(); + ::uint64_t raw_markspeedmin; + memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin)); + if (raw_markspeedmin != 0) { + _this->_internal_set_markspeedmin(from._internal_markspeedmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmax = from._internal_markspeedmax(); + ::uint64_t raw_markspeedmax; + memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax)); + if (raw_markspeedmax != 0) { + _this->_internal_set_markspeedmax(from._internal_markspeedmax()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ScanParamCfg::CopyFrom(const ScanParamCfg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScanParamCfg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ScanParamCfg::IsInitialized() const { + return true; +} + +void ScanParamCfg::InternalSwap(ScanParamCfg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_) + + sizeof(ScanParamCfg::_impl_.markspeedmax_) + - PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_)>( + reinterpret_cast(&_impl_.edgelevel_), + reinterpret_cast(&other->_impl_.edgelevel_)); +} + +::google::protobuf::Metadata ScanParamCfg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[15]); +} +// =================================================================== + +class CorrectParamCfg::_Internal { + public: +}; + +CorrectParamCfg::CorrectParamCfg(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.CorrectParamCfg) +} +CorrectParamCfg::CorrectParamCfg(const CorrectParamCfg& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.CorrectParamCfg) +} +inline void CorrectParamCfg::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.xmeasuremin_){0}, + decltype(_impl_.xmeasuremax_){0}, + decltype(_impl_.ymeasuremin_){0}, + decltype(_impl_.ymeasuremax_){0}, + decltype(_impl_.xposfix_){0}, + decltype(_impl_.yposfix_){0}, + decltype(_impl_.scanangle_){0}, + decltype(_impl_.scananglemin_){0}, + decltype(_impl_.scananglemax_){0}, + decltype(_impl_.fixangle_){0}, + decltype(_impl_.fixanglemin_){0}, + decltype(_impl_.fixanglemax_){0}, + decltype(_impl_.xcorrect_){0}, + decltype(_impl_.ycorrect_){0}, + decltype(_impl_.xcorrectmin_){0}, + decltype(_impl_.xcorrectmax_){0}, + decltype(_impl_.ycorrectmin_){0}, + decltype(_impl_.ycorrectmax_){0}, + decltype(_impl_.realxoffset_){0}, + decltype(_impl_.realyoffset_){0}, + decltype(_impl_.factork_){0}, + decltype(_impl_.defocusratio_){0}, + decltype(_impl_.defocusratiomin_){0}, + decltype(_impl_.defocusratiomax_){0}, + decltype(_impl_.iscorrectfile3d_){false}, + decltype(_impl_.isdynamicfocus_){false}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +CorrectParamCfg::~CorrectParamCfg() { + // @@protoc_insertion_point(destructor:stream.CorrectParamCfg) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void CorrectParamCfg::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void CorrectParamCfg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void CorrectParamCfg::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.CorrectParamCfg) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.xmeasuremin_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.isdynamicfocus_) - + reinterpret_cast(&_impl_.xmeasuremin_)) + sizeof(_impl_.isdynamicfocus_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* CorrectParamCfg::_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<5, 26, 0, 0, 2> CorrectParamCfg::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 26, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4227858432, // skipmap + offsetof(decltype(_table_), field_entries), + 26, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_CorrectParamCfg_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // double xmeasureMin = 1; + {::_pbi::TcParser::FastF64S1, + {9, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_)}}, + // double xmeasureMax = 2; + {::_pbi::TcParser::FastF64S1, + {17, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremax_)}}, + // double ymeasureMin = 3; + {::_pbi::TcParser::FastF64S1, + {25, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremin_)}}, + // double ymeasureMax = 4; + {::_pbi::TcParser::FastF64S1, + {33, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremax_)}}, + // double xposfix = 5; + {::_pbi::TcParser::FastF64S1, + {41, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xposfix_)}}, + // double yposfix = 6; + {::_pbi::TcParser::FastF64S1, + {49, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.yposfix_)}}, + // double scanAngle = 7; + {::_pbi::TcParser::FastF64S1, + {57, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scanangle_)}}, + // double scanAngleMin = 8; + {::_pbi::TcParser::FastF64S1, + {65, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemin_)}}, + // double scanAngleMax = 9; + {::_pbi::TcParser::FastF64S1, + {73, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemax_)}}, + // double fixAngle = 10; + {::_pbi::TcParser::FastF64S1, + {81, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixangle_)}}, + // double fixAngleMin = 11; + {::_pbi::TcParser::FastF64S1, + {89, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemin_)}}, + // double fixAngleMax = 12; + {::_pbi::TcParser::FastF64S1, + {97, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemax_)}}, + // double xcorrect = 13; + {::_pbi::TcParser::FastF64S1, + {105, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrect_)}}, + // double ycorrect = 14; + {::_pbi::TcParser::FastF64S1, + {113, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrect_)}}, + // double xcorrectMin = 15; + {::_pbi::TcParser::FastF64S1, + {121, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmin_)}}, + // double xcorrectMax = 16; + {::_pbi::TcParser::FastF64S2, + {385, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmax_)}}, + // double ycorrectMin = 17; + {::_pbi::TcParser::FastF64S2, + {393, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmin_)}}, + // double ycorrectMax = 18; + {::_pbi::TcParser::FastF64S2, + {401, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmax_)}}, + // double realXOffset = 19; + {::_pbi::TcParser::FastF64S2, + {409, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realxoffset_)}}, + // double realYOffset = 20; + {::_pbi::TcParser::FastF64S2, + {417, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realyoffset_)}}, + // double factorK = 21; + {::_pbi::TcParser::FastF64S2, + {425, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.factork_)}}, + // bool isCorrectFile3D = 22; + {::_pbi::TcParser::FastV8S2, + {432, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.iscorrectfile3d_)}}, + // bool isDynamicFocus = 23; + {::_pbi::TcParser::FastV8S2, + {440, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_)}}, + // double defocusRatio = 24; + {::_pbi::TcParser::FastF64S2, + {449, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratio_)}}, + // double defocusRatioMin = 25; + {::_pbi::TcParser::FastF64S2, + {457, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomin_)}}, + // double defocusRatioMax = 26; + {::_pbi::TcParser::FastF64S2, + {465, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomax_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // double xmeasureMin = 1; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xmeasureMax = 2; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ymeasureMin = 3; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ymeasureMax = 4; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xposfix = 5; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xposfix_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double yposfix = 6; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.yposfix_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double scanAngle = 7; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scanangle_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double scanAngleMin = 8; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double scanAngleMax = 9; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double fixAngle = 10; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixangle_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double fixAngleMin = 11; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double fixAngleMax = 12; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xcorrect = 13; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrect_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ycorrect = 14; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrect_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xcorrectMin = 15; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xcorrectMax = 16; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ycorrectMin = 17; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ycorrectMax = 18; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double realXOffset = 19; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realxoffset_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double realYOffset = 20; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realyoffset_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double factorK = 21; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.factork_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool isCorrectFile3D = 22; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.iscorrectfile3d_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool isDynamicFocus = 23; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // double defocusRatio = 24; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratio_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double defocusRatioMin = 25; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double defocusRatioMax = 26; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* CorrectParamCfg::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.CorrectParamCfg) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // double xmeasureMin = 1; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremin = this->_internal_xmeasuremin(); + ::uint64_t raw_xmeasuremin; + memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin)); + if (raw_xmeasuremin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 1, this->_internal_xmeasuremin(), target); + } + + // double xmeasureMax = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremax = this->_internal_xmeasuremax(); + ::uint64_t raw_xmeasuremax; + memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax)); + if (raw_xmeasuremax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 2, this->_internal_xmeasuremax(), target); + } + + // double ymeasureMin = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremin = this->_internal_ymeasuremin(); + ::uint64_t raw_ymeasuremin; + memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin)); + if (raw_ymeasuremin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 3, this->_internal_ymeasuremin(), target); + } + + // double ymeasureMax = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremax = this->_internal_ymeasuremax(); + ::uint64_t raw_ymeasuremax; + memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax)); + if (raw_ymeasuremax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 4, this->_internal_ymeasuremax(), target); + } + + // double xposfix = 5; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xposfix = this->_internal_xposfix(); + ::uint64_t raw_xposfix; + memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix)); + if (raw_xposfix != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 5, this->_internal_xposfix(), target); + } + + // double yposfix = 6; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_yposfix = this->_internal_yposfix(); + ::uint64_t raw_yposfix; + memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix)); + if (raw_yposfix != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 6, this->_internal_yposfix(), target); + } + + // double scanAngle = 7; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scanangle = this->_internal_scanangle(); + ::uint64_t raw_scanangle; + memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle)); + if (raw_scanangle != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 7, this->_internal_scanangle(), target); + } + + // double scanAngleMin = 8; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemin = this->_internal_scananglemin(); + ::uint64_t raw_scananglemin; + memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin)); + if (raw_scananglemin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 8, this->_internal_scananglemin(), target); + } + + // double scanAngleMax = 9; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemax = this->_internal_scananglemax(); + ::uint64_t raw_scananglemax; + memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax)); + if (raw_scananglemax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 9, this->_internal_scananglemax(), target); + } + + // double fixAngle = 10; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixangle = this->_internal_fixangle(); + ::uint64_t raw_fixangle; + memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle)); + if (raw_fixangle != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 10, this->_internal_fixangle(), target); + } + + // double fixAngleMin = 11; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemin = this->_internal_fixanglemin(); + ::uint64_t raw_fixanglemin; + memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin)); + if (raw_fixanglemin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 11, this->_internal_fixanglemin(), target); + } + + // double fixAngleMax = 12; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemax = this->_internal_fixanglemax(); + ::uint64_t raw_fixanglemax; + memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax)); + if (raw_fixanglemax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 12, this->_internal_fixanglemax(), target); + } + + // double xcorrect = 13; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrect = this->_internal_xcorrect(); + ::uint64_t raw_xcorrect; + memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect)); + if (raw_xcorrect != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 13, this->_internal_xcorrect(), target); + } + + // double ycorrect = 14; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrect = this->_internal_ycorrect(); + ::uint64_t raw_ycorrect; + memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect)); + if (raw_ycorrect != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 14, this->_internal_ycorrect(), target); + } + + // double xcorrectMin = 15; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmin = this->_internal_xcorrectmin(); + ::uint64_t raw_xcorrectmin; + memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin)); + if (raw_xcorrectmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 15, this->_internal_xcorrectmin(), target); + } + + // double xcorrectMax = 16; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmax = this->_internal_xcorrectmax(); + ::uint64_t raw_xcorrectmax; + memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax)); + if (raw_xcorrectmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 16, this->_internal_xcorrectmax(), target); + } + + // double ycorrectMin = 17; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmin = this->_internal_ycorrectmin(); + ::uint64_t raw_ycorrectmin; + memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin)); + if (raw_ycorrectmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 17, this->_internal_ycorrectmin(), target); + } + + // double ycorrectMax = 18; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmax = this->_internal_ycorrectmax(); + ::uint64_t raw_ycorrectmax; + memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax)); + if (raw_ycorrectmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 18, this->_internal_ycorrectmax(), target); + } + + // double realXOffset = 19; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realxoffset = this->_internal_realxoffset(); + ::uint64_t raw_realxoffset; + memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset)); + if (raw_realxoffset != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 19, this->_internal_realxoffset(), target); + } + + // double realYOffset = 20; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realyoffset = this->_internal_realyoffset(); + ::uint64_t raw_realyoffset; + memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset)); + if (raw_realyoffset != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 20, this->_internal_realyoffset(), target); + } + + // double factorK = 21; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_factork = this->_internal_factork(); + ::uint64_t raw_factork; + memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork)); + if (raw_factork != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 21, this->_internal_factork(), target); + } + + // bool isCorrectFile3D = 22; + if (this->_internal_iscorrectfile3d() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 22, this->_internal_iscorrectfile3d(), target); + } + + // bool isDynamicFocus = 23; + if (this->_internal_isdynamicfocus() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 23, this->_internal_isdynamicfocus(), target); + } + + // double defocusRatio = 24; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratio = this->_internal_defocusratio(); + ::uint64_t raw_defocusratio; + memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio)); + if (raw_defocusratio != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 24, this->_internal_defocusratio(), target); + } + + // double defocusRatioMin = 25; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomin = this->_internal_defocusratiomin(); + ::uint64_t raw_defocusratiomin; + memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin)); + if (raw_defocusratiomin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 25, this->_internal_defocusratiomin(), target); + } + + // double defocusRatioMax = 26; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomax = this->_internal_defocusratiomax(); + ::uint64_t raw_defocusratiomax; + memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax)); + if (raw_defocusratiomax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 26, this->_internal_defocusratiomax(), 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.CorrectParamCfg) + return target; +} + +::size_t CorrectParamCfg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.CorrectParamCfg) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // double xmeasureMin = 1; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremin = this->_internal_xmeasuremin(); + ::uint64_t raw_xmeasuremin; + memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin)); + if (raw_xmeasuremin != 0) { + total_size += 9; + } + + // double xmeasureMax = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremax = this->_internal_xmeasuremax(); + ::uint64_t raw_xmeasuremax; + memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax)); + if (raw_xmeasuremax != 0) { + total_size += 9; + } + + // double ymeasureMin = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremin = this->_internal_ymeasuremin(); + ::uint64_t raw_ymeasuremin; + memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin)); + if (raw_ymeasuremin != 0) { + total_size += 9; + } + + // double ymeasureMax = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremax = this->_internal_ymeasuremax(); + ::uint64_t raw_ymeasuremax; + memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax)); + if (raw_ymeasuremax != 0) { + total_size += 9; + } + + // double xposfix = 5; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xposfix = this->_internal_xposfix(); + ::uint64_t raw_xposfix; + memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix)); + if (raw_xposfix != 0) { + total_size += 9; + } + + // double yposfix = 6; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_yposfix = this->_internal_yposfix(); + ::uint64_t raw_yposfix; + memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix)); + if (raw_yposfix != 0) { + total_size += 9; + } + + // double scanAngle = 7; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scanangle = this->_internal_scanangle(); + ::uint64_t raw_scanangle; + memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle)); + if (raw_scanangle != 0) { + total_size += 9; + } + + // double scanAngleMin = 8; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemin = this->_internal_scananglemin(); + ::uint64_t raw_scananglemin; + memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin)); + if (raw_scananglemin != 0) { + total_size += 9; + } + + // double scanAngleMax = 9; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemax = this->_internal_scananglemax(); + ::uint64_t raw_scananglemax; + memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax)); + if (raw_scananglemax != 0) { + total_size += 9; + } + + // double fixAngle = 10; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixangle = this->_internal_fixangle(); + ::uint64_t raw_fixangle; + memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle)); + if (raw_fixangle != 0) { + total_size += 9; + } + + // double fixAngleMin = 11; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemin = this->_internal_fixanglemin(); + ::uint64_t raw_fixanglemin; + memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin)); + if (raw_fixanglemin != 0) { + total_size += 9; + } + + // double fixAngleMax = 12; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemax = this->_internal_fixanglemax(); + ::uint64_t raw_fixanglemax; + memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax)); + if (raw_fixanglemax != 0) { + total_size += 9; + } + + // double xcorrect = 13; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrect = this->_internal_xcorrect(); + ::uint64_t raw_xcorrect; + memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect)); + if (raw_xcorrect != 0) { + total_size += 9; + } + + // double ycorrect = 14; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrect = this->_internal_ycorrect(); + ::uint64_t raw_ycorrect; + memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect)); + if (raw_ycorrect != 0) { + total_size += 9; + } + + // double xcorrectMin = 15; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmin = this->_internal_xcorrectmin(); + ::uint64_t raw_xcorrectmin; + memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin)); + if (raw_xcorrectmin != 0) { + total_size += 9; + } + + // double xcorrectMax = 16; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmax = this->_internal_xcorrectmax(); + ::uint64_t raw_xcorrectmax; + memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax)); + if (raw_xcorrectmax != 0) { + total_size += 10; + } + + // double ycorrectMin = 17; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmin = this->_internal_ycorrectmin(); + ::uint64_t raw_ycorrectmin; + memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin)); + if (raw_ycorrectmin != 0) { + total_size += 10; + } + + // double ycorrectMax = 18; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmax = this->_internal_ycorrectmax(); + ::uint64_t raw_ycorrectmax; + memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax)); + if (raw_ycorrectmax != 0) { + total_size += 10; + } + + // double realXOffset = 19; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realxoffset = this->_internal_realxoffset(); + ::uint64_t raw_realxoffset; + memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset)); + if (raw_realxoffset != 0) { + total_size += 10; + } + + // double realYOffset = 20; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realyoffset = this->_internal_realyoffset(); + ::uint64_t raw_realyoffset; + memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset)); + if (raw_realyoffset != 0) { + total_size += 10; + } + + // double factorK = 21; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_factork = this->_internal_factork(); + ::uint64_t raw_factork; + memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork)); + if (raw_factork != 0) { + total_size += 10; + } + + // double defocusRatio = 24; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratio = this->_internal_defocusratio(); + ::uint64_t raw_defocusratio; + memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio)); + if (raw_defocusratio != 0) { + total_size += 10; + } + + // double defocusRatioMin = 25; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomin = this->_internal_defocusratiomin(); + ::uint64_t raw_defocusratiomin; + memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin)); + if (raw_defocusratiomin != 0) { + total_size += 10; + } + + // double defocusRatioMax = 26; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomax = this->_internal_defocusratiomax(); + ::uint64_t raw_defocusratiomax; + memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax)); + if (raw_defocusratiomax != 0) { + total_size += 10; + } + + // bool isCorrectFile3D = 22; + if (this->_internal_iscorrectfile3d() != 0) { + total_size += 3; + } + + // bool isDynamicFocus = 23; + if (this->_internal_isdynamicfocus() != 0) { + total_size += 3; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData CorrectParamCfg::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + CorrectParamCfg::MergeImpl +}; +const ::google::protobuf::Message::ClassData*CorrectParamCfg::GetClassData() const { return &_class_data_; } + + +void CorrectParamCfg::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.CorrectParamCfg) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremin = from._internal_xmeasuremin(); + ::uint64_t raw_xmeasuremin; + memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin)); + if (raw_xmeasuremin != 0) { + _this->_internal_set_xmeasuremin(from._internal_xmeasuremin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremax = from._internal_xmeasuremax(); + ::uint64_t raw_xmeasuremax; + memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax)); + if (raw_xmeasuremax != 0) { + _this->_internal_set_xmeasuremax(from._internal_xmeasuremax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremin = from._internal_ymeasuremin(); + ::uint64_t raw_ymeasuremin; + memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin)); + if (raw_ymeasuremin != 0) { + _this->_internal_set_ymeasuremin(from._internal_ymeasuremin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremax = from._internal_ymeasuremax(); + ::uint64_t raw_ymeasuremax; + memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax)); + if (raw_ymeasuremax != 0) { + _this->_internal_set_ymeasuremax(from._internal_ymeasuremax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xposfix = from._internal_xposfix(); + ::uint64_t raw_xposfix; + memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix)); + if (raw_xposfix != 0) { + _this->_internal_set_xposfix(from._internal_xposfix()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_yposfix = from._internal_yposfix(); + ::uint64_t raw_yposfix; + memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix)); + if (raw_yposfix != 0) { + _this->_internal_set_yposfix(from._internal_yposfix()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scanangle = from._internal_scanangle(); + ::uint64_t raw_scanangle; + memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle)); + if (raw_scanangle != 0) { + _this->_internal_set_scanangle(from._internal_scanangle()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemin = from._internal_scananglemin(); + ::uint64_t raw_scananglemin; + memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin)); + if (raw_scananglemin != 0) { + _this->_internal_set_scananglemin(from._internal_scananglemin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemax = from._internal_scananglemax(); + ::uint64_t raw_scananglemax; + memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax)); + if (raw_scananglemax != 0) { + _this->_internal_set_scananglemax(from._internal_scananglemax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixangle = from._internal_fixangle(); + ::uint64_t raw_fixangle; + memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle)); + if (raw_fixangle != 0) { + _this->_internal_set_fixangle(from._internal_fixangle()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemin = from._internal_fixanglemin(); + ::uint64_t raw_fixanglemin; + memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin)); + if (raw_fixanglemin != 0) { + _this->_internal_set_fixanglemin(from._internal_fixanglemin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemax = from._internal_fixanglemax(); + ::uint64_t raw_fixanglemax; + memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax)); + if (raw_fixanglemax != 0) { + _this->_internal_set_fixanglemax(from._internal_fixanglemax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrect = from._internal_xcorrect(); + ::uint64_t raw_xcorrect; + memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect)); + if (raw_xcorrect != 0) { + _this->_internal_set_xcorrect(from._internal_xcorrect()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrect = from._internal_ycorrect(); + ::uint64_t raw_ycorrect; + memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect)); + if (raw_ycorrect != 0) { + _this->_internal_set_ycorrect(from._internal_ycorrect()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmin = from._internal_xcorrectmin(); + ::uint64_t raw_xcorrectmin; + memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin)); + if (raw_xcorrectmin != 0) { + _this->_internal_set_xcorrectmin(from._internal_xcorrectmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmax = from._internal_xcorrectmax(); + ::uint64_t raw_xcorrectmax; + memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax)); + if (raw_xcorrectmax != 0) { + _this->_internal_set_xcorrectmax(from._internal_xcorrectmax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmin = from._internal_ycorrectmin(); + ::uint64_t raw_ycorrectmin; + memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin)); + if (raw_ycorrectmin != 0) { + _this->_internal_set_ycorrectmin(from._internal_ycorrectmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmax = from._internal_ycorrectmax(); + ::uint64_t raw_ycorrectmax; + memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax)); + if (raw_ycorrectmax != 0) { + _this->_internal_set_ycorrectmax(from._internal_ycorrectmax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realxoffset = from._internal_realxoffset(); + ::uint64_t raw_realxoffset; + memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset)); + if (raw_realxoffset != 0) { + _this->_internal_set_realxoffset(from._internal_realxoffset()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realyoffset = from._internal_realyoffset(); + ::uint64_t raw_realyoffset; + memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset)); + if (raw_realyoffset != 0) { + _this->_internal_set_realyoffset(from._internal_realyoffset()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_factork = from._internal_factork(); + ::uint64_t raw_factork; + memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork)); + if (raw_factork != 0) { + _this->_internal_set_factork(from._internal_factork()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratio = from._internal_defocusratio(); + ::uint64_t raw_defocusratio; + memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio)); + if (raw_defocusratio != 0) { + _this->_internal_set_defocusratio(from._internal_defocusratio()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomin = from._internal_defocusratiomin(); + ::uint64_t raw_defocusratiomin; + memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin)); + if (raw_defocusratiomin != 0) { + _this->_internal_set_defocusratiomin(from._internal_defocusratiomin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomax = from._internal_defocusratiomax(); + ::uint64_t raw_defocusratiomax; + memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax)); + if (raw_defocusratiomax != 0) { + _this->_internal_set_defocusratiomax(from._internal_defocusratiomax()); + } + if (from._internal_iscorrectfile3d() != 0) { + _this->_internal_set_iscorrectfile3d(from._internal_iscorrectfile3d()); + } + if (from._internal_isdynamicfocus() != 0) { + _this->_internal_set_isdynamicfocus(from._internal_isdynamicfocus()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void CorrectParamCfg::CopyFrom(const CorrectParamCfg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.CorrectParamCfg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool CorrectParamCfg::IsInitialized() const { + return true; +} + +void CorrectParamCfg::InternalSwap(CorrectParamCfg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_) + + sizeof(CorrectParamCfg::_impl_.isdynamicfocus_) + - PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_)>( + reinterpret_cast(&_impl_.xmeasuremin_), + reinterpret_cast(&other->_impl_.xmeasuremin_)); +} + +::google::protobuf::Metadata CorrectParamCfg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[16]); +} +// =================================================================== + +class ScanTestCfg::_Internal { + public: +}; + +ScanTestCfg::ScanTestCfg(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ScanTestCfg) +} +ScanTestCfg::ScanTestCfg(const ScanTestCfg& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.ScanTestCfg) +} +inline void ScanTestCfg::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.debugshape_){0}, + decltype(_impl_.shapesize_){0}, + decltype(_impl_.shapesizemin_){0}, + decltype(_impl_.shape_size_max_){0}, + decltype(_impl_.laser_power_){0}, + decltype(_impl_.laser_power_min_){0}, + decltype(_impl_.defocus_){0}, + decltype(_impl_.defocus_min_){0}, + decltype(_impl_.defocus_max_){0}, + decltype(_impl_.laser_power_max_){0}, + decltype(_impl_.is_cycle_){false}, + decltype(_impl_.isautoheatingscanner_){false}, + decltype(_impl_.cross_x_){0}, + decltype(_impl_.cross_y_){0}, + decltype(_impl_.z_distance_){0}, + decltype(_impl_.autoheatingscannerminutes_){0u}, + decltype(_impl_.autoheatingscannersize_){0u}, + decltype(_impl_.autoheatingscannerspeed_){0}, + decltype(_impl_.mark_test_start_x_){0}, + decltype(_impl_.mark_test_start_y_){0}, + decltype(_impl_.mark_test_end_x_){0}, + decltype(_impl_.mark_test_end_y_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +ScanTestCfg::~ScanTestCfg() { + // @@protoc_insertion_point(destructor:stream.ScanTestCfg) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ScanTestCfg::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void ScanTestCfg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ScanTestCfg::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ScanTestCfg) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.debugshape_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.mark_test_end_y_) - + reinterpret_cast(&_impl_.debugshape_)) + sizeof(_impl_.mark_test_end_y_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ScanTestCfg::_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<5, 22, 0, 0, 2> ScanTestCfg::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 22, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4290772992, // skipmap + offsetof(decltype(_table_), field_entries), + 22, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_ScanTestCfg_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 debugShape = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.debugshape_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_)}}, + // int32 shapeSize = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shapesize_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesize_)}}, + // int32 shapeSizeMin = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shapesizemin_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesizemin_)}}, + // int32 shape_size_max = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shape_size_max_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shape_size_max_)}}, + // int32 laser_power = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_)}}, + // int32 laser_power_min = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_min_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_min_)}}, + // int32 laser_power_max = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_max_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_max_)}}, + // double defocus = 8; + {::_pbi::TcParser::FastF64S1, + {65, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_)}}, + // double defocus_min = 9; + {::_pbi::TcParser::FastF64S1, + {73, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_min_)}}, + // double defocus_max = 10; + {::_pbi::TcParser::FastF64S1, + {81, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_max_)}}, + // bool is_cycle = 11; + {::_pbi::TcParser::SingularVarintNoZag1(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.is_cycle_)}}, + // double cross_x = 12; + {::_pbi::TcParser::FastF64S1, + {97, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_x_)}}, + // double cross_y = 13; + {::_pbi::TcParser::FastF64S1, + {105, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_y_)}}, + // double z_distance = 14; + {::_pbi::TcParser::FastF64S1, + {113, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.z_distance_)}}, + // bool isAutoHeatingScanner = 15; + {::_pbi::TcParser::SingularVarintNoZag1(), + {120, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.isautoheatingscanner_)}}, + // uint32 autoHeatingScannerMinutes = 16; + {::_pbi::TcParser::FastV32S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerminutes_)}}, + // uint32 autoHeatingScannerSize = 17; + {::_pbi::TcParser::FastV32S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannersize_)}}, + // double autoHeatingScannerSpeed = 18; + {::_pbi::TcParser::FastF64S2, + {401, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerspeed_)}}, + // double mark_test_start_x = 19; + {::_pbi::TcParser::FastF64S2, + {409, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_x_)}}, + // double mark_test_start_y = 20; + {::_pbi::TcParser::FastF64S2, + {417, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_y_)}}, + // double mark_test_end_x = 21; + {::_pbi::TcParser::FastF64S2, + {425, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_x_)}}, + // double mark_test_end_y = 22; + {::_pbi::TcParser::FastF64S2, + {433, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 debugShape = 1; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 shapeSize = 2; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesize_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 shapeSizeMin = 3; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesizemin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 shape_size_max = 4; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shape_size_max_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 laser_power = 5; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 laser_power_min = 6; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_min_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 laser_power_max = 7; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_max_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // double defocus = 8; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double defocus_min = 9; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_min_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double defocus_max = 10; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_max_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool is_cycle = 11; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.is_cycle_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // double cross_x = 12; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double cross_y = 13; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double z_distance = 14; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.z_distance_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool isAutoHeatingScanner = 15; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.isautoheatingscanner_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // uint32 autoHeatingScannerMinutes = 16; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerminutes_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 autoHeatingScannerSize = 17; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannersize_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // double autoHeatingScannerSpeed = 18; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerspeed_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double mark_test_start_x = 19; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double mark_test_start_y = 20; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double mark_test_end_x = 21; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double mark_test_end_y = 22; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* ScanTestCfg::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ScanTestCfg) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 debugShape = 1; + if (this->_internal_debugshape() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_debugshape(), target); + } + + // int32 shapeSize = 2; + if (this->_internal_shapesize() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_shapesize(), target); + } + + // int32 shapeSizeMin = 3; + if (this->_internal_shapesizemin() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this->_internal_shapesizemin(), target); + } + + // int32 shape_size_max = 4; + if (this->_internal_shape_size_max() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this->_internal_shape_size_max(), target); + } + + // int32 laser_power = 5; + if (this->_internal_laser_power() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<5>( + stream, this->_internal_laser_power(), target); + } + + // int32 laser_power_min = 6; + if (this->_internal_laser_power_min() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<6>( + stream, this->_internal_laser_power_min(), target); + } + + // int32 laser_power_max = 7; + if (this->_internal_laser_power_max() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<7>( + stream, this->_internal_laser_power_max(), target); + } + + // double defocus = 8; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus = this->_internal_defocus(); + ::uint64_t raw_defocus; + memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus)); + if (raw_defocus != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 8, this->_internal_defocus(), target); + } + + // double defocus_min = 9; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_min = this->_internal_defocus_min(); + ::uint64_t raw_defocus_min; + memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min)); + if (raw_defocus_min != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 9, this->_internal_defocus_min(), target); + } + + // double defocus_max = 10; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_max = this->_internal_defocus_max(); + ::uint64_t raw_defocus_max; + memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max)); + if (raw_defocus_max != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 10, this->_internal_defocus_max(), target); + } + + // bool is_cycle = 11; + if (this->_internal_is_cycle() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 11, this->_internal_is_cycle(), target); + } + + // double cross_x = 12; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_x = this->_internal_cross_x(); + ::uint64_t raw_cross_x; + memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x)); + if (raw_cross_x != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 12, this->_internal_cross_x(), target); + } + + // double cross_y = 13; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_y = this->_internal_cross_y(); + ::uint64_t raw_cross_y; + memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y)); + if (raw_cross_y != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 13, this->_internal_cross_y(), target); + } + + // double z_distance = 14; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z_distance = this->_internal_z_distance(); + ::uint64_t raw_z_distance; + memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance)); + if (raw_z_distance != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 14, this->_internal_z_distance(), target); + } + + // bool isAutoHeatingScanner = 15; + if (this->_internal_isautoheatingscanner() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 15, this->_internal_isautoheatingscanner(), target); + } + + // uint32 autoHeatingScannerMinutes = 16; + if (this->_internal_autoheatingscannerminutes() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 16, this->_internal_autoheatingscannerminutes(), target); + } + + // uint32 autoHeatingScannerSize = 17; + if (this->_internal_autoheatingscannersize() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 17, this->_internal_autoheatingscannersize(), target); + } + + // double autoHeatingScannerSpeed = 18; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_autoheatingscannerspeed = this->_internal_autoheatingscannerspeed(); + ::uint64_t raw_autoheatingscannerspeed; + memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed)); + if (raw_autoheatingscannerspeed != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 18, this->_internal_autoheatingscannerspeed(), target); + } + + // double mark_test_start_x = 19; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_x = this->_internal_mark_test_start_x(); + ::uint64_t raw_mark_test_start_x; + memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x)); + if (raw_mark_test_start_x != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 19, this->_internal_mark_test_start_x(), target); + } + + // double mark_test_start_y = 20; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_y = this->_internal_mark_test_start_y(); + ::uint64_t raw_mark_test_start_y; + memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y)); + if (raw_mark_test_start_y != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 20, this->_internal_mark_test_start_y(), target); + } + + // double mark_test_end_x = 21; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_x = this->_internal_mark_test_end_x(); + ::uint64_t raw_mark_test_end_x; + memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x)); + if (raw_mark_test_end_x != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 21, this->_internal_mark_test_end_x(), target); + } + + // double mark_test_end_y = 22; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_y = this->_internal_mark_test_end_y(); + ::uint64_t raw_mark_test_end_y; + memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y)); + if (raw_mark_test_end_y != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 22, this->_internal_mark_test_end_y(), 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.ScanTestCfg) + return target; +} + +::size_t ScanTestCfg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ScanTestCfg) + ::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 debugShape = 1; + if (this->_internal_debugshape() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_debugshape()); + } + + // int32 shapeSize = 2; + if (this->_internal_shapesize() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_shapesize()); + } + + // int32 shapeSizeMin = 3; + if (this->_internal_shapesizemin() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_shapesizemin()); + } + + // int32 shape_size_max = 4; + if (this->_internal_shape_size_max() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_shape_size_max()); + } + + // int32 laser_power = 5; + if (this->_internal_laser_power() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_laser_power()); + } + + // int32 laser_power_min = 6; + if (this->_internal_laser_power_min() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_laser_power_min()); + } + + // double defocus = 8; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus = this->_internal_defocus(); + ::uint64_t raw_defocus; + memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus)); + if (raw_defocus != 0) { + total_size += 9; + } + + // double defocus_min = 9; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_min = this->_internal_defocus_min(); + ::uint64_t raw_defocus_min; + memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min)); + if (raw_defocus_min != 0) { + total_size += 9; + } + + // double defocus_max = 10; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_max = this->_internal_defocus_max(); + ::uint64_t raw_defocus_max; + memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max)); + if (raw_defocus_max != 0) { + total_size += 9; + } + + // int32 laser_power_max = 7; + if (this->_internal_laser_power_max() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_laser_power_max()); + } + + // bool is_cycle = 11; + if (this->_internal_is_cycle() != 0) { + total_size += 2; + } + + // bool isAutoHeatingScanner = 15; + if (this->_internal_isautoheatingscanner() != 0) { + total_size += 2; + } + + // double cross_x = 12; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_x = this->_internal_cross_x(); + ::uint64_t raw_cross_x; + memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x)); + if (raw_cross_x != 0) { + total_size += 9; + } + + // double cross_y = 13; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_y = this->_internal_cross_y(); + ::uint64_t raw_cross_y; + memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y)); + if (raw_cross_y != 0) { + total_size += 9; + } + + // double z_distance = 14; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z_distance = this->_internal_z_distance(); + ::uint64_t raw_z_distance; + memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance)); + if (raw_z_distance != 0) { + total_size += 9; + } + + // uint32 autoHeatingScannerMinutes = 16; + if (this->_internal_autoheatingscannerminutes() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_autoheatingscannerminutes()); + } + + // uint32 autoHeatingScannerSize = 17; + if (this->_internal_autoheatingscannersize() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_autoheatingscannersize()); + } + + // double autoHeatingScannerSpeed = 18; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_autoheatingscannerspeed = this->_internal_autoheatingscannerspeed(); + ::uint64_t raw_autoheatingscannerspeed; + memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed)); + if (raw_autoheatingscannerspeed != 0) { + total_size += 10; + } + + // double mark_test_start_x = 19; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_x = this->_internal_mark_test_start_x(); + ::uint64_t raw_mark_test_start_x; + memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x)); + if (raw_mark_test_start_x != 0) { + total_size += 10; + } + + // double mark_test_start_y = 20; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_y = this->_internal_mark_test_start_y(); + ::uint64_t raw_mark_test_start_y; + memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y)); + if (raw_mark_test_start_y != 0) { + total_size += 10; + } + + // double mark_test_end_x = 21; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_x = this->_internal_mark_test_end_x(); + ::uint64_t raw_mark_test_end_x; + memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x)); + if (raw_mark_test_end_x != 0) { + total_size += 10; + } + + // double mark_test_end_y = 22; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_y = this->_internal_mark_test_end_y(); + ::uint64_t raw_mark_test_end_y; + memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y)); + if (raw_mark_test_end_y != 0) { + total_size += 10; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ScanTestCfg::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ScanTestCfg::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ScanTestCfg::GetClassData() const { return &_class_data_; } + + +void ScanTestCfg::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.ScanTestCfg) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_debugshape() != 0) { + _this->_internal_set_debugshape(from._internal_debugshape()); + } + if (from._internal_shapesize() != 0) { + _this->_internal_set_shapesize(from._internal_shapesize()); + } + if (from._internal_shapesizemin() != 0) { + _this->_internal_set_shapesizemin(from._internal_shapesizemin()); + } + if (from._internal_shape_size_max() != 0) { + _this->_internal_set_shape_size_max(from._internal_shape_size_max()); + } + if (from._internal_laser_power() != 0) { + _this->_internal_set_laser_power(from._internal_laser_power()); + } + if (from._internal_laser_power_min() != 0) { + _this->_internal_set_laser_power_min(from._internal_laser_power_min()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus = from._internal_defocus(); + ::uint64_t raw_defocus; + memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus)); + if (raw_defocus != 0) { + _this->_internal_set_defocus(from._internal_defocus()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_min = from._internal_defocus_min(); + ::uint64_t raw_defocus_min; + memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min)); + if (raw_defocus_min != 0) { + _this->_internal_set_defocus_min(from._internal_defocus_min()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_max = from._internal_defocus_max(); + ::uint64_t raw_defocus_max; + memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max)); + if (raw_defocus_max != 0) { + _this->_internal_set_defocus_max(from._internal_defocus_max()); + } + if (from._internal_laser_power_max() != 0) { + _this->_internal_set_laser_power_max(from._internal_laser_power_max()); + } + if (from._internal_is_cycle() != 0) { + _this->_internal_set_is_cycle(from._internal_is_cycle()); + } + if (from._internal_isautoheatingscanner() != 0) { + _this->_internal_set_isautoheatingscanner(from._internal_isautoheatingscanner()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_x = from._internal_cross_x(); + ::uint64_t raw_cross_x; + memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x)); + if (raw_cross_x != 0) { + _this->_internal_set_cross_x(from._internal_cross_x()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_y = from._internal_cross_y(); + ::uint64_t raw_cross_y; + memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y)); + if (raw_cross_y != 0) { + _this->_internal_set_cross_y(from._internal_cross_y()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z_distance = from._internal_z_distance(); + ::uint64_t raw_z_distance; + memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance)); + if (raw_z_distance != 0) { + _this->_internal_set_z_distance(from._internal_z_distance()); + } + if (from._internal_autoheatingscannerminutes() != 0) { + _this->_internal_set_autoheatingscannerminutes(from._internal_autoheatingscannerminutes()); + } + if (from._internal_autoheatingscannersize() != 0) { + _this->_internal_set_autoheatingscannersize(from._internal_autoheatingscannersize()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_autoheatingscannerspeed = from._internal_autoheatingscannerspeed(); + ::uint64_t raw_autoheatingscannerspeed; + memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed)); + if (raw_autoheatingscannerspeed != 0) { + _this->_internal_set_autoheatingscannerspeed(from._internal_autoheatingscannerspeed()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_x = from._internal_mark_test_start_x(); + ::uint64_t raw_mark_test_start_x; + memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x)); + if (raw_mark_test_start_x != 0) { + _this->_internal_set_mark_test_start_x(from._internal_mark_test_start_x()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_y = from._internal_mark_test_start_y(); + ::uint64_t raw_mark_test_start_y; + memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y)); + if (raw_mark_test_start_y != 0) { + _this->_internal_set_mark_test_start_y(from._internal_mark_test_start_y()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_x = from._internal_mark_test_end_x(); + ::uint64_t raw_mark_test_end_x; + memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x)); + if (raw_mark_test_end_x != 0) { + _this->_internal_set_mark_test_end_x(from._internal_mark_test_end_x()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_y = from._internal_mark_test_end_y(); + ::uint64_t raw_mark_test_end_y; + memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y)); + if (raw_mark_test_end_y != 0) { + _this->_internal_set_mark_test_end_y(from._internal_mark_test_end_y()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ScanTestCfg::CopyFrom(const ScanTestCfg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScanTestCfg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ScanTestCfg::IsInitialized() const { + return true; +} + +void ScanTestCfg::InternalSwap(ScanTestCfg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_) + + sizeof(ScanTestCfg::_impl_.mark_test_end_y_) + - PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_)>( + reinterpret_cast(&_impl_.debugshape_), + reinterpret_cast(&other->_impl_.debugshape_)); +} + +::google::protobuf::Metadata ScanTestCfg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[17]); +} +// =================================================================== + +class SkyWritingCfg::_Internal { + public: +}; + +SkyWritingCfg::SkyWritingCfg(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.SkyWritingCfg) +} +SkyWritingCfg::SkyWritingCfg(const SkyWritingCfg& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.SkyWritingCfg) +} +inline void SkyWritingCfg::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.timelag_){0}, + decltype(_impl_.timelagmin_){0}, + decltype(_impl_.timelagmax_){0}, + decltype(_impl_.isenable_){false}, + decltype(_impl_.nprev_){0u}, + decltype(_impl_.laseronshift_){::int64_t{0}}, + decltype(_impl_.laseronshiftmin_){::int64_t{0}}, + decltype(_impl_.laseronshiftmax_){::int64_t{0}}, + decltype(_impl_.nprevmin_){0u}, + decltype(_impl_.nprevmax_){0u}, + decltype(_impl_.npost_){0u}, + decltype(_impl_.npostmin_){0u}, + decltype(_impl_.npostmax_){0u}, + decltype(_impl_.mode_){0}, + decltype(_impl_.limite_){0}, + decltype(_impl_.limitemin_){0}, + decltype(_impl_.limitemax_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +SkyWritingCfg::~SkyWritingCfg() { + // @@protoc_insertion_point(destructor:stream.SkyWritingCfg) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void SkyWritingCfg::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void SkyWritingCfg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void SkyWritingCfg::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.SkyWritingCfg) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.timelag_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.limitemax_) - + reinterpret_cast(&_impl_.timelag_)) + sizeof(_impl_.limitemax_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* SkyWritingCfg::_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<5, 17, 0, 0, 2> SkyWritingCfg::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 17, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294836224, // skipmap + offsetof(decltype(_table_), field_entries), + 17, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_SkyWritingCfg_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bool isEnable = 1; + {::_pbi::TcParser::SingularVarintNoZag1(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.isenable_)}}, + // double timelag = 2; + {::_pbi::TcParser::FastF64S1, + {17, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_)}}, + // double timelagMin = 3; + {::_pbi::TcParser::FastF64S1, + {25, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmin_)}}, + // double timelagMax = 4; + {::_pbi::TcParser::FastF64S1, + {33, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmax_)}}, + // int64 laserOnShift = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshift_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshift_)}}, + // int64 laserOnShiftMin = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshiftmin_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmin_)}}, + // int64 laserOnShiftMax = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshiftmax_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmax_)}}, + // uint32 nprev = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprev_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprev_)}}, + // uint32 nprevMin = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprevmin_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmin_)}}, + // uint32 nprevMax = 10; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprevmax_), 63>(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmax_)}}, + // uint32 npost = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npost_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npost_)}}, + // uint32 npostMin = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npostmin_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmin_)}}, + // uint32 npostMax = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npostmax_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmax_)}}, + // int32 mode = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.mode_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.mode_)}}, + // double limite = 15; + {::_pbi::TcParser::FastF64S1, + {121, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limite_)}}, + // double limiteMin = 16; + {::_pbi::TcParser::FastF64S2, + {385, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemin_)}}, + // double limiteMax = 17; + {::_pbi::TcParser::FastF64S2, + {393, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool isEnable = 1; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.isenable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // double timelag = 2; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double timelagMin = 3; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double timelagMax = 4; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // int64 laserOnShift = 5; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshift_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laserOnShiftMin = 6; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laserOnShiftMax = 7; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // uint32 nprev = 8; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprev_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 nprevMin = 9; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 nprevMax = 10; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 npost = 11; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npost_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 npostMin = 12; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 npostMax = 13; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // int32 mode = 14; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.mode_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // double limite = 15; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limite_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double limiteMin = 16; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double limiteMax = 17; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* SkyWritingCfg::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.SkyWritingCfg) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // bool isEnable = 1; + if (this->_internal_isenable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 1, this->_internal_isenable(), target); + } + + // double timelag = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelag = this->_internal_timelag(); + ::uint64_t raw_timelag; + memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag)); + if (raw_timelag != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 2, this->_internal_timelag(), target); + } + + // double timelagMin = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmin = this->_internal_timelagmin(); + ::uint64_t raw_timelagmin; + memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin)); + if (raw_timelagmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 3, this->_internal_timelagmin(), target); + } + + // double timelagMax = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmax = this->_internal_timelagmax(); + ::uint64_t raw_timelagmax; + memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax)); + if (raw_timelagmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 4, this->_internal_timelagmax(), target); + } + + // int64 laserOnShift = 5; + if (this->_internal_laseronshift() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<5>( + stream, this->_internal_laseronshift(), target); + } + + // int64 laserOnShiftMin = 6; + if (this->_internal_laseronshiftmin() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<6>( + stream, this->_internal_laseronshiftmin(), target); + } + + // int64 laserOnShiftMax = 7; + if (this->_internal_laseronshiftmax() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<7>( + stream, this->_internal_laseronshiftmax(), target); + } + + // uint32 nprev = 8; + if (this->_internal_nprev() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 8, this->_internal_nprev(), target); + } + + // uint32 nprevMin = 9; + if (this->_internal_nprevmin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this->_internal_nprevmin(), target); + } + + // uint32 nprevMax = 10; + if (this->_internal_nprevmax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 10, this->_internal_nprevmax(), target); + } + + // uint32 npost = 11; + if (this->_internal_npost() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 11, this->_internal_npost(), target); + } + + // uint32 npostMin = 12; + if (this->_internal_npostmin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 12, this->_internal_npostmin(), target); + } + + // uint32 npostMax = 13; + if (this->_internal_npostmax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 13, this->_internal_npostmax(), target); + } + + // int32 mode = 14; + if (this->_internal_mode() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this->_internal_mode(), target); + } + + // double limite = 15; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limite = this->_internal_limite(); + ::uint64_t raw_limite; + memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite)); + if (raw_limite != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 15, this->_internal_limite(), target); + } + + // double limiteMin = 16; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemin = this->_internal_limitemin(); + ::uint64_t raw_limitemin; + memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin)); + if (raw_limitemin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 16, this->_internal_limitemin(), target); + } + + // double limiteMax = 17; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemax = this->_internal_limitemax(); + ::uint64_t raw_limitemax; + memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax)); + if (raw_limitemax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 17, this->_internal_limitemax(), 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.SkyWritingCfg) + return target; +} + +::size_t SkyWritingCfg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.SkyWritingCfg) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // double timelag = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelag = this->_internal_timelag(); + ::uint64_t raw_timelag; + memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag)); + if (raw_timelag != 0) { + total_size += 9; + } + + // double timelagMin = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmin = this->_internal_timelagmin(); + ::uint64_t raw_timelagmin; + memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin)); + if (raw_timelagmin != 0) { + total_size += 9; + } + + // double timelagMax = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmax = this->_internal_timelagmax(); + ::uint64_t raw_timelagmax; + memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax)); + if (raw_timelagmax != 0) { + total_size += 9; + } + + // bool isEnable = 1; + if (this->_internal_isenable() != 0) { + total_size += 2; + } + + // uint32 nprev = 8; + if (this->_internal_nprev() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_nprev()); + } + + // int64 laserOnShift = 5; + if (this->_internal_laseronshift() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseronshift()); + } + + // int64 laserOnShiftMin = 6; + if (this->_internal_laseronshiftmin() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseronshiftmin()); + } + + // int64 laserOnShiftMax = 7; + if (this->_internal_laseronshiftmax() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseronshiftmax()); + } + + // uint32 nprevMin = 9; + if (this->_internal_nprevmin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_nprevmin()); + } + + // uint32 nprevMax = 10; + if (this->_internal_nprevmax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_nprevmax()); + } + + // uint32 npost = 11; + if (this->_internal_npost() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_npost()); + } + + // uint32 npostMin = 12; + if (this->_internal_npostmin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_npostmin()); + } + + // uint32 npostMax = 13; + if (this->_internal_npostmax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_npostmax()); + } + + // int32 mode = 14; + if (this->_internal_mode() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_mode()); + } + + // double limite = 15; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limite = this->_internal_limite(); + ::uint64_t raw_limite; + memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite)); + if (raw_limite != 0) { + total_size += 9; + } + + // double limiteMin = 16; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemin = this->_internal_limitemin(); + ::uint64_t raw_limitemin; + memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin)); + if (raw_limitemin != 0) { + total_size += 10; + } + + // double limiteMax = 17; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemax = this->_internal_limitemax(); + ::uint64_t raw_limitemax; + memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax)); + if (raw_limitemax != 0) { + total_size += 10; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData SkyWritingCfg::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + SkyWritingCfg::MergeImpl +}; +const ::google::protobuf::Message::ClassData*SkyWritingCfg::GetClassData() const { return &_class_data_; } + + +void SkyWritingCfg::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.SkyWritingCfg) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelag = from._internal_timelag(); + ::uint64_t raw_timelag; + memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag)); + if (raw_timelag != 0) { + _this->_internal_set_timelag(from._internal_timelag()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmin = from._internal_timelagmin(); + ::uint64_t raw_timelagmin; + memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin)); + if (raw_timelagmin != 0) { + _this->_internal_set_timelagmin(from._internal_timelagmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmax = from._internal_timelagmax(); + ::uint64_t raw_timelagmax; + memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax)); + if (raw_timelagmax != 0) { + _this->_internal_set_timelagmax(from._internal_timelagmax()); + } + if (from._internal_isenable() != 0) { + _this->_internal_set_isenable(from._internal_isenable()); + } + if (from._internal_nprev() != 0) { + _this->_internal_set_nprev(from._internal_nprev()); + } + if (from._internal_laseronshift() != 0) { + _this->_internal_set_laseronshift(from._internal_laseronshift()); + } + if (from._internal_laseronshiftmin() != 0) { + _this->_internal_set_laseronshiftmin(from._internal_laseronshiftmin()); + } + if (from._internal_laseronshiftmax() != 0) { + _this->_internal_set_laseronshiftmax(from._internal_laseronshiftmax()); + } + if (from._internal_nprevmin() != 0) { + _this->_internal_set_nprevmin(from._internal_nprevmin()); + } + if (from._internal_nprevmax() != 0) { + _this->_internal_set_nprevmax(from._internal_nprevmax()); + } + if (from._internal_npost() != 0) { + _this->_internal_set_npost(from._internal_npost()); + } + if (from._internal_npostmin() != 0) { + _this->_internal_set_npostmin(from._internal_npostmin()); + } + if (from._internal_npostmax() != 0) { + _this->_internal_set_npostmax(from._internal_npostmax()); + } + if (from._internal_mode() != 0) { + _this->_internal_set_mode(from._internal_mode()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limite = from._internal_limite(); + ::uint64_t raw_limite; + memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite)); + if (raw_limite != 0) { + _this->_internal_set_limite(from._internal_limite()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemin = from._internal_limitemin(); + ::uint64_t raw_limitemin; + memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin)); + if (raw_limitemin != 0) { + _this->_internal_set_limitemin(from._internal_limitemin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemax = from._internal_limitemax(); + ::uint64_t raw_limitemax; + memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax)); + if (raw_limitemax != 0) { + _this->_internal_set_limitemax(from._internal_limitemax()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SkyWritingCfg::CopyFrom(const SkyWritingCfg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.SkyWritingCfg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool SkyWritingCfg::IsInitialized() const { + return true; +} + +void SkyWritingCfg::InternalSwap(SkyWritingCfg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_) + + sizeof(SkyWritingCfg::_impl_.limitemax_) + - PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_)>( + reinterpret_cast(&_impl_.timelag_), + reinterpret_cast(&other->_impl_.timelag_)); +} + +::google::protobuf::Metadata SkyWritingCfg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[18]); +} +// =================================================================== + +class PowerCompensate::_Internal { + public: +}; + +PowerCompensate::PowerCompensate(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.PowerCompensate) +} +PowerCompensate::PowerCompensate(const PowerCompensate& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.PowerCompensate) +} +inline void PowerCompensate::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.cno_){0}, + decltype(_impl_.percent_){0}, + decltype(_impl_.value_){0}, + decltype(_impl_.value_min_){0}, + decltype(_impl_.value_max_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +PowerCompensate::~PowerCompensate() { + // @@protoc_insertion_point(destructor:stream.PowerCompensate) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void PowerCompensate::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void PowerCompensate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void PowerCompensate::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.PowerCompensate) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.cno_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.value_max_) - + reinterpret_cast(&_impl_.cno_)) + sizeof(_impl_.value_max_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* PowerCompensate::_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, 0, 0, 2> PowerCompensate::_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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_PowerCompensate_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 cno = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PowerCompensate, _impl_.cno_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_)}}, + // int32 percent = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PowerCompensate, _impl_.percent_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.percent_)}}, + // float value = 3; + {::_pbi::TcParser::FastF32S1, + {29, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_)}}, + // float value_min = 4; + {::_pbi::TcParser::FastF32S1, + {37, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_min_)}}, + // float value_max = 5; + {::_pbi::TcParser::FastF32S1, + {45, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 cno = 1; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 percent = 2; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.percent_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // float value = 3; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float value_min = 4; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_min_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float value_max = 5; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* PowerCompensate::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.PowerCompensate) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 cno = 1; + if (this->_internal_cno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_cno(), target); + } + + // int32 percent = 2; + if (this->_internal_percent() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_percent(), target); + } + + // float value = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value = this->_internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 3, this->_internal_value(), target); + } + + // float value_min = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_min = this->_internal_value_min(); + ::uint32_t raw_value_min; + memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min)); + if (raw_value_min != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 4, this->_internal_value_min(), target); + } + + // float value_max = 5; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_max = this->_internal_value_max(); + ::uint32_t raw_value_max; + memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max)); + if (raw_value_max != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 5, this->_internal_value_max(), 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.PowerCompensate) + return target; +} + +::size_t PowerCompensate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.PowerCompensate) + ::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 cno = 1; + if (this->_internal_cno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_cno()); + } + + // int32 percent = 2; + if (this->_internal_percent() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_percent()); + } + + // float value = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value = this->_internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + total_size += 5; + } + + // float value_min = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_min = this->_internal_value_min(); + ::uint32_t raw_value_min; + memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min)); + if (raw_value_min != 0) { + total_size += 5; + } + + // float value_max = 5; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_max = this->_internal_value_max(); + ::uint32_t raw_value_max; + memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max)); + if (raw_value_max != 0) { + total_size += 5; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData PowerCompensate::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + PowerCompensate::MergeImpl +}; +const ::google::protobuf::Message::ClassData*PowerCompensate::GetClassData() const { return &_class_data_; } + + +void PowerCompensate::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.PowerCompensate) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_cno() != 0) { + _this->_internal_set_cno(from._internal_cno()); + } + if (from._internal_percent() != 0) { + _this->_internal_set_percent(from._internal_percent()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value = from._internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + _this->_internal_set_value(from._internal_value()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_min = from._internal_value_min(); + ::uint32_t raw_value_min; + memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min)); + if (raw_value_min != 0) { + _this->_internal_set_value_min(from._internal_value_min()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_max = from._internal_value_max(); + ::uint32_t raw_value_max; + memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max)); + if (raw_value_max != 0) { + _this->_internal_set_value_max(from._internal_value_max()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void PowerCompensate::CopyFrom(const PowerCompensate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.PowerCompensate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool PowerCompensate::IsInitialized() const { + return true; +} + +void PowerCompensate::InternalSwap(PowerCompensate* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_) + + sizeof(PowerCompensate::_impl_.value_max_) + - PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_)>( + reinterpret_cast(&_impl_.cno_), + reinterpret_cast(&other->_impl_.cno_)); +} + +::google::protobuf::Metadata PowerCompensate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[19]); +} +// =================================================================== + +class TimePowerCompensate::_Internal { + public: +}; + +TimePowerCompensate::TimePowerCompensate(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.TimePowerCompensate) +} +TimePowerCompensate::TimePowerCompensate(const TimePowerCompensate& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.TimePowerCompensate) +} +inline void TimePowerCompensate::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.id_){0}, + decltype(_impl_.cno_){0}, + decltype(_impl_.startminute_){0u}, + decltype(_impl_.endminute_){0u}, + decltype(_impl_.compensate_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +TimePowerCompensate::~TimePowerCompensate() { + // @@protoc_insertion_point(destructor:stream.TimePowerCompensate) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void TimePowerCompensate::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void TimePowerCompensate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void TimePowerCompensate::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.TimePowerCompensate) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.compensate_) - + reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.compensate_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* TimePowerCompensate::_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, 0, 0, 2> TimePowerCompensate::_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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_TimePowerCompensate_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_)}}, + // int32 cno = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.cno_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.cno_)}}, + // uint32 startMinute = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.startminute_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.startminute_)}}, + // uint32 endMinute = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.endminute_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.endminute_)}}, + // float compensate = 5; + {::_pbi::TcParser::FastF32S1, + {45, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 id = 1; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 cno = 2; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.cno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint32 startMinute = 3; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.startminute_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 endMinute = 4; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.endminute_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // float compensate = 5; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* TimePowerCompensate::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.TimePowerCompensate) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 id = 1; + if (this->_internal_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_id(), target); + } + + // int32 cno = 2; + if (this->_internal_cno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_cno(), target); + } + + // uint32 startMinute = 3; + if (this->_internal_startminute() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this->_internal_startminute(), target); + } + + // uint32 endMinute = 4; + if (this->_internal_endminute() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 4, this->_internal_endminute(), target); + } + + // float compensate = 5; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_compensate = this->_internal_compensate(); + ::uint32_t raw_compensate; + memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate)); + if (raw_compensate != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 5, this->_internal_compensate(), 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.TimePowerCompensate) + return target; +} + +::size_t TimePowerCompensate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.TimePowerCompensate) + ::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 id = 1; + if (this->_internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_id()); + } + + // int32 cno = 2; + if (this->_internal_cno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_cno()); + } + + // uint32 startMinute = 3; + if (this->_internal_startminute() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_startminute()); + } + + // uint32 endMinute = 4; + if (this->_internal_endminute() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_endminute()); + } + + // float compensate = 5; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_compensate = this->_internal_compensate(); + ::uint32_t raw_compensate; + memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate)); + if (raw_compensate != 0) { + total_size += 5; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData TimePowerCompensate::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + TimePowerCompensate::MergeImpl +}; +const ::google::protobuf::Message::ClassData*TimePowerCompensate::GetClassData() const { return &_class_data_; } + + +void TimePowerCompensate::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.TimePowerCompensate) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_internal_set_id(from._internal_id()); + } + if (from._internal_cno() != 0) { + _this->_internal_set_cno(from._internal_cno()); + } + if (from._internal_startminute() != 0) { + _this->_internal_set_startminute(from._internal_startminute()); + } + if (from._internal_endminute() != 0) { + _this->_internal_set_endminute(from._internal_endminute()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_compensate = from._internal_compensate(); + ::uint32_t raw_compensate; + memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate)); + if (raw_compensate != 0) { + _this->_internal_set_compensate(from._internal_compensate()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void TimePowerCompensate::CopyFrom(const TimePowerCompensate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.TimePowerCompensate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool TimePowerCompensate::IsInitialized() const { + return true; +} + +void TimePowerCompensate::InternalSwap(TimePowerCompensate* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_) + + sizeof(TimePowerCompensate::_impl_.compensate_) + - PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_)>( + reinterpret_cast(&_impl_.id_), + reinterpret_cast(&other->_impl_.id_)); +} + +::google::protobuf::Metadata TimePowerCompensate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[20]); +} // @@protoc_insertion_point(namespace_scope) } // namespace stream namespace google { diff --git a/PrintS/protobuf/stream.pb.h b/PrintS/protobuf/stream.pb.h index 4fd7990..f1a7c96 100644 --- a/PrintS/protobuf/stream.pb.h +++ b/PrintS/protobuf/stream.pb.h @@ -62,6 +62,12 @@ extern ChainDataBlockDefaultTypeInternal _ChainDataBlock_default_instance_; class ComResponce; struct ComResponceDefaultTypeInternal; extern ComResponceDefaultTypeInternal _ComResponce_default_instance_; +class CorrectParamCfg; +struct CorrectParamCfgDefaultTypeInternal; +extern CorrectParamCfgDefaultTypeInternal _CorrectParamCfg_default_instance_; +class FixPointData; +struct FixPointDataDefaultTypeInternal; +extern FixPointDataDefaultTypeInternal _FixPointData_default_instance_; class ImgInfoResponce; struct ImgInfoResponceDefaultTypeInternal; extern ImgInfoResponceDefaultTypeInternal _ImgInfoResponce_default_instance_; @@ -77,6 +83,9 @@ extern ParamInfoDefaultTypeInternal _ParamInfo_default_instance_; class Point; struct PointDefaultTypeInternal; extern PointDefaultTypeInternal _Point_default_instance_; +class PowerCompensate; +struct PowerCompensateDefaultTypeInternal; +extern PowerCompensateDefaultTypeInternal _PowerCompensate_default_instance_; class RegResponce; struct RegResponceDefaultTypeInternal; extern RegResponceDefaultTypeInternal _RegResponce_default_instance_; @@ -89,6 +98,24 @@ extern ResponseAnyDefaultTypeInternal _ResponseAny_default_instance_; class ResponseInfo; struct ResponseInfoDefaultTypeInternal; extern ResponseInfoDefaultTypeInternal _ResponseInfo_default_instance_; +class ScanParamCfg; +struct ScanParamCfgDefaultTypeInternal; +extern ScanParamCfgDefaultTypeInternal _ScanParamCfg_default_instance_; +class ScanTestCfg; +struct ScanTestCfgDefaultTypeInternal; +extern ScanTestCfgDefaultTypeInternal _ScanTestCfg_default_instance_; +class ScannerCrtlCfgData; +struct ScannerCrtlCfgDataDefaultTypeInternal; +extern ScannerCrtlCfgDataDefaultTypeInternal _ScannerCrtlCfgData_default_instance_; +class ScannerCrtlCfgResp; +struct ScannerCrtlCfgRespDefaultTypeInternal; +extern ScannerCrtlCfgRespDefaultTypeInternal _ScannerCrtlCfgResp_default_instance_; +class SkyWritingCfg; +struct SkyWritingCfgDefaultTypeInternal; +extern SkyWritingCfgDefaultTypeInternal _SkyWritingCfg_default_instance_; +class TimePowerCompensate; +struct TimePowerCompensateDefaultTypeInternal; +extern TimePowerCompensateDefaultTypeInternal _TimePowerCompensate_default_instance_; class VectorDataBlock; struct VectorDataBlockDefaultTypeInternal; extern VectorDataBlockDefaultTypeInternal _VectorDataBlock_default_instance_; @@ -311,13 +338,21 @@ class ParamInfo final : kNameKeyFieldNumber = 1, kStrValueFieldNumber = 2, kContextFieldNumber = 4, + kCardNameFieldNumber = 15, + kCardIPFieldNumber = 16, kValueTypeFieldNumber = 3, + kStartLayerFieldNumber = 8, kIsEnableFieldNumber = 5, kIsAlarmFieldNumber = 6, kIsShowFieldNumber = 7, - kStartLayerFieldNumber = 8, + kHadAssignFieldNumber = 17, kEndLayerFieldNumber = 9, kPowderFieldNumber = 10, + kSeqNoFieldNumber = 11, + kControlNoFieldNumber = 12, + kSerialNoFieldNumber = 13, + kControlTypeFieldNumber = 14, + kHadMatchFieldNumber = 18, }; // bytes nameKey = 1; void clear_namekey() ; @@ -366,6 +401,38 @@ class ParamInfo final : const std::string& value); std::string* _internal_mutable_context(); + public: + // bytes cardName = 15; + void clear_cardname() ; + const std::string& cardname() const; + template + void set_cardname(Arg_&& arg, Args_... args); + std::string* mutable_cardname(); + PROTOBUF_NODISCARD std::string* release_cardname(); + void set_allocated_cardname(std::string* ptr); + + private: + const std::string& _internal_cardname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardname( + const std::string& value); + std::string* _internal_mutable_cardname(); + + public: + // bytes cardIP = 16; + void clear_cardip() ; + const std::string& cardip() const; + template + void set_cardip(Arg_&& arg, Args_... args); + std::string* mutable_cardip(); + PROTOBUF_NODISCARD std::string* release_cardip(); + void set_allocated_cardip(std::string* ptr); + + private: + const std::string& _internal_cardip() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardip( + const std::string& value); + std::string* _internal_mutable_cardip(); + public: // .stream.TYPE valueType = 3; void clear_valuetype() ; @@ -376,6 +443,16 @@ class ParamInfo final : ::stream::TYPE _internal_valuetype() const; void _internal_set_valuetype(::stream::TYPE value); + public: + // int32 startLayer = 8; + void clear_startlayer() ; + ::int32_t startlayer() const; + void set_startlayer(::int32_t value); + + private: + ::int32_t _internal_startlayer() const; + void _internal_set_startlayer(::int32_t value); + public: // bool isEnable = 5; void clear_isenable() ; @@ -407,14 +484,14 @@ class ParamInfo final : void _internal_set_isshow(bool value); public: - // int32 startLayer = 8; - void clear_startlayer() ; - ::int32_t startlayer() const; - void set_startlayer(::int32_t value); + // bool hadAssign = 17; + void clear_hadassign() ; + bool hadassign() const; + void set_hadassign(bool value); private: - ::int32_t _internal_startlayer() const; - void _internal_set_startlayer(::int32_t value); + bool _internal_hadassign() const; + void _internal_set_hadassign(bool value); public: // int32 endLayer = 9; @@ -436,13 +513,63 @@ class ParamInfo final : float _internal_powder() const; void _internal_set_powder(float value); + public: + // int32 seqNo = 11; + void clear_seqno() ; + ::int32_t seqno() const; + void set_seqno(::int32_t value); + + private: + ::int32_t _internal_seqno() const; + void _internal_set_seqno(::int32_t value); + + public: + // int32 controlNo = 12; + void clear_controlno() ; + ::int32_t controlno() const; + void set_controlno(::int32_t value); + + private: + ::int32_t _internal_controlno() const; + void _internal_set_controlno(::int32_t value); + + public: + // int32 serialNo = 13; + void clear_serialno() ; + ::int32_t serialno() const; + void set_serialno(::int32_t value); + + private: + ::int32_t _internal_serialno() const; + void _internal_set_serialno(::int32_t value); + + public: + // int32 controlType = 14; + void clear_controltype() ; + ::int32_t controltype() const; + void set_controltype(::int32_t value); + + private: + ::int32_t _internal_controltype() const; + void _internal_set_controltype(::int32_t value); + + public: + // bool hadMatch = 18; + void clear_hadmatch() ; + bool hadmatch() const; + void set_hadmatch(bool value); + + private: + bool _internal_hadmatch() const; + void _internal_set_hadmatch(bool value); + public: // @@protoc_insertion_point(class_scope:stream.ParamInfo) private: class _Internal; friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<4, 10, 0, 0, 2> _table_; + static const ::google::protobuf::internal::TcParseTable<5, 18, 0, 0, 2> _table_; template friend class ::google::protobuf::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; @@ -450,13 +577,21 @@ class ParamInfo final : ::google::protobuf::internal::ArenaStringPtr namekey_; ::google::protobuf::internal::ArenaStringPtr strvalue_; ::google::protobuf::internal::ArenaStringPtr context_; + ::google::protobuf::internal::ArenaStringPtr cardname_; + ::google::protobuf::internal::ArenaStringPtr cardip_; int valuetype_; + ::int32_t startlayer_; bool isenable_; bool isalarm_; bool isshow_; - ::int32_t startlayer_; + bool hadassign_; ::int32_t endlayer_; float powder_; + ::int32_t seqno_; + ::int32_t controlno_; + ::int32_t serialno_; + ::int32_t controltype_; + bool hadmatch_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; @@ -2548,6 +2683,2960 @@ class ComResponce final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ScannerCrtlCfgResp final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScannerCrtlCfgResp) */ { + public: + inline ScannerCrtlCfgResp() : ScannerCrtlCfgResp(nullptr) {} + ~ScannerCrtlCfgResp() override; + template + explicit PROTOBUF_CONSTEXPR ScannerCrtlCfgResp(::google::protobuf::internal::ConstantInitialized); + + ScannerCrtlCfgResp(const ScannerCrtlCfgResp& from); + ScannerCrtlCfgResp(ScannerCrtlCfgResp&& from) noexcept + : ScannerCrtlCfgResp() { + *this = ::std::move(from); + } + + inline ScannerCrtlCfgResp& operator=(const ScannerCrtlCfgResp& from) { + CopyFrom(from); + return *this; + } + inline ScannerCrtlCfgResp& operator=(ScannerCrtlCfgResp&& 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 ScannerCrtlCfgResp& default_instance() { + return *internal_default_instance(); + } + static inline const ScannerCrtlCfgResp* internal_default_instance() { + return reinterpret_cast( + &_ScannerCrtlCfgResp_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(ScannerCrtlCfgResp& a, ScannerCrtlCfgResp& b) { + a.Swap(&b); + } + inline void Swap(ScannerCrtlCfgResp* 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(ScannerCrtlCfgResp* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScannerCrtlCfgResp* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ScannerCrtlCfgResp& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ScannerCrtlCfgResp& from) { + ScannerCrtlCfgResp::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(ScannerCrtlCfgResp* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ScannerCrtlCfgResp"; + } + protected: + explicit ScannerCrtlCfgResp(::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 { + kScannerCfgFieldNumber = 1, + }; + // repeated .stream.ScannerCrtlCfgData scannerCfg = 1; + int scannercfg_size() const; + private: + int _internal_scannercfg_size() const; + + public: + void clear_scannercfg() ; + ::stream::ScannerCrtlCfgData* mutable_scannercfg(int index); + ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >* + mutable_scannercfg(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>& _internal_scannercfg() const; + ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>* _internal_mutable_scannercfg(); + public: + const ::stream::ScannerCrtlCfgData& scannercfg(int index) const; + ::stream::ScannerCrtlCfgData* add_scannercfg(); + const ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >& + scannercfg() const; + // @@protoc_insertion_point(class_scope:stream.ScannerCrtlCfgResp) + 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::RepeatedPtrField< ::stream::ScannerCrtlCfgData > scannercfg_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ScannerCrtlCfgData final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScannerCrtlCfgData) */ { + public: + inline ScannerCrtlCfgData() : ScannerCrtlCfgData(nullptr) {} + ~ScannerCrtlCfgData() override; + template + explicit PROTOBUF_CONSTEXPR ScannerCrtlCfgData(::google::protobuf::internal::ConstantInitialized); + + ScannerCrtlCfgData(const ScannerCrtlCfgData& from); + ScannerCrtlCfgData(ScannerCrtlCfgData&& from) noexcept + : ScannerCrtlCfgData() { + *this = ::std::move(from); + } + + inline ScannerCrtlCfgData& operator=(const ScannerCrtlCfgData& from) { + CopyFrom(from); + return *this; + } + inline ScannerCrtlCfgData& operator=(ScannerCrtlCfgData&& 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 ScannerCrtlCfgData& default_instance() { + return *internal_default_instance(); + } + static inline const ScannerCrtlCfgData* internal_default_instance() { + return reinterpret_cast( + &_ScannerCrtlCfgData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(ScannerCrtlCfgData& a, ScannerCrtlCfgData& b) { + a.Swap(&b); + } + inline void Swap(ScannerCrtlCfgData* 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(ScannerCrtlCfgData* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScannerCrtlCfgData* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ScannerCrtlCfgData& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ScannerCrtlCfgData& from) { + ScannerCrtlCfgData::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(ScannerCrtlCfgData* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ScannerCrtlCfgData"; + } + protected: + explicit ScannerCrtlCfgData(::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 { + kFixPointDataFieldNumber = 2, + kPowerCompensateFieldNumber = 10, + kTPowerCompensateFieldNumber = 11, + kCardNameFieldNumber = 15, + kCardIPFieldNumber = 16, + kScanParamCfgFieldNumber = 3, + kHatchingParamsFieldNumber = 4, + kBorderParamsFieldNumber = 5, + kSupportParamsFieldNumber = 6, + kCorrectParamCfgFieldNumber = 7, + kScanTestCfgFieldNumber = 8, + kSkyWritingCfgFieldNumber = 9, + kSeqNoFieldNumber = 1, + kControlNoFieldNumber = 12, + kSerialNoFieldNumber = 13, + kControlTypeFieldNumber = 14, + kIsEnableFieldNumber = 17, + kHadAssignFieldNumber = 18, + kHadMatchFieldNumber = 19, + }; + // repeated .stream.FixPointData fixPointData = 2; + int fixpointdata_size() const; + private: + int _internal_fixpointdata_size() const; + + public: + void clear_fixpointdata() ; + ::stream::FixPointData* mutable_fixpointdata(int index); + ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >* + mutable_fixpointdata(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::FixPointData>& _internal_fixpointdata() const; + ::google::protobuf::RepeatedPtrField<::stream::FixPointData>* _internal_mutable_fixpointdata(); + public: + const ::stream::FixPointData& fixpointdata(int index) const; + ::stream::FixPointData* add_fixpointdata(); + const ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >& + fixpointdata() const; + // repeated .stream.PowerCompensate powerCompensate = 10; + int powercompensate_size() const; + private: + int _internal_powercompensate_size() const; + + public: + void clear_powercompensate() ; + ::stream::PowerCompensate* mutable_powercompensate(int index); + ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >* + mutable_powercompensate(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>& _internal_powercompensate() const; + ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>* _internal_mutable_powercompensate(); + public: + const ::stream::PowerCompensate& powercompensate(int index) const; + ::stream::PowerCompensate* add_powercompensate(); + const ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >& + powercompensate() const; + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + int tpowercompensate_size() const; + private: + int _internal_tpowercompensate_size() const; + + public: + void clear_tpowercompensate() ; + ::stream::TimePowerCompensate* mutable_tpowercompensate(int index); + ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >* + mutable_tpowercompensate(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>& _internal_tpowercompensate() const; + ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>* _internal_mutable_tpowercompensate(); + public: + const ::stream::TimePowerCompensate& tpowercompensate(int index) const; + ::stream::TimePowerCompensate* add_tpowercompensate(); + const ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >& + tpowercompensate() const; + // bytes cardName = 15; + void clear_cardname() ; + const std::string& cardname() const; + template + void set_cardname(Arg_&& arg, Args_... args); + std::string* mutable_cardname(); + PROTOBUF_NODISCARD std::string* release_cardname(); + void set_allocated_cardname(std::string* ptr); + + private: + const std::string& _internal_cardname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardname( + const std::string& value); + std::string* _internal_mutable_cardname(); + + public: + // bytes cardIP = 16; + void clear_cardip() ; + const std::string& cardip() const; + template + void set_cardip(Arg_&& arg, Args_... args); + std::string* mutable_cardip(); + PROTOBUF_NODISCARD std::string* release_cardip(); + void set_allocated_cardip(std::string* ptr); + + private: + const std::string& _internal_cardip() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardip( + const std::string& value); + std::string* _internal_mutable_cardip(); + + public: + // .stream.ScanParamCfg scanParamCfg = 3; + bool has_scanparamcfg() const; + void clear_scanparamcfg() ; + const ::stream::ScanParamCfg& scanparamcfg() const; + PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_scanparamcfg(); + ::stream::ScanParamCfg* mutable_scanparamcfg(); + void set_allocated_scanparamcfg(::stream::ScanParamCfg* value); + void unsafe_arena_set_allocated_scanparamcfg(::stream::ScanParamCfg* value); + ::stream::ScanParamCfg* unsafe_arena_release_scanparamcfg(); + + private: + const ::stream::ScanParamCfg& _internal_scanparamcfg() const; + ::stream::ScanParamCfg* _internal_mutable_scanparamcfg(); + + public: + // .stream.ScanParamCfg hatchingParams = 4; + bool has_hatchingparams() const; + void clear_hatchingparams() ; + const ::stream::ScanParamCfg& hatchingparams() const; + PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_hatchingparams(); + ::stream::ScanParamCfg* mutable_hatchingparams(); + void set_allocated_hatchingparams(::stream::ScanParamCfg* value); + void unsafe_arena_set_allocated_hatchingparams(::stream::ScanParamCfg* value); + ::stream::ScanParamCfg* unsafe_arena_release_hatchingparams(); + + private: + const ::stream::ScanParamCfg& _internal_hatchingparams() const; + ::stream::ScanParamCfg* _internal_mutable_hatchingparams(); + + public: + // .stream.ScanParamCfg borderParams = 5; + bool has_borderparams() const; + void clear_borderparams() ; + const ::stream::ScanParamCfg& borderparams() const; + PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_borderparams(); + ::stream::ScanParamCfg* mutable_borderparams(); + void set_allocated_borderparams(::stream::ScanParamCfg* value); + void unsafe_arena_set_allocated_borderparams(::stream::ScanParamCfg* value); + ::stream::ScanParamCfg* unsafe_arena_release_borderparams(); + + private: + const ::stream::ScanParamCfg& _internal_borderparams() const; + ::stream::ScanParamCfg* _internal_mutable_borderparams(); + + public: + // .stream.ScanParamCfg supportParams = 6; + bool has_supportparams() const; + void clear_supportparams() ; + const ::stream::ScanParamCfg& supportparams() const; + PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_supportparams(); + ::stream::ScanParamCfg* mutable_supportparams(); + void set_allocated_supportparams(::stream::ScanParamCfg* value); + void unsafe_arena_set_allocated_supportparams(::stream::ScanParamCfg* value); + ::stream::ScanParamCfg* unsafe_arena_release_supportparams(); + + private: + const ::stream::ScanParamCfg& _internal_supportparams() const; + ::stream::ScanParamCfg* _internal_mutable_supportparams(); + + public: + // .stream.CorrectParamCfg correctParamCfg = 7; + bool has_correctparamcfg() const; + void clear_correctparamcfg() ; + const ::stream::CorrectParamCfg& correctparamcfg() const; + PROTOBUF_NODISCARD ::stream::CorrectParamCfg* release_correctparamcfg(); + ::stream::CorrectParamCfg* mutable_correctparamcfg(); + void set_allocated_correctparamcfg(::stream::CorrectParamCfg* value); + void unsafe_arena_set_allocated_correctparamcfg(::stream::CorrectParamCfg* value); + ::stream::CorrectParamCfg* unsafe_arena_release_correctparamcfg(); + + private: + const ::stream::CorrectParamCfg& _internal_correctparamcfg() const; + ::stream::CorrectParamCfg* _internal_mutable_correctparamcfg(); + + public: + // .stream.ScanTestCfg scanTestCfg = 8; + bool has_scantestcfg() const; + void clear_scantestcfg() ; + const ::stream::ScanTestCfg& scantestcfg() const; + PROTOBUF_NODISCARD ::stream::ScanTestCfg* release_scantestcfg(); + ::stream::ScanTestCfg* mutable_scantestcfg(); + void set_allocated_scantestcfg(::stream::ScanTestCfg* value); + void unsafe_arena_set_allocated_scantestcfg(::stream::ScanTestCfg* value); + ::stream::ScanTestCfg* unsafe_arena_release_scantestcfg(); + + private: + const ::stream::ScanTestCfg& _internal_scantestcfg() const; + ::stream::ScanTestCfg* _internal_mutable_scantestcfg(); + + public: + // .stream.SkyWritingCfg skyWritingCfg = 9; + bool has_skywritingcfg() const; + void clear_skywritingcfg() ; + const ::stream::SkyWritingCfg& skywritingcfg() const; + PROTOBUF_NODISCARD ::stream::SkyWritingCfg* release_skywritingcfg(); + ::stream::SkyWritingCfg* mutable_skywritingcfg(); + void set_allocated_skywritingcfg(::stream::SkyWritingCfg* value); + void unsafe_arena_set_allocated_skywritingcfg(::stream::SkyWritingCfg* value); + ::stream::SkyWritingCfg* unsafe_arena_release_skywritingcfg(); + + private: + const ::stream::SkyWritingCfg& _internal_skywritingcfg() const; + ::stream::SkyWritingCfg* _internal_mutable_skywritingcfg(); + + public: + // int32 seqNo = 1; + void clear_seqno() ; + ::int32_t seqno() const; + void set_seqno(::int32_t value); + + private: + ::int32_t _internal_seqno() const; + void _internal_set_seqno(::int32_t value); + + public: + // int32 controlNo = 12; + void clear_controlno() ; + ::int32_t controlno() const; + void set_controlno(::int32_t value); + + private: + ::int32_t _internal_controlno() const; + void _internal_set_controlno(::int32_t value); + + public: + // int32 serialNo = 13; + void clear_serialno() ; + ::int32_t serialno() const; + void set_serialno(::int32_t value); + + private: + ::int32_t _internal_serialno() const; + void _internal_set_serialno(::int32_t value); + + public: + // int32 controlType = 14; + void clear_controltype() ; + ::int32_t controltype() const; + void set_controltype(::int32_t value); + + private: + ::int32_t _internal_controltype() const; + void _internal_set_controltype(::int32_t value); + + public: + // bool isEnable = 17; + void clear_isenable() ; + bool isenable() const; + void set_isenable(bool value); + + private: + bool _internal_isenable() const; + void _internal_set_isenable(bool value); + + public: + // bool hadAssign = 18; + void clear_hadassign() ; + bool hadassign() const; + void set_hadassign(bool value); + + private: + bool _internal_hadassign() const; + void _internal_set_hadassign(bool value); + + public: + // bool hadMatch = 19; + void clear_hadmatch() ; + bool hadmatch() const; + void set_hadmatch(bool value); + + private: + bool _internal_hadmatch() const; + void _internal_set_hadmatch(bool value); + + public: + // @@protoc_insertion_point(class_scope:stream.ScannerCrtlCfgData) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 19, 10, 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::RepeatedPtrField< ::stream::FixPointData > fixpointdata_; + ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate > powercompensate_; + ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate > tpowercompensate_; + ::google::protobuf::internal::ArenaStringPtr cardname_; + ::google::protobuf::internal::ArenaStringPtr cardip_; + ::stream::ScanParamCfg* scanparamcfg_; + ::stream::ScanParamCfg* hatchingparams_; + ::stream::ScanParamCfg* borderparams_; + ::stream::ScanParamCfg* supportparams_; + ::stream::CorrectParamCfg* correctparamcfg_; + ::stream::ScanTestCfg* scantestcfg_; + ::stream::SkyWritingCfg* skywritingcfg_; + ::int32_t seqno_; + ::int32_t controlno_; + ::int32_t serialno_; + ::int32_t controltype_; + bool isenable_; + bool hadassign_; + bool hadmatch_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class FixPointData final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.FixPointData) */ { + public: + inline FixPointData() : FixPointData(nullptr) {} + ~FixPointData() override; + template + explicit PROTOBUF_CONSTEXPR FixPointData(::google::protobuf::internal::ConstantInitialized); + + FixPointData(const FixPointData& from); + FixPointData(FixPointData&& from) noexcept + : FixPointData() { + *this = ::std::move(from); + } + + inline FixPointData& operator=(const FixPointData& from) { + CopyFrom(from); + return *this; + } + inline FixPointData& operator=(FixPointData&& 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 FixPointData& default_instance() { + return *internal_default_instance(); + } + static inline const FixPointData* internal_default_instance() { + return reinterpret_cast( + &_FixPointData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(FixPointData& a, FixPointData& b) { + a.Swap(&b); + } + inline void Swap(FixPointData* 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(FixPointData* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FixPointData* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const FixPointData& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const FixPointData& from) { + FixPointData::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(FixPointData* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.FixPointData"; + } + protected: + explicit FixPointData(::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 { + kIdFieldNumber = 1, + kCnoFieldNumber = 2, + kPointXFieldNumber = 3, + kPointYFieldNumber = 4, + kDurationFieldNumber = 5, + }; + // int32 id = 1; + void clear_id() ; + ::int32_t id() const; + void set_id(::int32_t value); + + private: + ::int32_t _internal_id() const; + void _internal_set_id(::int32_t value); + + public: + // int32 cno = 2; + void clear_cno() ; + ::int32_t cno() const; + void set_cno(::int32_t value); + + private: + ::int32_t _internal_cno() const; + void _internal_set_cno(::int32_t value); + + public: + // float pointX = 3; + void clear_pointx() ; + float pointx() const; + void set_pointx(float value); + + private: + float _internal_pointx() const; + void _internal_set_pointx(float value); + + public: + // float pointY = 4; + void clear_pointy() ; + float pointy() const; + void set_pointy(float value); + + private: + float _internal_pointy() const; + void _internal_set_pointy(float value); + + public: + // uint32 duration = 5; + void clear_duration() ; + ::uint32_t duration() const; + void set_duration(::uint32_t value); + + private: + ::uint32_t _internal_duration() const; + void _internal_set_duration(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:stream.FixPointData) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t id_; + ::int32_t cno_; + float pointx_; + float pointy_; + ::uint32_t duration_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ScanParamCfg final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScanParamCfg) */ { + public: + inline ScanParamCfg() : ScanParamCfg(nullptr) {} + ~ScanParamCfg() override; + template + explicit PROTOBUF_CONSTEXPR ScanParamCfg(::google::protobuf::internal::ConstantInitialized); + + ScanParamCfg(const ScanParamCfg& from); + ScanParamCfg(ScanParamCfg&& from) noexcept + : ScanParamCfg() { + *this = ::std::move(from); + } + + inline ScanParamCfg& operator=(const ScanParamCfg& from) { + CopyFrom(from); + return *this; + } + inline ScanParamCfg& operator=(ScanParamCfg&& 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 ScanParamCfg& default_instance() { + return *internal_default_instance(); + } + static inline const ScanParamCfg* internal_default_instance() { + return reinterpret_cast( + &_ScanParamCfg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(ScanParamCfg& a, ScanParamCfg& b) { + a.Swap(&b); + } + inline void Swap(ScanParamCfg* 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(ScanParamCfg* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScanParamCfg* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ScanParamCfg& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ScanParamCfg& from) { + ScanParamCfg::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(ScanParamCfg* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ScanParamCfg"; + } + protected: + explicit ScanParamCfg(::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 { + kEdgeLevelFieldNumber = 1, + kEdgeLevelMinFieldNumber = 2, + kEdgeLevelMaxFieldNumber = 3, + kJumpDelayFieldNumber = 4, + kJumpDelayMinFieldNumber = 5, + kJumpDelayMaxFieldNumber = 6, + kScanDelayFieldNumber = 7, + kScanDelayMinFieldNumber = 8, + kScanDelayMaxFieldNumber = 9, + kPolygonDelayFieldNumber = 10, + kPolygonDelayMinFieldNumber = 11, + kPolygonDelayMaxFieldNumber = 12, + kLaseroffDelayFieldNumber = 13, + kLaseroffDelayMinFieldNumber = 14, + kLaseroffDelayMaxFieldNumber = 15, + kLaseronDelayFieldNumber = 16, + kLaseronDelayMinFieldNumber = 17, + kLaseronDelayMaxFieldNumber = 18, + kMinJumpDelayFieldNumber = 19, + kMinJumpDelayMinFieldNumber = 20, + kMinJumpDelayMaxFieldNumber = 21, + kJumpLengthLimitFieldNumber = 22, + kJumpLengthLimitMinFieldNumber = 23, + kJumpLengthLimitMaxFieldNumber = 24, + kJumpSpeedFieldNumber = 25, + kJumpSpeedMinFieldNumber = 26, + kJumpSpeedMaxFieldNumber = 27, + kMarkSpeedFieldNumber = 28, + kMarkSpeedMinFieldNumber = 29, + kMarkSpeedMaxFieldNumber = 30, + }; + // int32 edgeLevel = 1; + void clear_edgelevel() ; + ::int32_t edgelevel() const; + void set_edgelevel(::int32_t value); + + private: + ::int32_t _internal_edgelevel() const; + void _internal_set_edgelevel(::int32_t value); + + public: + // int32 edgeLevelMin = 2; + void clear_edgelevelmin() ; + ::int32_t edgelevelmin() const; + void set_edgelevelmin(::int32_t value); + + private: + ::int32_t _internal_edgelevelmin() const; + void _internal_set_edgelevelmin(::int32_t value); + + public: + // int32 edgeLevelMax = 3; + void clear_edgelevelmax() ; + ::int32_t edgelevelmax() const; + void set_edgelevelmax(::int32_t value); + + private: + ::int32_t _internal_edgelevelmax() const; + void _internal_set_edgelevelmax(::int32_t value); + + public: + // uint32 jumpDelay = 4; + void clear_jumpdelay() ; + ::uint32_t jumpdelay() const; + void set_jumpdelay(::uint32_t value); + + private: + ::uint32_t _internal_jumpdelay() const; + void _internal_set_jumpdelay(::uint32_t value); + + public: + // uint32 jumpDelayMin = 5; + void clear_jumpdelaymin() ; + ::uint32_t jumpdelaymin() const; + void set_jumpdelaymin(::uint32_t value); + + private: + ::uint32_t _internal_jumpdelaymin() const; + void _internal_set_jumpdelaymin(::uint32_t value); + + public: + // uint32 jumpDelayMax = 6; + void clear_jumpdelaymax() ; + ::uint32_t jumpdelaymax() const; + void set_jumpdelaymax(::uint32_t value); + + private: + ::uint32_t _internal_jumpdelaymax() const; + void _internal_set_jumpdelaymax(::uint32_t value); + + public: + // uint32 scanDelay = 7; + void clear_scandelay() ; + ::uint32_t scandelay() const; + void set_scandelay(::uint32_t value); + + private: + ::uint32_t _internal_scandelay() const; + void _internal_set_scandelay(::uint32_t value); + + public: + // uint32 scanDelayMin = 8; + void clear_scandelaymin() ; + ::uint32_t scandelaymin() const; + void set_scandelaymin(::uint32_t value); + + private: + ::uint32_t _internal_scandelaymin() const; + void _internal_set_scandelaymin(::uint32_t value); + + public: + // uint32 scanDelayMax = 9; + void clear_scandelaymax() ; + ::uint32_t scandelaymax() const; + void set_scandelaymax(::uint32_t value); + + private: + ::uint32_t _internal_scandelaymax() const; + void _internal_set_scandelaymax(::uint32_t value); + + public: + // uint32 polygonDelay = 10; + void clear_polygondelay() ; + ::uint32_t polygondelay() const; + void set_polygondelay(::uint32_t value); + + private: + ::uint32_t _internal_polygondelay() const; + void _internal_set_polygondelay(::uint32_t value); + + public: + // uint32 polygonDelayMin = 11; + void clear_polygondelaymin() ; + ::uint32_t polygondelaymin() const; + void set_polygondelaymin(::uint32_t value); + + private: + ::uint32_t _internal_polygondelaymin() const; + void _internal_set_polygondelaymin(::uint32_t value); + + public: + // uint32 polygonDelayMax = 12; + void clear_polygondelaymax() ; + ::uint32_t polygondelaymax() const; + void set_polygondelaymax(::uint32_t value); + + private: + ::uint32_t _internal_polygondelaymax() const; + void _internal_set_polygondelaymax(::uint32_t value); + + public: + // int64 laseroffDelay = 13; + void clear_laseroffdelay() ; + ::int64_t laseroffdelay() const; + void set_laseroffdelay(::int64_t value); + + private: + ::int64_t _internal_laseroffdelay() const; + void _internal_set_laseroffdelay(::int64_t value); + + public: + // int64 laseroffDelayMin = 14; + void clear_laseroffdelaymin() ; + ::int64_t laseroffdelaymin() const; + void set_laseroffdelaymin(::int64_t value); + + private: + ::int64_t _internal_laseroffdelaymin() const; + void _internal_set_laseroffdelaymin(::int64_t value); + + public: + // int64 laseroffDelayMax = 15; + void clear_laseroffdelaymax() ; + ::int64_t laseroffdelaymax() const; + void set_laseroffdelaymax(::int64_t value); + + private: + ::int64_t _internal_laseroffdelaymax() const; + void _internal_set_laseroffdelaymax(::int64_t value); + + public: + // int64 laseronDelay = 16; + void clear_laserondelay() ; + ::int64_t laserondelay() const; + void set_laserondelay(::int64_t value); + + private: + ::int64_t _internal_laserondelay() const; + void _internal_set_laserondelay(::int64_t value); + + public: + // int64 laseronDelayMin = 17; + void clear_laserondelaymin() ; + ::int64_t laserondelaymin() const; + void set_laserondelaymin(::int64_t value); + + private: + ::int64_t _internal_laserondelaymin() const; + void _internal_set_laserondelaymin(::int64_t value); + + public: + // int64 laseronDelayMax = 18; + void clear_laserondelaymax() ; + ::int64_t laserondelaymax() const; + void set_laserondelaymax(::int64_t value); + + private: + ::int64_t _internal_laserondelaymax() const; + void _internal_set_laserondelaymax(::int64_t value); + + public: + // uint32 minJumpDelay = 19; + void clear_minjumpdelay() ; + ::uint32_t minjumpdelay() const; + void set_minjumpdelay(::uint32_t value); + + private: + ::uint32_t _internal_minjumpdelay() const; + void _internal_set_minjumpdelay(::uint32_t value); + + public: + // uint32 minJumpDelayMin = 20; + void clear_minjumpdelaymin() ; + ::uint32_t minjumpdelaymin() const; + void set_minjumpdelaymin(::uint32_t value); + + private: + ::uint32_t _internal_minjumpdelaymin() const; + void _internal_set_minjumpdelaymin(::uint32_t value); + + public: + // uint32 minJumpDelayMax = 21; + void clear_minjumpdelaymax() ; + ::uint32_t minjumpdelaymax() const; + void set_minjumpdelaymax(::uint32_t value); + + private: + ::uint32_t _internal_minjumpdelaymax() const; + void _internal_set_minjumpdelaymax(::uint32_t value); + + public: + // uint32 jumpLengthLimit = 22; + void clear_jumplengthlimit() ; + ::uint32_t jumplengthlimit() const; + void set_jumplengthlimit(::uint32_t value); + + private: + ::uint32_t _internal_jumplengthlimit() const; + void _internal_set_jumplengthlimit(::uint32_t value); + + public: + // uint32 jumpLengthLimitMin = 23; + void clear_jumplengthlimitmin() ; + ::uint32_t jumplengthlimitmin() const; + void set_jumplengthlimitmin(::uint32_t value); + + private: + ::uint32_t _internal_jumplengthlimitmin() const; + void _internal_set_jumplengthlimitmin(::uint32_t value); + + public: + // uint32 jumpLengthLimitMax = 24; + void clear_jumplengthlimitmax() ; + ::uint32_t jumplengthlimitmax() const; + void set_jumplengthlimitmax(::uint32_t value); + + private: + ::uint32_t _internal_jumplengthlimitmax() const; + void _internal_set_jumplengthlimitmax(::uint32_t value); + + public: + // double jumpSpeed = 25; + void clear_jumpspeed() ; + double jumpspeed() const; + void set_jumpspeed(double value); + + private: + double _internal_jumpspeed() const; + void _internal_set_jumpspeed(double value); + + public: + // double jumpSpeedMin = 26; + void clear_jumpspeedmin() ; + double jumpspeedmin() const; + void set_jumpspeedmin(double value); + + private: + double _internal_jumpspeedmin() const; + void _internal_set_jumpspeedmin(double value); + + public: + // double jumpSpeedMax = 27; + void clear_jumpspeedmax() ; + double jumpspeedmax() const; + void set_jumpspeedmax(double value); + + private: + double _internal_jumpspeedmax() const; + void _internal_set_jumpspeedmax(double value); + + public: + // double markSpeed = 28; + void clear_markspeed() ; + double markspeed() const; + void set_markspeed(double value); + + private: + double _internal_markspeed() const; + void _internal_set_markspeed(double value); + + public: + // double markSpeedMin = 29; + void clear_markspeedmin() ; + double markspeedmin() const; + void set_markspeedmin(double value); + + private: + double _internal_markspeedmin() const; + void _internal_set_markspeedmin(double value); + + public: + // double markSpeedMax = 30; + void clear_markspeedmax() ; + double markspeedmax() const; + void set_markspeedmax(double value); + + private: + double _internal_markspeedmax() const; + void _internal_set_markspeedmax(double value); + + public: + // @@protoc_insertion_point(class_scope:stream.ScanParamCfg) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 30, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t edgelevel_; + ::int32_t edgelevelmin_; + ::int32_t edgelevelmax_; + ::uint32_t jumpdelay_; + ::uint32_t jumpdelaymin_; + ::uint32_t jumpdelaymax_; + ::uint32_t scandelay_; + ::uint32_t scandelaymin_; + ::uint32_t scandelaymax_; + ::uint32_t polygondelay_; + ::uint32_t polygondelaymin_; + ::uint32_t polygondelaymax_; + ::int64_t laseroffdelay_; + ::int64_t laseroffdelaymin_; + ::int64_t laseroffdelaymax_; + ::int64_t laserondelay_; + ::int64_t laserondelaymin_; + ::int64_t laserondelaymax_; + ::uint32_t minjumpdelay_; + ::uint32_t minjumpdelaymin_; + ::uint32_t minjumpdelaymax_; + ::uint32_t jumplengthlimit_; + ::uint32_t jumplengthlimitmin_; + ::uint32_t jumplengthlimitmax_; + double jumpspeed_; + double jumpspeedmin_; + double jumpspeedmax_; + double markspeed_; + double markspeedmin_; + double markspeedmax_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class CorrectParamCfg final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.CorrectParamCfg) */ { + public: + inline CorrectParamCfg() : CorrectParamCfg(nullptr) {} + ~CorrectParamCfg() override; + template + explicit PROTOBUF_CONSTEXPR CorrectParamCfg(::google::protobuf::internal::ConstantInitialized); + + CorrectParamCfg(const CorrectParamCfg& from); + CorrectParamCfg(CorrectParamCfg&& from) noexcept + : CorrectParamCfg() { + *this = ::std::move(from); + } + + inline CorrectParamCfg& operator=(const CorrectParamCfg& from) { + CopyFrom(from); + return *this; + } + inline CorrectParamCfg& operator=(CorrectParamCfg&& 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 CorrectParamCfg& default_instance() { + return *internal_default_instance(); + } + static inline const CorrectParamCfg* internal_default_instance() { + return reinterpret_cast( + &_CorrectParamCfg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(CorrectParamCfg& a, CorrectParamCfg& b) { + a.Swap(&b); + } + inline void Swap(CorrectParamCfg* 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(CorrectParamCfg* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CorrectParamCfg* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const CorrectParamCfg& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const CorrectParamCfg& from) { + CorrectParamCfg::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(CorrectParamCfg* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.CorrectParamCfg"; + } + protected: + explicit CorrectParamCfg(::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 { + kXmeasureMinFieldNumber = 1, + kXmeasureMaxFieldNumber = 2, + kYmeasureMinFieldNumber = 3, + kYmeasureMaxFieldNumber = 4, + kXposfixFieldNumber = 5, + kYposfixFieldNumber = 6, + kScanAngleFieldNumber = 7, + kScanAngleMinFieldNumber = 8, + kScanAngleMaxFieldNumber = 9, + kFixAngleFieldNumber = 10, + kFixAngleMinFieldNumber = 11, + kFixAngleMaxFieldNumber = 12, + kXcorrectFieldNumber = 13, + kYcorrectFieldNumber = 14, + kXcorrectMinFieldNumber = 15, + kXcorrectMaxFieldNumber = 16, + kYcorrectMinFieldNumber = 17, + kYcorrectMaxFieldNumber = 18, + kRealXOffsetFieldNumber = 19, + kRealYOffsetFieldNumber = 20, + kFactorKFieldNumber = 21, + kDefocusRatioFieldNumber = 24, + kDefocusRatioMinFieldNumber = 25, + kDefocusRatioMaxFieldNumber = 26, + kIsCorrectFile3DFieldNumber = 22, + kIsDynamicFocusFieldNumber = 23, + }; + // double xmeasureMin = 1; + void clear_xmeasuremin() ; + double xmeasuremin() const; + void set_xmeasuremin(double value); + + private: + double _internal_xmeasuremin() const; + void _internal_set_xmeasuremin(double value); + + public: + // double xmeasureMax = 2; + void clear_xmeasuremax() ; + double xmeasuremax() const; + void set_xmeasuremax(double value); + + private: + double _internal_xmeasuremax() const; + void _internal_set_xmeasuremax(double value); + + public: + // double ymeasureMin = 3; + void clear_ymeasuremin() ; + double ymeasuremin() const; + void set_ymeasuremin(double value); + + private: + double _internal_ymeasuremin() const; + void _internal_set_ymeasuremin(double value); + + public: + // double ymeasureMax = 4; + void clear_ymeasuremax() ; + double ymeasuremax() const; + void set_ymeasuremax(double value); + + private: + double _internal_ymeasuremax() const; + void _internal_set_ymeasuremax(double value); + + public: + // double xposfix = 5; + void clear_xposfix() ; + double xposfix() const; + void set_xposfix(double value); + + private: + double _internal_xposfix() const; + void _internal_set_xposfix(double value); + + public: + // double yposfix = 6; + void clear_yposfix() ; + double yposfix() const; + void set_yposfix(double value); + + private: + double _internal_yposfix() const; + void _internal_set_yposfix(double value); + + public: + // double scanAngle = 7; + void clear_scanangle() ; + double scanangle() const; + void set_scanangle(double value); + + private: + double _internal_scanangle() const; + void _internal_set_scanangle(double value); + + public: + // double scanAngleMin = 8; + void clear_scananglemin() ; + double scananglemin() const; + void set_scananglemin(double value); + + private: + double _internal_scananglemin() const; + void _internal_set_scananglemin(double value); + + public: + // double scanAngleMax = 9; + void clear_scananglemax() ; + double scananglemax() const; + void set_scananglemax(double value); + + private: + double _internal_scananglemax() const; + void _internal_set_scananglemax(double value); + + public: + // double fixAngle = 10; + void clear_fixangle() ; + double fixangle() const; + void set_fixangle(double value); + + private: + double _internal_fixangle() const; + void _internal_set_fixangle(double value); + + public: + // double fixAngleMin = 11; + void clear_fixanglemin() ; + double fixanglemin() const; + void set_fixanglemin(double value); + + private: + double _internal_fixanglemin() const; + void _internal_set_fixanglemin(double value); + + public: + // double fixAngleMax = 12; + void clear_fixanglemax() ; + double fixanglemax() const; + void set_fixanglemax(double value); + + private: + double _internal_fixanglemax() const; + void _internal_set_fixanglemax(double value); + + public: + // double xcorrect = 13; + void clear_xcorrect() ; + double xcorrect() const; + void set_xcorrect(double value); + + private: + double _internal_xcorrect() const; + void _internal_set_xcorrect(double value); + + public: + // double ycorrect = 14; + void clear_ycorrect() ; + double ycorrect() const; + void set_ycorrect(double value); + + private: + double _internal_ycorrect() const; + void _internal_set_ycorrect(double value); + + public: + // double xcorrectMin = 15; + void clear_xcorrectmin() ; + double xcorrectmin() const; + void set_xcorrectmin(double value); + + private: + double _internal_xcorrectmin() const; + void _internal_set_xcorrectmin(double value); + + public: + // double xcorrectMax = 16; + void clear_xcorrectmax() ; + double xcorrectmax() const; + void set_xcorrectmax(double value); + + private: + double _internal_xcorrectmax() const; + void _internal_set_xcorrectmax(double value); + + public: + // double ycorrectMin = 17; + void clear_ycorrectmin() ; + double ycorrectmin() const; + void set_ycorrectmin(double value); + + private: + double _internal_ycorrectmin() const; + void _internal_set_ycorrectmin(double value); + + public: + // double ycorrectMax = 18; + void clear_ycorrectmax() ; + double ycorrectmax() const; + void set_ycorrectmax(double value); + + private: + double _internal_ycorrectmax() const; + void _internal_set_ycorrectmax(double value); + + public: + // double realXOffset = 19; + void clear_realxoffset() ; + double realxoffset() const; + void set_realxoffset(double value); + + private: + double _internal_realxoffset() const; + void _internal_set_realxoffset(double value); + + public: + // double realYOffset = 20; + void clear_realyoffset() ; + double realyoffset() const; + void set_realyoffset(double value); + + private: + double _internal_realyoffset() const; + void _internal_set_realyoffset(double value); + + public: + // double factorK = 21; + void clear_factork() ; + double factork() const; + void set_factork(double value); + + private: + double _internal_factork() const; + void _internal_set_factork(double value); + + public: + // double defocusRatio = 24; + void clear_defocusratio() ; + double defocusratio() const; + void set_defocusratio(double value); + + private: + double _internal_defocusratio() const; + void _internal_set_defocusratio(double value); + + public: + // double defocusRatioMin = 25; + void clear_defocusratiomin() ; + double defocusratiomin() const; + void set_defocusratiomin(double value); + + private: + double _internal_defocusratiomin() const; + void _internal_set_defocusratiomin(double value); + + public: + // double defocusRatioMax = 26; + void clear_defocusratiomax() ; + double defocusratiomax() const; + void set_defocusratiomax(double value); + + private: + double _internal_defocusratiomax() const; + void _internal_set_defocusratiomax(double value); + + public: + // bool isCorrectFile3D = 22; + void clear_iscorrectfile3d() ; + bool iscorrectfile3d() const; + void set_iscorrectfile3d(bool value); + + private: + bool _internal_iscorrectfile3d() const; + void _internal_set_iscorrectfile3d(bool value); + + public: + // bool isDynamicFocus = 23; + void clear_isdynamicfocus() ; + bool isdynamicfocus() const; + void set_isdynamicfocus(bool value); + + private: + bool _internal_isdynamicfocus() const; + void _internal_set_isdynamicfocus(bool value); + + public: + // @@protoc_insertion_point(class_scope:stream.CorrectParamCfg) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 26, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + double xmeasuremin_; + double xmeasuremax_; + double ymeasuremin_; + double ymeasuremax_; + double xposfix_; + double yposfix_; + double scanangle_; + double scananglemin_; + double scananglemax_; + double fixangle_; + double fixanglemin_; + double fixanglemax_; + double xcorrect_; + double ycorrect_; + double xcorrectmin_; + double xcorrectmax_; + double ycorrectmin_; + double ycorrectmax_; + double realxoffset_; + double realyoffset_; + double factork_; + double defocusratio_; + double defocusratiomin_; + double defocusratiomax_; + bool iscorrectfile3d_; + bool isdynamicfocus_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ScanTestCfg final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScanTestCfg) */ { + public: + inline ScanTestCfg() : ScanTestCfg(nullptr) {} + ~ScanTestCfg() override; + template + explicit PROTOBUF_CONSTEXPR ScanTestCfg(::google::protobuf::internal::ConstantInitialized); + + ScanTestCfg(const ScanTestCfg& from); + ScanTestCfg(ScanTestCfg&& from) noexcept + : ScanTestCfg() { + *this = ::std::move(from); + } + + inline ScanTestCfg& operator=(const ScanTestCfg& from) { + CopyFrom(from); + return *this; + } + inline ScanTestCfg& operator=(ScanTestCfg&& 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 ScanTestCfg& default_instance() { + return *internal_default_instance(); + } + static inline const ScanTestCfg* internal_default_instance() { + return reinterpret_cast( + &_ScanTestCfg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(ScanTestCfg& a, ScanTestCfg& b) { + a.Swap(&b); + } + inline void Swap(ScanTestCfg* 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(ScanTestCfg* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScanTestCfg* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ScanTestCfg& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ScanTestCfg& from) { + ScanTestCfg::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(ScanTestCfg* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ScanTestCfg"; + } + protected: + explicit ScanTestCfg(::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 { + kDebugShapeFieldNumber = 1, + kShapeSizeFieldNumber = 2, + kShapeSizeMinFieldNumber = 3, + kShapeSizeMaxFieldNumber = 4, + kLaserPowerFieldNumber = 5, + kLaserPowerMinFieldNumber = 6, + kDefocusFieldNumber = 8, + kDefocusMinFieldNumber = 9, + kDefocusMaxFieldNumber = 10, + kLaserPowerMaxFieldNumber = 7, + kIsCycleFieldNumber = 11, + kIsAutoHeatingScannerFieldNumber = 15, + kCrossXFieldNumber = 12, + kCrossYFieldNumber = 13, + kZDistanceFieldNumber = 14, + kAutoHeatingScannerMinutesFieldNumber = 16, + kAutoHeatingScannerSizeFieldNumber = 17, + kAutoHeatingScannerSpeedFieldNumber = 18, + kMarkTestStartXFieldNumber = 19, + kMarkTestStartYFieldNumber = 20, + kMarkTestEndXFieldNumber = 21, + kMarkTestEndYFieldNumber = 22, + }; + // int32 debugShape = 1; + void clear_debugshape() ; + ::int32_t debugshape() const; + void set_debugshape(::int32_t value); + + private: + ::int32_t _internal_debugshape() const; + void _internal_set_debugshape(::int32_t value); + + public: + // int32 shapeSize = 2; + void clear_shapesize() ; + ::int32_t shapesize() const; + void set_shapesize(::int32_t value); + + private: + ::int32_t _internal_shapesize() const; + void _internal_set_shapesize(::int32_t value); + + public: + // int32 shapeSizeMin = 3; + void clear_shapesizemin() ; + ::int32_t shapesizemin() const; + void set_shapesizemin(::int32_t value); + + private: + ::int32_t _internal_shapesizemin() const; + void _internal_set_shapesizemin(::int32_t value); + + public: + // int32 shape_size_max = 4; + void clear_shape_size_max() ; + ::int32_t shape_size_max() const; + void set_shape_size_max(::int32_t value); + + private: + ::int32_t _internal_shape_size_max() const; + void _internal_set_shape_size_max(::int32_t value); + + public: + // int32 laser_power = 5; + void clear_laser_power() ; + ::int32_t laser_power() const; + void set_laser_power(::int32_t value); + + private: + ::int32_t _internal_laser_power() const; + void _internal_set_laser_power(::int32_t value); + + public: + // int32 laser_power_min = 6; + void clear_laser_power_min() ; + ::int32_t laser_power_min() const; + void set_laser_power_min(::int32_t value); + + private: + ::int32_t _internal_laser_power_min() const; + void _internal_set_laser_power_min(::int32_t value); + + public: + // double defocus = 8; + void clear_defocus() ; + double defocus() const; + void set_defocus(double value); + + private: + double _internal_defocus() const; + void _internal_set_defocus(double value); + + public: + // double defocus_min = 9; + void clear_defocus_min() ; + double defocus_min() const; + void set_defocus_min(double value); + + private: + double _internal_defocus_min() const; + void _internal_set_defocus_min(double value); + + public: + // double defocus_max = 10; + void clear_defocus_max() ; + double defocus_max() const; + void set_defocus_max(double value); + + private: + double _internal_defocus_max() const; + void _internal_set_defocus_max(double value); + + public: + // int32 laser_power_max = 7; + void clear_laser_power_max() ; + ::int32_t laser_power_max() const; + void set_laser_power_max(::int32_t value); + + private: + ::int32_t _internal_laser_power_max() const; + void _internal_set_laser_power_max(::int32_t value); + + public: + // bool is_cycle = 11; + void clear_is_cycle() ; + bool is_cycle() const; + void set_is_cycle(bool value); + + private: + bool _internal_is_cycle() const; + void _internal_set_is_cycle(bool value); + + public: + // bool isAutoHeatingScanner = 15; + void clear_isautoheatingscanner() ; + bool isautoheatingscanner() const; + void set_isautoheatingscanner(bool value); + + private: + bool _internal_isautoheatingscanner() const; + void _internal_set_isautoheatingscanner(bool value); + + public: + // double cross_x = 12; + void clear_cross_x() ; + double cross_x() const; + void set_cross_x(double value); + + private: + double _internal_cross_x() const; + void _internal_set_cross_x(double value); + + public: + // double cross_y = 13; + void clear_cross_y() ; + double cross_y() const; + void set_cross_y(double value); + + private: + double _internal_cross_y() const; + void _internal_set_cross_y(double value); + + public: + // double z_distance = 14; + void clear_z_distance() ; + double z_distance() const; + void set_z_distance(double value); + + private: + double _internal_z_distance() const; + void _internal_set_z_distance(double value); + + public: + // uint32 autoHeatingScannerMinutes = 16; + void clear_autoheatingscannerminutes() ; + ::uint32_t autoheatingscannerminutes() const; + void set_autoheatingscannerminutes(::uint32_t value); + + private: + ::uint32_t _internal_autoheatingscannerminutes() const; + void _internal_set_autoheatingscannerminutes(::uint32_t value); + + public: + // uint32 autoHeatingScannerSize = 17; + void clear_autoheatingscannersize() ; + ::uint32_t autoheatingscannersize() const; + void set_autoheatingscannersize(::uint32_t value); + + private: + ::uint32_t _internal_autoheatingscannersize() const; + void _internal_set_autoheatingscannersize(::uint32_t value); + + public: + // double autoHeatingScannerSpeed = 18; + void clear_autoheatingscannerspeed() ; + double autoheatingscannerspeed() const; + void set_autoheatingscannerspeed(double value); + + private: + double _internal_autoheatingscannerspeed() const; + void _internal_set_autoheatingscannerspeed(double value); + + public: + // double mark_test_start_x = 19; + void clear_mark_test_start_x() ; + double mark_test_start_x() const; + void set_mark_test_start_x(double value); + + private: + double _internal_mark_test_start_x() const; + void _internal_set_mark_test_start_x(double value); + + public: + // double mark_test_start_y = 20; + void clear_mark_test_start_y() ; + double mark_test_start_y() const; + void set_mark_test_start_y(double value); + + private: + double _internal_mark_test_start_y() const; + void _internal_set_mark_test_start_y(double value); + + public: + // double mark_test_end_x = 21; + void clear_mark_test_end_x() ; + double mark_test_end_x() const; + void set_mark_test_end_x(double value); + + private: + double _internal_mark_test_end_x() const; + void _internal_set_mark_test_end_x(double value); + + public: + // double mark_test_end_y = 22; + void clear_mark_test_end_y() ; + double mark_test_end_y() const; + void set_mark_test_end_y(double value); + + private: + double _internal_mark_test_end_y() const; + void _internal_set_mark_test_end_y(double value); + + public: + // @@protoc_insertion_point(class_scope:stream.ScanTestCfg) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 22, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t debugshape_; + ::int32_t shapesize_; + ::int32_t shapesizemin_; + ::int32_t shape_size_max_; + ::int32_t laser_power_; + ::int32_t laser_power_min_; + double defocus_; + double defocus_min_; + double defocus_max_; + ::int32_t laser_power_max_; + bool is_cycle_; + bool isautoheatingscanner_; + double cross_x_; + double cross_y_; + double z_distance_; + ::uint32_t autoheatingscannerminutes_; + ::uint32_t autoheatingscannersize_; + double autoheatingscannerspeed_; + double mark_test_start_x_; + double mark_test_start_y_; + double mark_test_end_x_; + double mark_test_end_y_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class SkyWritingCfg final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.SkyWritingCfg) */ { + public: + inline SkyWritingCfg() : SkyWritingCfg(nullptr) {} + ~SkyWritingCfg() override; + template + explicit PROTOBUF_CONSTEXPR SkyWritingCfg(::google::protobuf::internal::ConstantInitialized); + + SkyWritingCfg(const SkyWritingCfg& from); + SkyWritingCfg(SkyWritingCfg&& from) noexcept + : SkyWritingCfg() { + *this = ::std::move(from); + } + + inline SkyWritingCfg& operator=(const SkyWritingCfg& from) { + CopyFrom(from); + return *this; + } + inline SkyWritingCfg& operator=(SkyWritingCfg&& 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 SkyWritingCfg& default_instance() { + return *internal_default_instance(); + } + static inline const SkyWritingCfg* internal_default_instance() { + return reinterpret_cast( + &_SkyWritingCfg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(SkyWritingCfg& a, SkyWritingCfg& b) { + a.Swap(&b); + } + inline void Swap(SkyWritingCfg* 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(SkyWritingCfg* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SkyWritingCfg* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SkyWritingCfg& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const SkyWritingCfg& from) { + SkyWritingCfg::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(SkyWritingCfg* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.SkyWritingCfg"; + } + protected: + explicit SkyWritingCfg(::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 { + kTimelagFieldNumber = 2, + kTimelagMinFieldNumber = 3, + kTimelagMaxFieldNumber = 4, + kIsEnableFieldNumber = 1, + kNprevFieldNumber = 8, + kLaserOnShiftFieldNumber = 5, + kLaserOnShiftMinFieldNumber = 6, + kLaserOnShiftMaxFieldNumber = 7, + kNprevMinFieldNumber = 9, + kNprevMaxFieldNumber = 10, + kNpostFieldNumber = 11, + kNpostMinFieldNumber = 12, + kNpostMaxFieldNumber = 13, + kModeFieldNumber = 14, + kLimiteFieldNumber = 15, + kLimiteMinFieldNumber = 16, + kLimiteMaxFieldNumber = 17, + }; + // double timelag = 2; + void clear_timelag() ; + double timelag() const; + void set_timelag(double value); + + private: + double _internal_timelag() const; + void _internal_set_timelag(double value); + + public: + // double timelagMin = 3; + void clear_timelagmin() ; + double timelagmin() const; + void set_timelagmin(double value); + + private: + double _internal_timelagmin() const; + void _internal_set_timelagmin(double value); + + public: + // double timelagMax = 4; + void clear_timelagmax() ; + double timelagmax() const; + void set_timelagmax(double value); + + private: + double _internal_timelagmax() const; + void _internal_set_timelagmax(double value); + + public: + // bool isEnable = 1; + void clear_isenable() ; + bool isenable() const; + void set_isenable(bool value); + + private: + bool _internal_isenable() const; + void _internal_set_isenable(bool value); + + public: + // uint32 nprev = 8; + void clear_nprev() ; + ::uint32_t nprev() const; + void set_nprev(::uint32_t value); + + private: + ::uint32_t _internal_nprev() const; + void _internal_set_nprev(::uint32_t value); + + public: + // int64 laserOnShift = 5; + void clear_laseronshift() ; + ::int64_t laseronshift() const; + void set_laseronshift(::int64_t value); + + private: + ::int64_t _internal_laseronshift() const; + void _internal_set_laseronshift(::int64_t value); + + public: + // int64 laserOnShiftMin = 6; + void clear_laseronshiftmin() ; + ::int64_t laseronshiftmin() const; + void set_laseronshiftmin(::int64_t value); + + private: + ::int64_t _internal_laseronshiftmin() const; + void _internal_set_laseronshiftmin(::int64_t value); + + public: + // int64 laserOnShiftMax = 7; + void clear_laseronshiftmax() ; + ::int64_t laseronshiftmax() const; + void set_laseronshiftmax(::int64_t value); + + private: + ::int64_t _internal_laseronshiftmax() const; + void _internal_set_laseronshiftmax(::int64_t value); + + public: + // uint32 nprevMin = 9; + void clear_nprevmin() ; + ::uint32_t nprevmin() const; + void set_nprevmin(::uint32_t value); + + private: + ::uint32_t _internal_nprevmin() const; + void _internal_set_nprevmin(::uint32_t value); + + public: + // uint32 nprevMax = 10; + void clear_nprevmax() ; + ::uint32_t nprevmax() const; + void set_nprevmax(::uint32_t value); + + private: + ::uint32_t _internal_nprevmax() const; + void _internal_set_nprevmax(::uint32_t value); + + public: + // uint32 npost = 11; + void clear_npost() ; + ::uint32_t npost() const; + void set_npost(::uint32_t value); + + private: + ::uint32_t _internal_npost() const; + void _internal_set_npost(::uint32_t value); + + public: + // uint32 npostMin = 12; + void clear_npostmin() ; + ::uint32_t npostmin() const; + void set_npostmin(::uint32_t value); + + private: + ::uint32_t _internal_npostmin() const; + void _internal_set_npostmin(::uint32_t value); + + public: + // uint32 npostMax = 13; + void clear_npostmax() ; + ::uint32_t npostmax() const; + void set_npostmax(::uint32_t value); + + private: + ::uint32_t _internal_npostmax() const; + void _internal_set_npostmax(::uint32_t value); + + public: + // int32 mode = 14; + void clear_mode() ; + ::int32_t mode() const; + void set_mode(::int32_t value); + + private: + ::int32_t _internal_mode() const; + void _internal_set_mode(::int32_t value); + + public: + // double limite = 15; + void clear_limite() ; + double limite() const; + void set_limite(double value); + + private: + double _internal_limite() const; + void _internal_set_limite(double value); + + public: + // double limiteMin = 16; + void clear_limitemin() ; + double limitemin() const; + void set_limitemin(double value); + + private: + double _internal_limitemin() const; + void _internal_set_limitemin(double value); + + public: + // double limiteMax = 17; + void clear_limitemax() ; + double limitemax() const; + void set_limitemax(double value); + + private: + double _internal_limitemax() const; + void _internal_set_limitemax(double value); + + public: + // @@protoc_insertion_point(class_scope:stream.SkyWritingCfg) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 17, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + double timelag_; + double timelagmin_; + double timelagmax_; + bool isenable_; + ::uint32_t nprev_; + ::int64_t laseronshift_; + ::int64_t laseronshiftmin_; + ::int64_t laseronshiftmax_; + ::uint32_t nprevmin_; + ::uint32_t nprevmax_; + ::uint32_t npost_; + ::uint32_t npostmin_; + ::uint32_t npostmax_; + ::int32_t mode_; + double limite_; + double limitemin_; + double limitemax_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class PowerCompensate final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.PowerCompensate) */ { + public: + inline PowerCompensate() : PowerCompensate(nullptr) {} + ~PowerCompensate() override; + template + explicit PROTOBUF_CONSTEXPR PowerCompensate(::google::protobuf::internal::ConstantInitialized); + + PowerCompensate(const PowerCompensate& from); + PowerCompensate(PowerCompensate&& from) noexcept + : PowerCompensate() { + *this = ::std::move(from); + } + + inline PowerCompensate& operator=(const PowerCompensate& from) { + CopyFrom(from); + return *this; + } + inline PowerCompensate& operator=(PowerCompensate&& 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 PowerCompensate& default_instance() { + return *internal_default_instance(); + } + static inline const PowerCompensate* internal_default_instance() { + return reinterpret_cast( + &_PowerCompensate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(PowerCompensate& a, PowerCompensate& b) { + a.Swap(&b); + } + inline void Swap(PowerCompensate* 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(PowerCompensate* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PowerCompensate* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const PowerCompensate& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const PowerCompensate& from) { + PowerCompensate::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(PowerCompensate* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.PowerCompensate"; + } + protected: + explicit PowerCompensate(::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 { + kCnoFieldNumber = 1, + kPercentFieldNumber = 2, + kValueFieldNumber = 3, + kValueMinFieldNumber = 4, + kValueMaxFieldNumber = 5, + }; + // int32 cno = 1; + void clear_cno() ; + ::int32_t cno() const; + void set_cno(::int32_t value); + + private: + ::int32_t _internal_cno() const; + void _internal_set_cno(::int32_t value); + + public: + // int32 percent = 2; + void clear_percent() ; + ::int32_t percent() const; + void set_percent(::int32_t value); + + private: + ::int32_t _internal_percent() const; + void _internal_set_percent(::int32_t value); + + public: + // float value = 3; + void clear_value() ; + float value() const; + void set_value(float value); + + private: + float _internal_value() const; + void _internal_set_value(float value); + + public: + // float value_min = 4; + void clear_value_min() ; + float value_min() const; + void set_value_min(float value); + + private: + float _internal_value_min() const; + void _internal_set_value_min(float value); + + public: + // float value_max = 5; + void clear_value_max() ; + float value_max() const; + void set_value_max(float value); + + private: + float _internal_value_max() const; + void _internal_set_value_max(float value); + + public: + // @@protoc_insertion_point(class_scope:stream.PowerCompensate) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t cno_; + ::int32_t percent_; + float value_; + float value_min_; + float value_max_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class TimePowerCompensate final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.TimePowerCompensate) */ { + public: + inline TimePowerCompensate() : TimePowerCompensate(nullptr) {} + ~TimePowerCompensate() override; + template + explicit PROTOBUF_CONSTEXPR TimePowerCompensate(::google::protobuf::internal::ConstantInitialized); + + TimePowerCompensate(const TimePowerCompensate& from); + TimePowerCompensate(TimePowerCompensate&& from) noexcept + : TimePowerCompensate() { + *this = ::std::move(from); + } + + inline TimePowerCompensate& operator=(const TimePowerCompensate& from) { + CopyFrom(from); + return *this; + } + inline TimePowerCompensate& operator=(TimePowerCompensate&& 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 TimePowerCompensate& default_instance() { + return *internal_default_instance(); + } + static inline const TimePowerCompensate* internal_default_instance() { + return reinterpret_cast( + &_TimePowerCompensate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(TimePowerCompensate& a, TimePowerCompensate& b) { + a.Swap(&b); + } + inline void Swap(TimePowerCompensate* 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(TimePowerCompensate* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TimePowerCompensate* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const TimePowerCompensate& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const TimePowerCompensate& from) { + TimePowerCompensate::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(TimePowerCompensate* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.TimePowerCompensate"; + } + protected: + explicit TimePowerCompensate(::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 { + kIdFieldNumber = 1, + kCnoFieldNumber = 2, + kStartMinuteFieldNumber = 3, + kEndMinuteFieldNumber = 4, + kCompensateFieldNumber = 5, + }; + // int32 id = 1; + void clear_id() ; + ::int32_t id() const; + void set_id(::int32_t value); + + private: + ::int32_t _internal_id() const; + void _internal_set_id(::int32_t value); + + public: + // int32 cno = 2; + void clear_cno() ; + ::int32_t cno() const; + void set_cno(::int32_t value); + + private: + ::int32_t _internal_cno() const; + void _internal_set_cno(::int32_t value); + + public: + // uint32 startMinute = 3; + void clear_startminute() ; + ::uint32_t startminute() const; + void set_startminute(::uint32_t value); + + private: + ::uint32_t _internal_startminute() const; + void _internal_set_startminute(::uint32_t value); + + public: + // uint32 endMinute = 4; + void clear_endminute() ; + ::uint32_t endminute() const; + void set_endminute(::uint32_t value); + + private: + ::uint32_t _internal_endminute() const; + void _internal_set_endminute(::uint32_t value); + + public: + // float compensate = 5; + void clear_compensate() ; + float compensate() const; + void set_compensate(float value); + + private: + float _internal_compensate() const; + void _internal_set_compensate(float value); + + public: + // @@protoc_insertion_point(class_scope:stream.TimePowerCompensate) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t id_; + ::int32_t cno_; + ::uint32_t startminute_; + ::uint32_t endminute_; + float compensate_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; }; // =================================================================== @@ -2873,6 +5962,240 @@ inline void ParamInfo::_internal_set_powder(float value) { _impl_.powder_ = value; } +// int32 seqNo = 11; +inline void ParamInfo::clear_seqno() { + _impl_.seqno_ = 0; +} +inline ::int32_t ParamInfo::seqno() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.seqNo) + return _internal_seqno(); +} +inline void ParamInfo::set_seqno(::int32_t value) { + _internal_set_seqno(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.seqNo) +} +inline ::int32_t ParamInfo::_internal_seqno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.seqno_; +} +inline void ParamInfo::_internal_set_seqno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.seqno_ = value; +} + +// int32 controlNo = 12; +inline void ParamInfo::clear_controlno() { + _impl_.controlno_ = 0; +} +inline ::int32_t ParamInfo::controlno() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.controlNo) + return _internal_controlno(); +} +inline void ParamInfo::set_controlno(::int32_t value) { + _internal_set_controlno(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.controlNo) +} +inline ::int32_t ParamInfo::_internal_controlno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.controlno_; +} +inline void ParamInfo::_internal_set_controlno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.controlno_ = value; +} + +// int32 serialNo = 13; +inline void ParamInfo::clear_serialno() { + _impl_.serialno_ = 0; +} +inline ::int32_t ParamInfo::serialno() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.serialNo) + return _internal_serialno(); +} +inline void ParamInfo::set_serialno(::int32_t value) { + _internal_set_serialno(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.serialNo) +} +inline ::int32_t ParamInfo::_internal_serialno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.serialno_; +} +inline void ParamInfo::_internal_set_serialno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.serialno_ = value; +} + +// int32 controlType = 14; +inline void ParamInfo::clear_controltype() { + _impl_.controltype_ = 0; +} +inline ::int32_t ParamInfo::controltype() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.controlType) + return _internal_controltype(); +} +inline void ParamInfo::set_controltype(::int32_t value) { + _internal_set_controltype(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.controlType) +} +inline ::int32_t ParamInfo::_internal_controltype() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.controltype_; +} +inline void ParamInfo::_internal_set_controltype(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.controltype_ = value; +} + +// bytes cardName = 15; +inline void ParamInfo::clear_cardname() { + _impl_.cardname_.ClearToEmpty(); +} +inline const std::string& ParamInfo::cardname() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.cardName) + return _internal_cardname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ParamInfo::set_cardname(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardname_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:stream.ParamInfo.cardName) +} +inline std::string* ParamInfo::mutable_cardname() { + std::string* _s = _internal_mutable_cardname(); + // @@protoc_insertion_point(field_mutable:stream.ParamInfo.cardName) + return _s; +} +inline const std::string& ParamInfo::_internal_cardname() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cardname_.Get(); +} +inline void ParamInfo::_internal_set_cardname(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardname_.Set(value, GetArenaForAllocation()); +} +inline std::string* ParamInfo::_internal_mutable_cardname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.cardname_.Mutable( GetArenaForAllocation()); +} +inline std::string* ParamInfo::release_cardname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ParamInfo.cardName) + return _impl_.cardname_.Release(); +} +inline void ParamInfo::set_allocated_cardname(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.cardname_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.cardname_.IsDefault()) { + _impl_.cardname_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:stream.ParamInfo.cardName) +} + +// bytes cardIP = 16; +inline void ParamInfo::clear_cardip() { + _impl_.cardip_.ClearToEmpty(); +} +inline const std::string& ParamInfo::cardip() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.cardIP) + return _internal_cardip(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ParamInfo::set_cardip(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardip_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:stream.ParamInfo.cardIP) +} +inline std::string* ParamInfo::mutable_cardip() { + std::string* _s = _internal_mutable_cardip(); + // @@protoc_insertion_point(field_mutable:stream.ParamInfo.cardIP) + return _s; +} +inline const std::string& ParamInfo::_internal_cardip() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cardip_.Get(); +} +inline void ParamInfo::_internal_set_cardip(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardip_.Set(value, GetArenaForAllocation()); +} +inline std::string* ParamInfo::_internal_mutable_cardip() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.cardip_.Mutable( GetArenaForAllocation()); +} +inline std::string* ParamInfo::release_cardip() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ParamInfo.cardIP) + return _impl_.cardip_.Release(); +} +inline void ParamInfo::set_allocated_cardip(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.cardip_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.cardip_.IsDefault()) { + _impl_.cardip_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:stream.ParamInfo.cardIP) +} + +// bool hadAssign = 17; +inline void ParamInfo::clear_hadassign() { + _impl_.hadassign_ = false; +} +inline bool ParamInfo::hadassign() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.hadAssign) + return _internal_hadassign(); +} +inline void ParamInfo::set_hadassign(bool value) { + _internal_set_hadassign(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.hadAssign) +} +inline bool ParamInfo::_internal_hadassign() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.hadassign_; +} +inline void ParamInfo::_internal_set_hadassign(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.hadassign_ = value; +} + +// bool hadMatch = 18; +inline void ParamInfo::clear_hadmatch() { + _impl_.hadmatch_ = false; +} +inline bool ParamInfo::hadmatch() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.hadMatch) + return _internal_hadmatch(); +} +inline void ParamInfo::set_hadmatch(bool value) { + _internal_set_hadmatch(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.hadMatch) +} +inline bool ParamInfo::_internal_hadmatch() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.hadmatch_; +} +inline void ParamInfo::_internal_set_hadmatch(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.hadmatch_ = value; +} + // ------------------------------------------------------------------- // RequestInfo @@ -3966,6 +7289,3574 @@ inline void ComResponce::set_allocated_data(std::string* value) { // @@protoc_insertion_point(field_set_allocated:stream.ComResponce.data) } +// ------------------------------------------------------------------- + +// ScannerCrtlCfgResp + +// repeated .stream.ScannerCrtlCfgData scannerCfg = 1; +inline int ScannerCrtlCfgResp::_internal_scannercfg_size() const { + return _internal_scannercfg().size(); +} +inline int ScannerCrtlCfgResp::scannercfg_size() const { + return _internal_scannercfg_size(); +} +inline void ScannerCrtlCfgResp::clear_scannercfg() { + _internal_mutable_scannercfg()->Clear(); +} +inline ::stream::ScannerCrtlCfgData* ScannerCrtlCfgResp::mutable_scannercfg(int index) { + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgResp.scannerCfg) + return _internal_mutable_scannercfg()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >* +ScannerCrtlCfgResp::mutable_scannercfg() { + // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgResp.scannerCfg) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_scannercfg(); +} +inline const ::stream::ScannerCrtlCfgData& ScannerCrtlCfgResp::scannercfg(int index) const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgResp.scannerCfg) + return _internal_scannercfg().Get(index); +} +inline ::stream::ScannerCrtlCfgData* ScannerCrtlCfgResp::add_scannercfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::ScannerCrtlCfgData* _add = _internal_mutable_scannercfg()->Add(); + // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgResp.scannerCfg) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >& +ScannerCrtlCfgResp::scannercfg() const { + // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgResp.scannerCfg) + return _internal_scannercfg(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>& +ScannerCrtlCfgResp::_internal_scannercfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scannercfg_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>* +ScannerCrtlCfgResp::_internal_mutable_scannercfg() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.scannercfg_; +} + +// ------------------------------------------------------------------- + +// ScannerCrtlCfgData + +// int32 seqNo = 1; +inline void ScannerCrtlCfgData::clear_seqno() { + _impl_.seqno_ = 0; +} +inline ::int32_t ScannerCrtlCfgData::seqno() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.seqNo) + return _internal_seqno(); +} +inline void ScannerCrtlCfgData::set_seqno(::int32_t value) { + _internal_set_seqno(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.seqNo) +} +inline ::int32_t ScannerCrtlCfgData::_internal_seqno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.seqno_; +} +inline void ScannerCrtlCfgData::_internal_set_seqno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.seqno_ = value; +} + +// repeated .stream.FixPointData fixPointData = 2; +inline int ScannerCrtlCfgData::_internal_fixpointdata_size() const { + return _internal_fixpointdata().size(); +} +inline int ScannerCrtlCfgData::fixpointdata_size() const { + return _internal_fixpointdata_size(); +} +inline void ScannerCrtlCfgData::clear_fixpointdata() { + _internal_mutable_fixpointdata()->Clear(); +} +inline ::stream::FixPointData* ScannerCrtlCfgData::mutable_fixpointdata(int index) { + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.fixPointData) + return _internal_mutable_fixpointdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >* +ScannerCrtlCfgData::mutable_fixpointdata() { + // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.fixPointData) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_fixpointdata(); +} +inline const ::stream::FixPointData& ScannerCrtlCfgData::fixpointdata(int index) const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.fixPointData) + return _internal_fixpointdata().Get(index); +} +inline ::stream::FixPointData* ScannerCrtlCfgData::add_fixpointdata() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::FixPointData* _add = _internal_mutable_fixpointdata()->Add(); + // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.fixPointData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >& +ScannerCrtlCfgData::fixpointdata() const { + // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.fixPointData) + return _internal_fixpointdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::FixPointData>& +ScannerCrtlCfgData::_internal_fixpointdata() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.fixpointdata_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::FixPointData>* +ScannerCrtlCfgData::_internal_mutable_fixpointdata() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.fixpointdata_; +} + +// .stream.ScanParamCfg scanParamCfg = 3; +inline bool ScannerCrtlCfgData::has_scanparamcfg() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.scanparamcfg_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_scanparamcfg() { + if (_impl_.scanparamcfg_ != nullptr) _impl_.scanparamcfg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_scanparamcfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanParamCfg* p = _impl_.scanparamcfg_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanParamCfg_default_instance_); +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::scanparamcfg() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.scanParamCfg) + return _internal_scanparamcfg(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_scanparamcfg(::stream::ScanParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scanparamcfg_); + } + _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.scanParamCfg) +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_scanparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::stream::ScanParamCfg* released = _impl_.scanparamcfg_; + _impl_.scanparamcfg_ = 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 ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_scanparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.scanParamCfg) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::stream::ScanParamCfg* temp = _impl_.scanparamcfg_; + _impl_.scanparamcfg_ = nullptr; + return temp; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_scanparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.scanparamcfg_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation()); + _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(p); + } + return _impl_.scanparamcfg_; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_scanparamcfg() { + ::stream::ScanParamCfg* _msg = _internal_mutable_scanparamcfg(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.scanParamCfg) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_scanparamcfg(::stream::ScanParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.scanparamcfg_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(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_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.scanParamCfg) +} + +// .stream.ScanParamCfg hatchingParams = 4; +inline bool ScannerCrtlCfgData::has_hatchingparams() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.hatchingparams_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_hatchingparams() { + if (_impl_.hatchingparams_ != nullptr) _impl_.hatchingparams_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_hatchingparams() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanParamCfg* p = _impl_.hatchingparams_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanParamCfg_default_instance_); +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::hatchingparams() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hatchingParams) + return _internal_hatchingparams(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_hatchingparams(::stream::ScanParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hatchingparams_); + } + _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.hatchingParams) +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_hatchingparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000002u; + ::stream::ScanParamCfg* released = _impl_.hatchingparams_; + _impl_.hatchingparams_ = 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 ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_hatchingparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.hatchingParams) + + _impl_._has_bits_[0] &= ~0x00000002u; + ::stream::ScanParamCfg* temp = _impl_.hatchingparams_; + _impl_.hatchingparams_ = nullptr; + return temp; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_hatchingparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.hatchingparams_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation()); + _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p); + } + return _impl_.hatchingparams_; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_hatchingparams() { + ::stream::ScanParamCfg* _msg = _internal_mutable_hatchingparams(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.hatchingParams) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_hatchingparams(::stream::ScanParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.hatchingparams_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + + _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.hatchingParams) +} + +// .stream.ScanParamCfg borderParams = 5; +inline bool ScannerCrtlCfgData::has_borderparams() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.borderparams_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_borderparams() { + if (_impl_.borderparams_ != nullptr) _impl_.borderparams_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_borderparams() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanParamCfg* p = _impl_.borderparams_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanParamCfg_default_instance_); +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::borderparams() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.borderParams) + return _internal_borderparams(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_borderparams(::stream::ScanParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.borderparams_); + } + _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.borderParams) +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_borderparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000004u; + ::stream::ScanParamCfg* released = _impl_.borderparams_; + _impl_.borderparams_ = 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 ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_borderparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.borderParams) + + _impl_._has_bits_[0] &= ~0x00000004u; + ::stream::ScanParamCfg* temp = _impl_.borderparams_; + _impl_.borderparams_ = nullptr; + return temp; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_borderparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.borderparams_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation()); + _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p); + } + return _impl_.borderparams_; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_borderparams() { + ::stream::ScanParamCfg* _msg = _internal_mutable_borderparams(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.borderParams) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_borderparams(::stream::ScanParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.borderparams_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + + _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.borderParams) +} + +// .stream.ScanParamCfg supportParams = 6; +inline bool ScannerCrtlCfgData::has_supportparams() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.supportparams_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_supportparams() { + if (_impl_.supportparams_ != nullptr) _impl_.supportparams_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_supportparams() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanParamCfg* p = _impl_.supportparams_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanParamCfg_default_instance_); +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::supportparams() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.supportParams) + return _internal_supportparams(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_supportparams(::stream::ScanParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.supportparams_); + } + _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.supportParams) +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_supportparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000008u; + ::stream::ScanParamCfg* released = _impl_.supportparams_; + _impl_.supportparams_ = 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 ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_supportparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.supportParams) + + _impl_._has_bits_[0] &= ~0x00000008u; + ::stream::ScanParamCfg* temp = _impl_.supportparams_; + _impl_.supportparams_ = nullptr; + return temp; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_supportparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.supportparams_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation()); + _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p); + } + return _impl_.supportparams_; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_supportparams() { + ::stream::ScanParamCfg* _msg = _internal_mutable_supportparams(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.supportParams) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_supportparams(::stream::ScanParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.supportparams_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + + _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.supportParams) +} + +// .stream.CorrectParamCfg correctParamCfg = 7; +inline bool ScannerCrtlCfgData::has_correctparamcfg() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.correctparamcfg_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_correctparamcfg() { + if (_impl_.correctparamcfg_ != nullptr) _impl_.correctparamcfg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::stream::CorrectParamCfg& ScannerCrtlCfgData::_internal_correctparamcfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::CorrectParamCfg* p = _impl_.correctparamcfg_; + return p != nullptr ? *p : reinterpret_cast(::stream::_CorrectParamCfg_default_instance_); +} +inline const ::stream::CorrectParamCfg& ScannerCrtlCfgData::correctparamcfg() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.correctParamCfg) + return _internal_correctparamcfg(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_correctparamcfg(::stream::CorrectParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.correctparamcfg_); + } + _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.correctParamCfg) +} +inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::release_correctparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000010u; + ::stream::CorrectParamCfg* released = _impl_.correctparamcfg_; + _impl_.correctparamcfg_ = 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 ::stream::CorrectParamCfg* ScannerCrtlCfgData::unsafe_arena_release_correctparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.correctParamCfg) + + _impl_._has_bits_[0] &= ~0x00000010u; + ::stream::CorrectParamCfg* temp = _impl_.correctparamcfg_; + _impl_.correctparamcfg_ = nullptr; + return temp; +} +inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::_internal_mutable_correctparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.correctparamcfg_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::CorrectParamCfg>(GetArenaForAllocation()); + _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(p); + } + return _impl_.correctparamcfg_; +} +inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::mutable_correctparamcfg() { + ::stream::CorrectParamCfg* _msg = _internal_mutable_correctparamcfg(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.correctParamCfg) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_correctparamcfg(::stream::CorrectParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::CorrectParamCfg*>(_impl_.correctparamcfg_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::CorrectParamCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + + _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.correctParamCfg) +} + +// .stream.ScanTestCfg scanTestCfg = 8; +inline bool ScannerCrtlCfgData::has_scantestcfg() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.scantestcfg_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_scantestcfg() { + if (_impl_.scantestcfg_ != nullptr) _impl_.scantestcfg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::stream::ScanTestCfg& ScannerCrtlCfgData::_internal_scantestcfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanTestCfg* p = _impl_.scantestcfg_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanTestCfg_default_instance_); +} +inline const ::stream::ScanTestCfg& ScannerCrtlCfgData::scantestcfg() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.scanTestCfg) + return _internal_scantestcfg(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_scantestcfg(::stream::ScanTestCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scantestcfg_); + } + _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.scanTestCfg) +} +inline ::stream::ScanTestCfg* ScannerCrtlCfgData::release_scantestcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000020u; + ::stream::ScanTestCfg* released = _impl_.scantestcfg_; + _impl_.scantestcfg_ = 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 ::stream::ScanTestCfg* ScannerCrtlCfgData::unsafe_arena_release_scantestcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.scanTestCfg) + + _impl_._has_bits_[0] &= ~0x00000020u; + ::stream::ScanTestCfg* temp = _impl_.scantestcfg_; + _impl_.scantestcfg_ = nullptr; + return temp; +} +inline ::stream::ScanTestCfg* ScannerCrtlCfgData::_internal_mutable_scantestcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.scantestcfg_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanTestCfg>(GetArenaForAllocation()); + _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(p); + } + return _impl_.scantestcfg_; +} +inline ::stream::ScanTestCfg* ScannerCrtlCfgData::mutable_scantestcfg() { + ::stream::ScanTestCfg* _msg = _internal_mutable_scantestcfg(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.scanTestCfg) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_scantestcfg(::stream::ScanTestCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanTestCfg*>(_impl_.scantestcfg_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanTestCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + + _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.scanTestCfg) +} + +// .stream.SkyWritingCfg skyWritingCfg = 9; +inline bool ScannerCrtlCfgData::has_skywritingcfg() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.skywritingcfg_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_skywritingcfg() { + if (_impl_.skywritingcfg_ != nullptr) _impl_.skywritingcfg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const ::stream::SkyWritingCfg& ScannerCrtlCfgData::_internal_skywritingcfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::SkyWritingCfg* p = _impl_.skywritingcfg_; + return p != nullptr ? *p : reinterpret_cast(::stream::_SkyWritingCfg_default_instance_); +} +inline const ::stream::SkyWritingCfg& ScannerCrtlCfgData::skywritingcfg() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.skyWritingCfg) + return _internal_skywritingcfg(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_skywritingcfg(::stream::SkyWritingCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.skywritingcfg_); + } + _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.skyWritingCfg) +} +inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::release_skywritingcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000040u; + ::stream::SkyWritingCfg* released = _impl_.skywritingcfg_; + _impl_.skywritingcfg_ = 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 ::stream::SkyWritingCfg* ScannerCrtlCfgData::unsafe_arena_release_skywritingcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.skyWritingCfg) + + _impl_._has_bits_[0] &= ~0x00000040u; + ::stream::SkyWritingCfg* temp = _impl_.skywritingcfg_; + _impl_.skywritingcfg_ = nullptr; + return temp; +} +inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::_internal_mutable_skywritingcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000040u; + if (_impl_.skywritingcfg_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::SkyWritingCfg>(GetArenaForAllocation()); + _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(p); + } + return _impl_.skywritingcfg_; +} +inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::mutable_skywritingcfg() { + ::stream::SkyWritingCfg* _msg = _internal_mutable_skywritingcfg(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.skyWritingCfg) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_skywritingcfg(::stream::SkyWritingCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::SkyWritingCfg*>(_impl_.skywritingcfg_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::SkyWritingCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + + _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.skyWritingCfg) +} + +// repeated .stream.PowerCompensate powerCompensate = 10; +inline int ScannerCrtlCfgData::_internal_powercompensate_size() const { + return _internal_powercompensate().size(); +} +inline int ScannerCrtlCfgData::powercompensate_size() const { + return _internal_powercompensate_size(); +} +inline void ScannerCrtlCfgData::clear_powercompensate() { + _internal_mutable_powercompensate()->Clear(); +} +inline ::stream::PowerCompensate* ScannerCrtlCfgData::mutable_powercompensate(int index) { + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.powerCompensate) + return _internal_mutable_powercompensate()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >* +ScannerCrtlCfgData::mutable_powercompensate() { + // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.powerCompensate) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_powercompensate(); +} +inline const ::stream::PowerCompensate& ScannerCrtlCfgData::powercompensate(int index) const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.powerCompensate) + return _internal_powercompensate().Get(index); +} +inline ::stream::PowerCompensate* ScannerCrtlCfgData::add_powercompensate() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::PowerCompensate* _add = _internal_mutable_powercompensate()->Add(); + // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.powerCompensate) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >& +ScannerCrtlCfgData::powercompensate() const { + // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.powerCompensate) + return _internal_powercompensate(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>& +ScannerCrtlCfgData::_internal_powercompensate() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.powercompensate_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>* +ScannerCrtlCfgData::_internal_mutable_powercompensate() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.powercompensate_; +} + +// repeated .stream.TimePowerCompensate tPowerCompensate = 11; +inline int ScannerCrtlCfgData::_internal_tpowercompensate_size() const { + return _internal_tpowercompensate().size(); +} +inline int ScannerCrtlCfgData::tpowercompensate_size() const { + return _internal_tpowercompensate_size(); +} +inline void ScannerCrtlCfgData::clear_tpowercompensate() { + _internal_mutable_tpowercompensate()->Clear(); +} +inline ::stream::TimePowerCompensate* ScannerCrtlCfgData::mutable_tpowercompensate(int index) { + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.tPowerCompensate) + return _internal_mutable_tpowercompensate()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >* +ScannerCrtlCfgData::mutable_tpowercompensate() { + // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.tPowerCompensate) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_tpowercompensate(); +} +inline const ::stream::TimePowerCompensate& ScannerCrtlCfgData::tpowercompensate(int index) const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.tPowerCompensate) + return _internal_tpowercompensate().Get(index); +} +inline ::stream::TimePowerCompensate* ScannerCrtlCfgData::add_tpowercompensate() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::TimePowerCompensate* _add = _internal_mutable_tpowercompensate()->Add(); + // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.tPowerCompensate) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >& +ScannerCrtlCfgData::tpowercompensate() const { + // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.tPowerCompensate) + return _internal_tpowercompensate(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>& +ScannerCrtlCfgData::_internal_tpowercompensate() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.tpowercompensate_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>* +ScannerCrtlCfgData::_internal_mutable_tpowercompensate() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.tpowercompensate_; +} + +// int32 controlNo = 12; +inline void ScannerCrtlCfgData::clear_controlno() { + _impl_.controlno_ = 0; +} +inline ::int32_t ScannerCrtlCfgData::controlno() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.controlNo) + return _internal_controlno(); +} +inline void ScannerCrtlCfgData::set_controlno(::int32_t value) { + _internal_set_controlno(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.controlNo) +} +inline ::int32_t ScannerCrtlCfgData::_internal_controlno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.controlno_; +} +inline void ScannerCrtlCfgData::_internal_set_controlno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.controlno_ = value; +} + +// int32 serialNo = 13; +inline void ScannerCrtlCfgData::clear_serialno() { + _impl_.serialno_ = 0; +} +inline ::int32_t ScannerCrtlCfgData::serialno() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.serialNo) + return _internal_serialno(); +} +inline void ScannerCrtlCfgData::set_serialno(::int32_t value) { + _internal_set_serialno(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.serialNo) +} +inline ::int32_t ScannerCrtlCfgData::_internal_serialno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.serialno_; +} +inline void ScannerCrtlCfgData::_internal_set_serialno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.serialno_ = value; +} + +// int32 controlType = 14; +inline void ScannerCrtlCfgData::clear_controltype() { + _impl_.controltype_ = 0; +} +inline ::int32_t ScannerCrtlCfgData::controltype() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.controlType) + return _internal_controltype(); +} +inline void ScannerCrtlCfgData::set_controltype(::int32_t value) { + _internal_set_controltype(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.controlType) +} +inline ::int32_t ScannerCrtlCfgData::_internal_controltype() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.controltype_; +} +inline void ScannerCrtlCfgData::_internal_set_controltype(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.controltype_ = value; +} + +// bytes cardName = 15; +inline void ScannerCrtlCfgData::clear_cardname() { + _impl_.cardname_.ClearToEmpty(); +} +inline const std::string& ScannerCrtlCfgData::cardname() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.cardName) + return _internal_cardname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ScannerCrtlCfgData::set_cardname(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardname_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.cardName) +} +inline std::string* ScannerCrtlCfgData::mutable_cardname() { + std::string* _s = _internal_mutable_cardname(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.cardName) + return _s; +} +inline const std::string& ScannerCrtlCfgData::_internal_cardname() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cardname_.Get(); +} +inline void ScannerCrtlCfgData::_internal_set_cardname(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardname_.Set(value, GetArenaForAllocation()); +} +inline std::string* ScannerCrtlCfgData::_internal_mutable_cardname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.cardname_.Mutable( GetArenaForAllocation()); +} +inline std::string* ScannerCrtlCfgData::release_cardname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.cardName) + return _impl_.cardname_.Release(); +} +inline void ScannerCrtlCfgData::set_allocated_cardname(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.cardname_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.cardname_.IsDefault()) { + _impl_.cardname_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.cardName) +} + +// bytes cardIP = 16; +inline void ScannerCrtlCfgData::clear_cardip() { + _impl_.cardip_.ClearToEmpty(); +} +inline const std::string& ScannerCrtlCfgData::cardip() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.cardIP) + return _internal_cardip(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ScannerCrtlCfgData::set_cardip(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardip_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.cardIP) +} +inline std::string* ScannerCrtlCfgData::mutable_cardip() { + std::string* _s = _internal_mutable_cardip(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.cardIP) + return _s; +} +inline const std::string& ScannerCrtlCfgData::_internal_cardip() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cardip_.Get(); +} +inline void ScannerCrtlCfgData::_internal_set_cardip(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardip_.Set(value, GetArenaForAllocation()); +} +inline std::string* ScannerCrtlCfgData::_internal_mutable_cardip() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.cardip_.Mutable( GetArenaForAllocation()); +} +inline std::string* ScannerCrtlCfgData::release_cardip() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.cardIP) + return _impl_.cardip_.Release(); +} +inline void ScannerCrtlCfgData::set_allocated_cardip(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.cardip_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.cardip_.IsDefault()) { + _impl_.cardip_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.cardIP) +} + +// bool isEnable = 17; +inline void ScannerCrtlCfgData::clear_isenable() { + _impl_.isenable_ = false; +} +inline bool ScannerCrtlCfgData::isenable() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.isEnable) + return _internal_isenable(); +} +inline void ScannerCrtlCfgData::set_isenable(bool value) { + _internal_set_isenable(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.isEnable) +} +inline bool ScannerCrtlCfgData::_internal_isenable() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.isenable_; +} +inline void ScannerCrtlCfgData::_internal_set_isenable(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.isenable_ = value; +} + +// bool hadAssign = 18; +inline void ScannerCrtlCfgData::clear_hadassign() { + _impl_.hadassign_ = false; +} +inline bool ScannerCrtlCfgData::hadassign() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hadAssign) + return _internal_hadassign(); +} +inline void ScannerCrtlCfgData::set_hadassign(bool value) { + _internal_set_hadassign(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.hadAssign) +} +inline bool ScannerCrtlCfgData::_internal_hadassign() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.hadassign_; +} +inline void ScannerCrtlCfgData::_internal_set_hadassign(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.hadassign_ = value; +} + +// bool hadMatch = 19; +inline void ScannerCrtlCfgData::clear_hadmatch() { + _impl_.hadmatch_ = false; +} +inline bool ScannerCrtlCfgData::hadmatch() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hadMatch) + return _internal_hadmatch(); +} +inline void ScannerCrtlCfgData::set_hadmatch(bool value) { + _internal_set_hadmatch(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.hadMatch) +} +inline bool ScannerCrtlCfgData::_internal_hadmatch() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.hadmatch_; +} +inline void ScannerCrtlCfgData::_internal_set_hadmatch(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.hadmatch_ = value; +} + +// ------------------------------------------------------------------- + +// FixPointData + +// int32 id = 1; +inline void FixPointData::clear_id() { + _impl_.id_ = 0; +} +inline ::int32_t FixPointData::id() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.id) + return _internal_id(); +} +inline void FixPointData::set_id(::int32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.id) +} +inline ::int32_t FixPointData::_internal_id() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.id_; +} +inline void FixPointData::_internal_set_id(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.id_ = value; +} + +// int32 cno = 2; +inline void FixPointData::clear_cno() { + _impl_.cno_ = 0; +} +inline ::int32_t FixPointData::cno() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.cno) + return _internal_cno(); +} +inline void FixPointData::set_cno(::int32_t value) { + _internal_set_cno(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.cno) +} +inline ::int32_t FixPointData::_internal_cno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cno_; +} +inline void FixPointData::_internal_set_cno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cno_ = value; +} + +// float pointX = 3; +inline void FixPointData::clear_pointx() { + _impl_.pointx_ = 0; +} +inline float FixPointData::pointx() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.pointX) + return _internal_pointx(); +} +inline void FixPointData::set_pointx(float value) { + _internal_set_pointx(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.pointX) +} +inline float FixPointData::_internal_pointx() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.pointx_; +} +inline void FixPointData::_internal_set_pointx(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.pointx_ = value; +} + +// float pointY = 4; +inline void FixPointData::clear_pointy() { + _impl_.pointy_ = 0; +} +inline float FixPointData::pointy() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.pointY) + return _internal_pointy(); +} +inline void FixPointData::set_pointy(float value) { + _internal_set_pointy(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.pointY) +} +inline float FixPointData::_internal_pointy() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.pointy_; +} +inline void FixPointData::_internal_set_pointy(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.pointy_ = value; +} + +// uint32 duration = 5; +inline void FixPointData::clear_duration() { + _impl_.duration_ = 0u; +} +inline ::uint32_t FixPointData::duration() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.duration) + return _internal_duration(); +} +inline void FixPointData::set_duration(::uint32_t value) { + _internal_set_duration(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.duration) +} +inline ::uint32_t FixPointData::_internal_duration() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.duration_; +} +inline void FixPointData::_internal_set_duration(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.duration_ = value; +} + +// ------------------------------------------------------------------- + +// ScanParamCfg + +// int32 edgeLevel = 1; +inline void ScanParamCfg::clear_edgelevel() { + _impl_.edgelevel_ = 0; +} +inline ::int32_t ScanParamCfg::edgelevel() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevel) + return _internal_edgelevel(); +} +inline void ScanParamCfg::set_edgelevel(::int32_t value) { + _internal_set_edgelevel(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevel) +} +inline ::int32_t ScanParamCfg::_internal_edgelevel() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.edgelevel_; +} +inline void ScanParamCfg::_internal_set_edgelevel(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.edgelevel_ = value; +} + +// int32 edgeLevelMin = 2; +inline void ScanParamCfg::clear_edgelevelmin() { + _impl_.edgelevelmin_ = 0; +} +inline ::int32_t ScanParamCfg::edgelevelmin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevelMin) + return _internal_edgelevelmin(); +} +inline void ScanParamCfg::set_edgelevelmin(::int32_t value) { + _internal_set_edgelevelmin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevelMin) +} +inline ::int32_t ScanParamCfg::_internal_edgelevelmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.edgelevelmin_; +} +inline void ScanParamCfg::_internal_set_edgelevelmin(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.edgelevelmin_ = value; +} + +// int32 edgeLevelMax = 3; +inline void ScanParamCfg::clear_edgelevelmax() { + _impl_.edgelevelmax_ = 0; +} +inline ::int32_t ScanParamCfg::edgelevelmax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevelMax) + return _internal_edgelevelmax(); +} +inline void ScanParamCfg::set_edgelevelmax(::int32_t value) { + _internal_set_edgelevelmax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevelMax) +} +inline ::int32_t ScanParamCfg::_internal_edgelevelmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.edgelevelmax_; +} +inline void ScanParamCfg::_internal_set_edgelevelmax(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.edgelevelmax_ = value; +} + +// uint32 jumpDelay = 4; +inline void ScanParamCfg::clear_jumpdelay() { + _impl_.jumpdelay_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumpdelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelay) + return _internal_jumpdelay(); +} +inline void ScanParamCfg::set_jumpdelay(::uint32_t value) { + _internal_set_jumpdelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelay) +} +inline ::uint32_t ScanParamCfg::_internal_jumpdelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpdelay_; +} +inline void ScanParamCfg::_internal_set_jumpdelay(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpdelay_ = value; +} + +// uint32 jumpDelayMin = 5; +inline void ScanParamCfg::clear_jumpdelaymin() { + _impl_.jumpdelaymin_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumpdelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelayMin) + return _internal_jumpdelaymin(); +} +inline void ScanParamCfg::set_jumpdelaymin(::uint32_t value) { + _internal_set_jumpdelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelayMin) +} +inline ::uint32_t ScanParamCfg::_internal_jumpdelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpdelaymin_; +} +inline void ScanParamCfg::_internal_set_jumpdelaymin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpdelaymin_ = value; +} + +// uint32 jumpDelayMax = 6; +inline void ScanParamCfg::clear_jumpdelaymax() { + _impl_.jumpdelaymax_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumpdelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelayMax) + return _internal_jumpdelaymax(); +} +inline void ScanParamCfg::set_jumpdelaymax(::uint32_t value) { + _internal_set_jumpdelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelayMax) +} +inline ::uint32_t ScanParamCfg::_internal_jumpdelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpdelaymax_; +} +inline void ScanParamCfg::_internal_set_jumpdelaymax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpdelaymax_ = value; +} + +// uint32 scanDelay = 7; +inline void ScanParamCfg::clear_scandelay() { + _impl_.scandelay_ = 0u; +} +inline ::uint32_t ScanParamCfg::scandelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelay) + return _internal_scandelay(); +} +inline void ScanParamCfg::set_scandelay(::uint32_t value) { + _internal_set_scandelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelay) +} +inline ::uint32_t ScanParamCfg::_internal_scandelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scandelay_; +} +inline void ScanParamCfg::_internal_set_scandelay(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scandelay_ = value; +} + +// uint32 scanDelayMin = 8; +inline void ScanParamCfg::clear_scandelaymin() { + _impl_.scandelaymin_ = 0u; +} +inline ::uint32_t ScanParamCfg::scandelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelayMin) + return _internal_scandelaymin(); +} +inline void ScanParamCfg::set_scandelaymin(::uint32_t value) { + _internal_set_scandelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelayMin) +} +inline ::uint32_t ScanParamCfg::_internal_scandelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scandelaymin_; +} +inline void ScanParamCfg::_internal_set_scandelaymin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scandelaymin_ = value; +} + +// uint32 scanDelayMax = 9; +inline void ScanParamCfg::clear_scandelaymax() { + _impl_.scandelaymax_ = 0u; +} +inline ::uint32_t ScanParamCfg::scandelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelayMax) + return _internal_scandelaymax(); +} +inline void ScanParamCfg::set_scandelaymax(::uint32_t value) { + _internal_set_scandelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelayMax) +} +inline ::uint32_t ScanParamCfg::_internal_scandelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scandelaymax_; +} +inline void ScanParamCfg::_internal_set_scandelaymax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scandelaymax_ = value; +} + +// uint32 polygonDelay = 10; +inline void ScanParamCfg::clear_polygondelay() { + _impl_.polygondelay_ = 0u; +} +inline ::uint32_t ScanParamCfg::polygondelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelay) + return _internal_polygondelay(); +} +inline void ScanParamCfg::set_polygondelay(::uint32_t value) { + _internal_set_polygondelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelay) +} +inline ::uint32_t ScanParamCfg::_internal_polygondelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.polygondelay_; +} +inline void ScanParamCfg::_internal_set_polygondelay(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.polygondelay_ = value; +} + +// uint32 polygonDelayMin = 11; +inline void ScanParamCfg::clear_polygondelaymin() { + _impl_.polygondelaymin_ = 0u; +} +inline ::uint32_t ScanParamCfg::polygondelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelayMin) + return _internal_polygondelaymin(); +} +inline void ScanParamCfg::set_polygondelaymin(::uint32_t value) { + _internal_set_polygondelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelayMin) +} +inline ::uint32_t ScanParamCfg::_internal_polygondelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.polygondelaymin_; +} +inline void ScanParamCfg::_internal_set_polygondelaymin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.polygondelaymin_ = value; +} + +// uint32 polygonDelayMax = 12; +inline void ScanParamCfg::clear_polygondelaymax() { + _impl_.polygondelaymax_ = 0u; +} +inline ::uint32_t ScanParamCfg::polygondelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelayMax) + return _internal_polygondelaymax(); +} +inline void ScanParamCfg::set_polygondelaymax(::uint32_t value) { + _internal_set_polygondelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelayMax) +} +inline ::uint32_t ScanParamCfg::_internal_polygondelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.polygondelaymax_; +} +inline void ScanParamCfg::_internal_set_polygondelaymax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.polygondelaymax_ = value; +} + +// int64 laseroffDelay = 13; +inline void ScanParamCfg::clear_laseroffdelay() { + _impl_.laseroffdelay_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laseroffdelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelay) + return _internal_laseroffdelay(); +} +inline void ScanParamCfg::set_laseroffdelay(::int64_t value) { + _internal_set_laseroffdelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelay) +} +inline ::int64_t ScanParamCfg::_internal_laseroffdelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseroffdelay_; +} +inline void ScanParamCfg::_internal_set_laseroffdelay(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseroffdelay_ = value; +} + +// int64 laseroffDelayMin = 14; +inline void ScanParamCfg::clear_laseroffdelaymin() { + _impl_.laseroffdelaymin_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laseroffdelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelayMin) + return _internal_laseroffdelaymin(); +} +inline void ScanParamCfg::set_laseroffdelaymin(::int64_t value) { + _internal_set_laseroffdelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelayMin) +} +inline ::int64_t ScanParamCfg::_internal_laseroffdelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseroffdelaymin_; +} +inline void ScanParamCfg::_internal_set_laseroffdelaymin(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseroffdelaymin_ = value; +} + +// int64 laseroffDelayMax = 15; +inline void ScanParamCfg::clear_laseroffdelaymax() { + _impl_.laseroffdelaymax_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laseroffdelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelayMax) + return _internal_laseroffdelaymax(); +} +inline void ScanParamCfg::set_laseroffdelaymax(::int64_t value) { + _internal_set_laseroffdelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelayMax) +} +inline ::int64_t ScanParamCfg::_internal_laseroffdelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseroffdelaymax_; +} +inline void ScanParamCfg::_internal_set_laseroffdelaymax(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseroffdelaymax_ = value; +} + +// int64 laseronDelay = 16; +inline void ScanParamCfg::clear_laserondelay() { + _impl_.laserondelay_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laserondelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelay) + return _internal_laserondelay(); +} +inline void ScanParamCfg::set_laserondelay(::int64_t value) { + _internal_set_laserondelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelay) +} +inline ::int64_t ScanParamCfg::_internal_laserondelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laserondelay_; +} +inline void ScanParamCfg::_internal_set_laserondelay(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laserondelay_ = value; +} + +// int64 laseronDelayMin = 17; +inline void ScanParamCfg::clear_laserondelaymin() { + _impl_.laserondelaymin_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laserondelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelayMin) + return _internal_laserondelaymin(); +} +inline void ScanParamCfg::set_laserondelaymin(::int64_t value) { + _internal_set_laserondelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelayMin) +} +inline ::int64_t ScanParamCfg::_internal_laserondelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laserondelaymin_; +} +inline void ScanParamCfg::_internal_set_laserondelaymin(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laserondelaymin_ = value; +} + +// int64 laseronDelayMax = 18; +inline void ScanParamCfg::clear_laserondelaymax() { + _impl_.laserondelaymax_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laserondelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelayMax) + return _internal_laserondelaymax(); +} +inline void ScanParamCfg::set_laserondelaymax(::int64_t value) { + _internal_set_laserondelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelayMax) +} +inline ::int64_t ScanParamCfg::_internal_laserondelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laserondelaymax_; +} +inline void ScanParamCfg::_internal_set_laserondelaymax(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laserondelaymax_ = value; +} + +// uint32 minJumpDelay = 19; +inline void ScanParamCfg::clear_minjumpdelay() { + _impl_.minjumpdelay_ = 0u; +} +inline ::uint32_t ScanParamCfg::minjumpdelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelay) + return _internal_minjumpdelay(); +} +inline void ScanParamCfg::set_minjumpdelay(::uint32_t value) { + _internal_set_minjumpdelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelay) +} +inline ::uint32_t ScanParamCfg::_internal_minjumpdelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.minjumpdelay_; +} +inline void ScanParamCfg::_internal_set_minjumpdelay(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.minjumpdelay_ = value; +} + +// uint32 minJumpDelayMin = 20; +inline void ScanParamCfg::clear_minjumpdelaymin() { + _impl_.minjumpdelaymin_ = 0u; +} +inline ::uint32_t ScanParamCfg::minjumpdelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelayMin) + return _internal_minjumpdelaymin(); +} +inline void ScanParamCfg::set_minjumpdelaymin(::uint32_t value) { + _internal_set_minjumpdelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelayMin) +} +inline ::uint32_t ScanParamCfg::_internal_minjumpdelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.minjumpdelaymin_; +} +inline void ScanParamCfg::_internal_set_minjumpdelaymin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.minjumpdelaymin_ = value; +} + +// uint32 minJumpDelayMax = 21; +inline void ScanParamCfg::clear_minjumpdelaymax() { + _impl_.minjumpdelaymax_ = 0u; +} +inline ::uint32_t ScanParamCfg::minjumpdelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelayMax) + return _internal_minjumpdelaymax(); +} +inline void ScanParamCfg::set_minjumpdelaymax(::uint32_t value) { + _internal_set_minjumpdelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelayMax) +} +inline ::uint32_t ScanParamCfg::_internal_minjumpdelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.minjumpdelaymax_; +} +inline void ScanParamCfg::_internal_set_minjumpdelaymax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.minjumpdelaymax_ = value; +} + +// uint32 jumpLengthLimit = 22; +inline void ScanParamCfg::clear_jumplengthlimit() { + _impl_.jumplengthlimit_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumplengthlimit() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimit) + return _internal_jumplengthlimit(); +} +inline void ScanParamCfg::set_jumplengthlimit(::uint32_t value) { + _internal_set_jumplengthlimit(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimit) +} +inline ::uint32_t ScanParamCfg::_internal_jumplengthlimit() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumplengthlimit_; +} +inline void ScanParamCfg::_internal_set_jumplengthlimit(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumplengthlimit_ = value; +} + +// uint32 jumpLengthLimitMin = 23; +inline void ScanParamCfg::clear_jumplengthlimitmin() { + _impl_.jumplengthlimitmin_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumplengthlimitmin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimitMin) + return _internal_jumplengthlimitmin(); +} +inline void ScanParamCfg::set_jumplengthlimitmin(::uint32_t value) { + _internal_set_jumplengthlimitmin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimitMin) +} +inline ::uint32_t ScanParamCfg::_internal_jumplengthlimitmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumplengthlimitmin_; +} +inline void ScanParamCfg::_internal_set_jumplengthlimitmin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumplengthlimitmin_ = value; +} + +// uint32 jumpLengthLimitMax = 24; +inline void ScanParamCfg::clear_jumplengthlimitmax() { + _impl_.jumplengthlimitmax_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumplengthlimitmax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimitMax) + return _internal_jumplengthlimitmax(); +} +inline void ScanParamCfg::set_jumplengthlimitmax(::uint32_t value) { + _internal_set_jumplengthlimitmax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimitMax) +} +inline ::uint32_t ScanParamCfg::_internal_jumplengthlimitmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumplengthlimitmax_; +} +inline void ScanParamCfg::_internal_set_jumplengthlimitmax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumplengthlimitmax_ = value; +} + +// double jumpSpeed = 25; +inline void ScanParamCfg::clear_jumpspeed() { + _impl_.jumpspeed_ = 0; +} +inline double ScanParamCfg::jumpspeed() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeed) + return _internal_jumpspeed(); +} +inline void ScanParamCfg::set_jumpspeed(double value) { + _internal_set_jumpspeed(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeed) +} +inline double ScanParamCfg::_internal_jumpspeed() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpspeed_; +} +inline void ScanParamCfg::_internal_set_jumpspeed(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpspeed_ = value; +} + +// double jumpSpeedMin = 26; +inline void ScanParamCfg::clear_jumpspeedmin() { + _impl_.jumpspeedmin_ = 0; +} +inline double ScanParamCfg::jumpspeedmin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeedMin) + return _internal_jumpspeedmin(); +} +inline void ScanParamCfg::set_jumpspeedmin(double value) { + _internal_set_jumpspeedmin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeedMin) +} +inline double ScanParamCfg::_internal_jumpspeedmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpspeedmin_; +} +inline void ScanParamCfg::_internal_set_jumpspeedmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpspeedmin_ = value; +} + +// double jumpSpeedMax = 27; +inline void ScanParamCfg::clear_jumpspeedmax() { + _impl_.jumpspeedmax_ = 0; +} +inline double ScanParamCfg::jumpspeedmax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeedMax) + return _internal_jumpspeedmax(); +} +inline void ScanParamCfg::set_jumpspeedmax(double value) { + _internal_set_jumpspeedmax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeedMax) +} +inline double ScanParamCfg::_internal_jumpspeedmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpspeedmax_; +} +inline void ScanParamCfg::_internal_set_jumpspeedmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpspeedmax_ = value; +} + +// double markSpeed = 28; +inline void ScanParamCfg::clear_markspeed() { + _impl_.markspeed_ = 0; +} +inline double ScanParamCfg::markspeed() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeed) + return _internal_markspeed(); +} +inline void ScanParamCfg::set_markspeed(double value) { + _internal_set_markspeed(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeed) +} +inline double ScanParamCfg::_internal_markspeed() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.markspeed_; +} +inline void ScanParamCfg::_internal_set_markspeed(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.markspeed_ = value; +} + +// double markSpeedMin = 29; +inline void ScanParamCfg::clear_markspeedmin() { + _impl_.markspeedmin_ = 0; +} +inline double ScanParamCfg::markspeedmin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeedMin) + return _internal_markspeedmin(); +} +inline void ScanParamCfg::set_markspeedmin(double value) { + _internal_set_markspeedmin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeedMin) +} +inline double ScanParamCfg::_internal_markspeedmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.markspeedmin_; +} +inline void ScanParamCfg::_internal_set_markspeedmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.markspeedmin_ = value; +} + +// double markSpeedMax = 30; +inline void ScanParamCfg::clear_markspeedmax() { + _impl_.markspeedmax_ = 0; +} +inline double ScanParamCfg::markspeedmax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeedMax) + return _internal_markspeedmax(); +} +inline void ScanParamCfg::set_markspeedmax(double value) { + _internal_set_markspeedmax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeedMax) +} +inline double ScanParamCfg::_internal_markspeedmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.markspeedmax_; +} +inline void ScanParamCfg::_internal_set_markspeedmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.markspeedmax_ = value; +} + +// ------------------------------------------------------------------- + +// CorrectParamCfg + +// double xmeasureMin = 1; +inline void CorrectParamCfg::clear_xmeasuremin() { + _impl_.xmeasuremin_ = 0; +} +inline double CorrectParamCfg::xmeasuremin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xmeasureMin) + return _internal_xmeasuremin(); +} +inline void CorrectParamCfg::set_xmeasuremin(double value) { + _internal_set_xmeasuremin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xmeasureMin) +} +inline double CorrectParamCfg::_internal_xmeasuremin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xmeasuremin_; +} +inline void CorrectParamCfg::_internal_set_xmeasuremin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xmeasuremin_ = value; +} + +// double xmeasureMax = 2; +inline void CorrectParamCfg::clear_xmeasuremax() { + _impl_.xmeasuremax_ = 0; +} +inline double CorrectParamCfg::xmeasuremax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xmeasureMax) + return _internal_xmeasuremax(); +} +inline void CorrectParamCfg::set_xmeasuremax(double value) { + _internal_set_xmeasuremax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xmeasureMax) +} +inline double CorrectParamCfg::_internal_xmeasuremax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xmeasuremax_; +} +inline void CorrectParamCfg::_internal_set_xmeasuremax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xmeasuremax_ = value; +} + +// double ymeasureMin = 3; +inline void CorrectParamCfg::clear_ymeasuremin() { + _impl_.ymeasuremin_ = 0; +} +inline double CorrectParamCfg::ymeasuremin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ymeasureMin) + return _internal_ymeasuremin(); +} +inline void CorrectParamCfg::set_ymeasuremin(double value) { + _internal_set_ymeasuremin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ymeasureMin) +} +inline double CorrectParamCfg::_internal_ymeasuremin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ymeasuremin_; +} +inline void CorrectParamCfg::_internal_set_ymeasuremin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ymeasuremin_ = value; +} + +// double ymeasureMax = 4; +inline void CorrectParamCfg::clear_ymeasuremax() { + _impl_.ymeasuremax_ = 0; +} +inline double CorrectParamCfg::ymeasuremax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ymeasureMax) + return _internal_ymeasuremax(); +} +inline void CorrectParamCfg::set_ymeasuremax(double value) { + _internal_set_ymeasuremax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ymeasureMax) +} +inline double CorrectParamCfg::_internal_ymeasuremax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ymeasuremax_; +} +inline void CorrectParamCfg::_internal_set_ymeasuremax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ymeasuremax_ = value; +} + +// double xposfix = 5; +inline void CorrectParamCfg::clear_xposfix() { + _impl_.xposfix_ = 0; +} +inline double CorrectParamCfg::xposfix() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xposfix) + return _internal_xposfix(); +} +inline void CorrectParamCfg::set_xposfix(double value) { + _internal_set_xposfix(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xposfix) +} +inline double CorrectParamCfg::_internal_xposfix() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xposfix_; +} +inline void CorrectParamCfg::_internal_set_xposfix(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xposfix_ = value; +} + +// double yposfix = 6; +inline void CorrectParamCfg::clear_yposfix() { + _impl_.yposfix_ = 0; +} +inline double CorrectParamCfg::yposfix() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.yposfix) + return _internal_yposfix(); +} +inline void CorrectParamCfg::set_yposfix(double value) { + _internal_set_yposfix(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.yposfix) +} +inline double CorrectParamCfg::_internal_yposfix() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.yposfix_; +} +inline void CorrectParamCfg::_internal_set_yposfix(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.yposfix_ = value; +} + +// double scanAngle = 7; +inline void CorrectParamCfg::clear_scanangle() { + _impl_.scanangle_ = 0; +} +inline double CorrectParamCfg::scanangle() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngle) + return _internal_scanangle(); +} +inline void CorrectParamCfg::set_scanangle(double value) { + _internal_set_scanangle(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngle) +} +inline double CorrectParamCfg::_internal_scanangle() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scanangle_; +} +inline void CorrectParamCfg::_internal_set_scanangle(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scanangle_ = value; +} + +// double scanAngleMin = 8; +inline void CorrectParamCfg::clear_scananglemin() { + _impl_.scananglemin_ = 0; +} +inline double CorrectParamCfg::scananglemin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngleMin) + return _internal_scananglemin(); +} +inline void CorrectParamCfg::set_scananglemin(double value) { + _internal_set_scananglemin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngleMin) +} +inline double CorrectParamCfg::_internal_scananglemin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scananglemin_; +} +inline void CorrectParamCfg::_internal_set_scananglemin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scananglemin_ = value; +} + +// double scanAngleMax = 9; +inline void CorrectParamCfg::clear_scananglemax() { + _impl_.scananglemax_ = 0; +} +inline double CorrectParamCfg::scananglemax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngleMax) + return _internal_scananglemax(); +} +inline void CorrectParamCfg::set_scananglemax(double value) { + _internal_set_scananglemax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngleMax) +} +inline double CorrectParamCfg::_internal_scananglemax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scananglemax_; +} +inline void CorrectParamCfg::_internal_set_scananglemax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scananglemax_ = value; +} + +// double fixAngle = 10; +inline void CorrectParamCfg::clear_fixangle() { + _impl_.fixangle_ = 0; +} +inline double CorrectParamCfg::fixangle() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngle) + return _internal_fixangle(); +} +inline void CorrectParamCfg::set_fixangle(double value) { + _internal_set_fixangle(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngle) +} +inline double CorrectParamCfg::_internal_fixangle() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.fixangle_; +} +inline void CorrectParamCfg::_internal_set_fixangle(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.fixangle_ = value; +} + +// double fixAngleMin = 11; +inline void CorrectParamCfg::clear_fixanglemin() { + _impl_.fixanglemin_ = 0; +} +inline double CorrectParamCfg::fixanglemin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngleMin) + return _internal_fixanglemin(); +} +inline void CorrectParamCfg::set_fixanglemin(double value) { + _internal_set_fixanglemin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngleMin) +} +inline double CorrectParamCfg::_internal_fixanglemin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.fixanglemin_; +} +inline void CorrectParamCfg::_internal_set_fixanglemin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.fixanglemin_ = value; +} + +// double fixAngleMax = 12; +inline void CorrectParamCfg::clear_fixanglemax() { + _impl_.fixanglemax_ = 0; +} +inline double CorrectParamCfg::fixanglemax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngleMax) + return _internal_fixanglemax(); +} +inline void CorrectParamCfg::set_fixanglemax(double value) { + _internal_set_fixanglemax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngleMax) +} +inline double CorrectParamCfg::_internal_fixanglemax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.fixanglemax_; +} +inline void CorrectParamCfg::_internal_set_fixanglemax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.fixanglemax_ = value; +} + +// double xcorrect = 13; +inline void CorrectParamCfg::clear_xcorrect() { + _impl_.xcorrect_ = 0; +} +inline double CorrectParamCfg::xcorrect() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrect) + return _internal_xcorrect(); +} +inline void CorrectParamCfg::set_xcorrect(double value) { + _internal_set_xcorrect(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrect) +} +inline double CorrectParamCfg::_internal_xcorrect() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xcorrect_; +} +inline void CorrectParamCfg::_internal_set_xcorrect(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xcorrect_ = value; +} + +// double ycorrect = 14; +inline void CorrectParamCfg::clear_ycorrect() { + _impl_.ycorrect_ = 0; +} +inline double CorrectParamCfg::ycorrect() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrect) + return _internal_ycorrect(); +} +inline void CorrectParamCfg::set_ycorrect(double value) { + _internal_set_ycorrect(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrect) +} +inline double CorrectParamCfg::_internal_ycorrect() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ycorrect_; +} +inline void CorrectParamCfg::_internal_set_ycorrect(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ycorrect_ = value; +} + +// double xcorrectMin = 15; +inline void CorrectParamCfg::clear_xcorrectmin() { + _impl_.xcorrectmin_ = 0; +} +inline double CorrectParamCfg::xcorrectmin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrectMin) + return _internal_xcorrectmin(); +} +inline void CorrectParamCfg::set_xcorrectmin(double value) { + _internal_set_xcorrectmin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrectMin) +} +inline double CorrectParamCfg::_internal_xcorrectmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xcorrectmin_; +} +inline void CorrectParamCfg::_internal_set_xcorrectmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xcorrectmin_ = value; +} + +// double xcorrectMax = 16; +inline void CorrectParamCfg::clear_xcorrectmax() { + _impl_.xcorrectmax_ = 0; +} +inline double CorrectParamCfg::xcorrectmax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrectMax) + return _internal_xcorrectmax(); +} +inline void CorrectParamCfg::set_xcorrectmax(double value) { + _internal_set_xcorrectmax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrectMax) +} +inline double CorrectParamCfg::_internal_xcorrectmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xcorrectmax_; +} +inline void CorrectParamCfg::_internal_set_xcorrectmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xcorrectmax_ = value; +} + +// double ycorrectMin = 17; +inline void CorrectParamCfg::clear_ycorrectmin() { + _impl_.ycorrectmin_ = 0; +} +inline double CorrectParamCfg::ycorrectmin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrectMin) + return _internal_ycorrectmin(); +} +inline void CorrectParamCfg::set_ycorrectmin(double value) { + _internal_set_ycorrectmin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrectMin) +} +inline double CorrectParamCfg::_internal_ycorrectmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ycorrectmin_; +} +inline void CorrectParamCfg::_internal_set_ycorrectmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ycorrectmin_ = value; +} + +// double ycorrectMax = 18; +inline void CorrectParamCfg::clear_ycorrectmax() { + _impl_.ycorrectmax_ = 0; +} +inline double CorrectParamCfg::ycorrectmax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrectMax) + return _internal_ycorrectmax(); +} +inline void CorrectParamCfg::set_ycorrectmax(double value) { + _internal_set_ycorrectmax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrectMax) +} +inline double CorrectParamCfg::_internal_ycorrectmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ycorrectmax_; +} +inline void CorrectParamCfg::_internal_set_ycorrectmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ycorrectmax_ = value; +} + +// double realXOffset = 19; +inline void CorrectParamCfg::clear_realxoffset() { + _impl_.realxoffset_ = 0; +} +inline double CorrectParamCfg::realxoffset() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.realXOffset) + return _internal_realxoffset(); +} +inline void CorrectParamCfg::set_realxoffset(double value) { + _internal_set_realxoffset(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.realXOffset) +} +inline double CorrectParamCfg::_internal_realxoffset() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.realxoffset_; +} +inline void CorrectParamCfg::_internal_set_realxoffset(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.realxoffset_ = value; +} + +// double realYOffset = 20; +inline void CorrectParamCfg::clear_realyoffset() { + _impl_.realyoffset_ = 0; +} +inline double CorrectParamCfg::realyoffset() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.realYOffset) + return _internal_realyoffset(); +} +inline void CorrectParamCfg::set_realyoffset(double value) { + _internal_set_realyoffset(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.realYOffset) +} +inline double CorrectParamCfg::_internal_realyoffset() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.realyoffset_; +} +inline void CorrectParamCfg::_internal_set_realyoffset(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.realyoffset_ = value; +} + +// double factorK = 21; +inline void CorrectParamCfg::clear_factork() { + _impl_.factork_ = 0; +} +inline double CorrectParamCfg::factork() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.factorK) + return _internal_factork(); +} +inline void CorrectParamCfg::set_factork(double value) { + _internal_set_factork(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.factorK) +} +inline double CorrectParamCfg::_internal_factork() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.factork_; +} +inline void CorrectParamCfg::_internal_set_factork(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.factork_ = value; +} + +// bool isCorrectFile3D = 22; +inline void CorrectParamCfg::clear_iscorrectfile3d() { + _impl_.iscorrectfile3d_ = false; +} +inline bool CorrectParamCfg::iscorrectfile3d() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.isCorrectFile3D) + return _internal_iscorrectfile3d(); +} +inline void CorrectParamCfg::set_iscorrectfile3d(bool value) { + _internal_set_iscorrectfile3d(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.isCorrectFile3D) +} +inline bool CorrectParamCfg::_internal_iscorrectfile3d() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.iscorrectfile3d_; +} +inline void CorrectParamCfg::_internal_set_iscorrectfile3d(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.iscorrectfile3d_ = value; +} + +// bool isDynamicFocus = 23; +inline void CorrectParamCfg::clear_isdynamicfocus() { + _impl_.isdynamicfocus_ = false; +} +inline bool CorrectParamCfg::isdynamicfocus() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.isDynamicFocus) + return _internal_isdynamicfocus(); +} +inline void CorrectParamCfg::set_isdynamicfocus(bool value) { + _internal_set_isdynamicfocus(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.isDynamicFocus) +} +inline bool CorrectParamCfg::_internal_isdynamicfocus() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.isdynamicfocus_; +} +inline void CorrectParamCfg::_internal_set_isdynamicfocus(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.isdynamicfocus_ = value; +} + +// double defocusRatio = 24; +inline void CorrectParamCfg::clear_defocusratio() { + _impl_.defocusratio_ = 0; +} +inline double CorrectParamCfg::defocusratio() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatio) + return _internal_defocusratio(); +} +inline void CorrectParamCfg::set_defocusratio(double value) { + _internal_set_defocusratio(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatio) +} +inline double CorrectParamCfg::_internal_defocusratio() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocusratio_; +} +inline void CorrectParamCfg::_internal_set_defocusratio(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocusratio_ = value; +} + +// double defocusRatioMin = 25; +inline void CorrectParamCfg::clear_defocusratiomin() { + _impl_.defocusratiomin_ = 0; +} +inline double CorrectParamCfg::defocusratiomin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatioMin) + return _internal_defocusratiomin(); +} +inline void CorrectParamCfg::set_defocusratiomin(double value) { + _internal_set_defocusratiomin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatioMin) +} +inline double CorrectParamCfg::_internal_defocusratiomin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocusratiomin_; +} +inline void CorrectParamCfg::_internal_set_defocusratiomin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocusratiomin_ = value; +} + +// double defocusRatioMax = 26; +inline void CorrectParamCfg::clear_defocusratiomax() { + _impl_.defocusratiomax_ = 0; +} +inline double CorrectParamCfg::defocusratiomax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatioMax) + return _internal_defocusratiomax(); +} +inline void CorrectParamCfg::set_defocusratiomax(double value) { + _internal_set_defocusratiomax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatioMax) +} +inline double CorrectParamCfg::_internal_defocusratiomax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocusratiomax_; +} +inline void CorrectParamCfg::_internal_set_defocusratiomax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocusratiomax_ = value; +} + +// ------------------------------------------------------------------- + +// ScanTestCfg + +// int32 debugShape = 1; +inline void ScanTestCfg::clear_debugshape() { + _impl_.debugshape_ = 0; +} +inline ::int32_t ScanTestCfg::debugshape() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.debugShape) + return _internal_debugshape(); +} +inline void ScanTestCfg::set_debugshape(::int32_t value) { + _internal_set_debugshape(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.debugShape) +} +inline ::int32_t ScanTestCfg::_internal_debugshape() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.debugshape_; +} +inline void ScanTestCfg::_internal_set_debugshape(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.debugshape_ = value; +} + +// int32 shapeSize = 2; +inline void ScanTestCfg::clear_shapesize() { + _impl_.shapesize_ = 0; +} +inline ::int32_t ScanTestCfg::shapesize() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shapeSize) + return _internal_shapesize(); +} +inline void ScanTestCfg::set_shapesize(::int32_t value) { + _internal_set_shapesize(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shapeSize) +} +inline ::int32_t ScanTestCfg::_internal_shapesize() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.shapesize_; +} +inline void ScanTestCfg::_internal_set_shapesize(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.shapesize_ = value; +} + +// int32 shapeSizeMin = 3; +inline void ScanTestCfg::clear_shapesizemin() { + _impl_.shapesizemin_ = 0; +} +inline ::int32_t ScanTestCfg::shapesizemin() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shapeSizeMin) + return _internal_shapesizemin(); +} +inline void ScanTestCfg::set_shapesizemin(::int32_t value) { + _internal_set_shapesizemin(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shapeSizeMin) +} +inline ::int32_t ScanTestCfg::_internal_shapesizemin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.shapesizemin_; +} +inline void ScanTestCfg::_internal_set_shapesizemin(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.shapesizemin_ = value; +} + +// int32 shape_size_max = 4; +inline void ScanTestCfg::clear_shape_size_max() { + _impl_.shape_size_max_ = 0; +} +inline ::int32_t ScanTestCfg::shape_size_max() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shape_size_max) + return _internal_shape_size_max(); +} +inline void ScanTestCfg::set_shape_size_max(::int32_t value) { + _internal_set_shape_size_max(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shape_size_max) +} +inline ::int32_t ScanTestCfg::_internal_shape_size_max() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.shape_size_max_; +} +inline void ScanTestCfg::_internal_set_shape_size_max(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.shape_size_max_ = value; +} + +// int32 laser_power = 5; +inline void ScanTestCfg::clear_laser_power() { + _impl_.laser_power_ = 0; +} +inline ::int32_t ScanTestCfg::laser_power() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power) + return _internal_laser_power(); +} +inline void ScanTestCfg::set_laser_power(::int32_t value) { + _internal_set_laser_power(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power) +} +inline ::int32_t ScanTestCfg::_internal_laser_power() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laser_power_; +} +inline void ScanTestCfg::_internal_set_laser_power(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laser_power_ = value; +} + +// int32 laser_power_min = 6; +inline void ScanTestCfg::clear_laser_power_min() { + _impl_.laser_power_min_ = 0; +} +inline ::int32_t ScanTestCfg::laser_power_min() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power_min) + return _internal_laser_power_min(); +} +inline void ScanTestCfg::set_laser_power_min(::int32_t value) { + _internal_set_laser_power_min(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power_min) +} +inline ::int32_t ScanTestCfg::_internal_laser_power_min() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laser_power_min_; +} +inline void ScanTestCfg::_internal_set_laser_power_min(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laser_power_min_ = value; +} + +// int32 laser_power_max = 7; +inline void ScanTestCfg::clear_laser_power_max() { + _impl_.laser_power_max_ = 0; +} +inline ::int32_t ScanTestCfg::laser_power_max() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power_max) + return _internal_laser_power_max(); +} +inline void ScanTestCfg::set_laser_power_max(::int32_t value) { + _internal_set_laser_power_max(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power_max) +} +inline ::int32_t ScanTestCfg::_internal_laser_power_max() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laser_power_max_; +} +inline void ScanTestCfg::_internal_set_laser_power_max(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laser_power_max_ = value; +} + +// double defocus = 8; +inline void ScanTestCfg::clear_defocus() { + _impl_.defocus_ = 0; +} +inline double ScanTestCfg::defocus() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus) + return _internal_defocus(); +} +inline void ScanTestCfg::set_defocus(double value) { + _internal_set_defocus(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus) +} +inline double ScanTestCfg::_internal_defocus() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocus_; +} +inline void ScanTestCfg::_internal_set_defocus(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocus_ = value; +} + +// double defocus_min = 9; +inline void ScanTestCfg::clear_defocus_min() { + _impl_.defocus_min_ = 0; +} +inline double ScanTestCfg::defocus_min() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus_min) + return _internal_defocus_min(); +} +inline void ScanTestCfg::set_defocus_min(double value) { + _internal_set_defocus_min(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus_min) +} +inline double ScanTestCfg::_internal_defocus_min() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocus_min_; +} +inline void ScanTestCfg::_internal_set_defocus_min(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocus_min_ = value; +} + +// double defocus_max = 10; +inline void ScanTestCfg::clear_defocus_max() { + _impl_.defocus_max_ = 0; +} +inline double ScanTestCfg::defocus_max() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus_max) + return _internal_defocus_max(); +} +inline void ScanTestCfg::set_defocus_max(double value) { + _internal_set_defocus_max(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus_max) +} +inline double ScanTestCfg::_internal_defocus_max() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocus_max_; +} +inline void ScanTestCfg::_internal_set_defocus_max(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocus_max_ = value; +} + +// bool is_cycle = 11; +inline void ScanTestCfg::clear_is_cycle() { + _impl_.is_cycle_ = false; +} +inline bool ScanTestCfg::is_cycle() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.is_cycle) + return _internal_is_cycle(); +} +inline void ScanTestCfg::set_is_cycle(bool value) { + _internal_set_is_cycle(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.is_cycle) +} +inline bool ScanTestCfg::_internal_is_cycle() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.is_cycle_; +} +inline void ScanTestCfg::_internal_set_is_cycle(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.is_cycle_ = value; +} + +// double cross_x = 12; +inline void ScanTestCfg::clear_cross_x() { + _impl_.cross_x_ = 0; +} +inline double ScanTestCfg::cross_x() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.cross_x) + return _internal_cross_x(); +} +inline void ScanTestCfg::set_cross_x(double value) { + _internal_set_cross_x(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.cross_x) +} +inline double ScanTestCfg::_internal_cross_x() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cross_x_; +} +inline void ScanTestCfg::_internal_set_cross_x(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cross_x_ = value; +} + +// double cross_y = 13; +inline void ScanTestCfg::clear_cross_y() { + _impl_.cross_y_ = 0; +} +inline double ScanTestCfg::cross_y() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.cross_y) + return _internal_cross_y(); +} +inline void ScanTestCfg::set_cross_y(double value) { + _internal_set_cross_y(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.cross_y) +} +inline double ScanTestCfg::_internal_cross_y() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cross_y_; +} +inline void ScanTestCfg::_internal_set_cross_y(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cross_y_ = value; +} + +// double z_distance = 14; +inline void ScanTestCfg::clear_z_distance() { + _impl_.z_distance_ = 0; +} +inline double ScanTestCfg::z_distance() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.z_distance) + return _internal_z_distance(); +} +inline void ScanTestCfg::set_z_distance(double value) { + _internal_set_z_distance(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.z_distance) +} +inline double ScanTestCfg::_internal_z_distance() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.z_distance_; +} +inline void ScanTestCfg::_internal_set_z_distance(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.z_distance_ = value; +} + +// bool isAutoHeatingScanner = 15; +inline void ScanTestCfg::clear_isautoheatingscanner() { + _impl_.isautoheatingscanner_ = false; +} +inline bool ScanTestCfg::isautoheatingscanner() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.isAutoHeatingScanner) + return _internal_isautoheatingscanner(); +} +inline void ScanTestCfg::set_isautoheatingscanner(bool value) { + _internal_set_isautoheatingscanner(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.isAutoHeatingScanner) +} +inline bool ScanTestCfg::_internal_isautoheatingscanner() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.isautoheatingscanner_; +} +inline void ScanTestCfg::_internal_set_isautoheatingscanner(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.isautoheatingscanner_ = value; +} + +// uint32 autoHeatingScannerMinutes = 16; +inline void ScanTestCfg::clear_autoheatingscannerminutes() { + _impl_.autoheatingscannerminutes_ = 0u; +} +inline ::uint32_t ScanTestCfg::autoheatingscannerminutes() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerMinutes) + return _internal_autoheatingscannerminutes(); +} +inline void ScanTestCfg::set_autoheatingscannerminutes(::uint32_t value) { + _internal_set_autoheatingscannerminutes(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerMinutes) +} +inline ::uint32_t ScanTestCfg::_internal_autoheatingscannerminutes() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.autoheatingscannerminutes_; +} +inline void ScanTestCfg::_internal_set_autoheatingscannerminutes(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.autoheatingscannerminutes_ = value; +} + +// uint32 autoHeatingScannerSize = 17; +inline void ScanTestCfg::clear_autoheatingscannersize() { + _impl_.autoheatingscannersize_ = 0u; +} +inline ::uint32_t ScanTestCfg::autoheatingscannersize() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerSize) + return _internal_autoheatingscannersize(); +} +inline void ScanTestCfg::set_autoheatingscannersize(::uint32_t value) { + _internal_set_autoheatingscannersize(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerSize) +} +inline ::uint32_t ScanTestCfg::_internal_autoheatingscannersize() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.autoheatingscannersize_; +} +inline void ScanTestCfg::_internal_set_autoheatingscannersize(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.autoheatingscannersize_ = value; +} + +// double autoHeatingScannerSpeed = 18; +inline void ScanTestCfg::clear_autoheatingscannerspeed() { + _impl_.autoheatingscannerspeed_ = 0; +} +inline double ScanTestCfg::autoheatingscannerspeed() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerSpeed) + return _internal_autoheatingscannerspeed(); +} +inline void ScanTestCfg::set_autoheatingscannerspeed(double value) { + _internal_set_autoheatingscannerspeed(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerSpeed) +} +inline double ScanTestCfg::_internal_autoheatingscannerspeed() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.autoheatingscannerspeed_; +} +inline void ScanTestCfg::_internal_set_autoheatingscannerspeed(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.autoheatingscannerspeed_ = value; +} + +// double mark_test_start_x = 19; +inline void ScanTestCfg::clear_mark_test_start_x() { + _impl_.mark_test_start_x_ = 0; +} +inline double ScanTestCfg::mark_test_start_x() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_start_x) + return _internal_mark_test_start_x(); +} +inline void ScanTestCfg::set_mark_test_start_x(double value) { + _internal_set_mark_test_start_x(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_start_x) +} +inline double ScanTestCfg::_internal_mark_test_start_x() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mark_test_start_x_; +} +inline void ScanTestCfg::_internal_set_mark_test_start_x(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mark_test_start_x_ = value; +} + +// double mark_test_start_y = 20; +inline void ScanTestCfg::clear_mark_test_start_y() { + _impl_.mark_test_start_y_ = 0; +} +inline double ScanTestCfg::mark_test_start_y() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_start_y) + return _internal_mark_test_start_y(); +} +inline void ScanTestCfg::set_mark_test_start_y(double value) { + _internal_set_mark_test_start_y(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_start_y) +} +inline double ScanTestCfg::_internal_mark_test_start_y() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mark_test_start_y_; +} +inline void ScanTestCfg::_internal_set_mark_test_start_y(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mark_test_start_y_ = value; +} + +// double mark_test_end_x = 21; +inline void ScanTestCfg::clear_mark_test_end_x() { + _impl_.mark_test_end_x_ = 0; +} +inline double ScanTestCfg::mark_test_end_x() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_end_x) + return _internal_mark_test_end_x(); +} +inline void ScanTestCfg::set_mark_test_end_x(double value) { + _internal_set_mark_test_end_x(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_end_x) +} +inline double ScanTestCfg::_internal_mark_test_end_x() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mark_test_end_x_; +} +inline void ScanTestCfg::_internal_set_mark_test_end_x(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mark_test_end_x_ = value; +} + +// double mark_test_end_y = 22; +inline void ScanTestCfg::clear_mark_test_end_y() { + _impl_.mark_test_end_y_ = 0; +} +inline double ScanTestCfg::mark_test_end_y() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_end_y) + return _internal_mark_test_end_y(); +} +inline void ScanTestCfg::set_mark_test_end_y(double value) { + _internal_set_mark_test_end_y(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_end_y) +} +inline double ScanTestCfg::_internal_mark_test_end_y() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mark_test_end_y_; +} +inline void ScanTestCfg::_internal_set_mark_test_end_y(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mark_test_end_y_ = value; +} + +// ------------------------------------------------------------------- + +// SkyWritingCfg + +// bool isEnable = 1; +inline void SkyWritingCfg::clear_isenable() { + _impl_.isenable_ = false; +} +inline bool SkyWritingCfg::isenable() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.isEnable) + return _internal_isenable(); +} +inline void SkyWritingCfg::set_isenable(bool value) { + _internal_set_isenable(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.isEnable) +} +inline bool SkyWritingCfg::_internal_isenable() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.isenable_; +} +inline void SkyWritingCfg::_internal_set_isenable(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.isenable_ = value; +} + +// double timelag = 2; +inline void SkyWritingCfg::clear_timelag() { + _impl_.timelag_ = 0; +} +inline double SkyWritingCfg::timelag() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelag) + return _internal_timelag(); +} +inline void SkyWritingCfg::set_timelag(double value) { + _internal_set_timelag(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelag) +} +inline double SkyWritingCfg::_internal_timelag() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.timelag_; +} +inline void SkyWritingCfg::_internal_set_timelag(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.timelag_ = value; +} + +// double timelagMin = 3; +inline void SkyWritingCfg::clear_timelagmin() { + _impl_.timelagmin_ = 0; +} +inline double SkyWritingCfg::timelagmin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelagMin) + return _internal_timelagmin(); +} +inline void SkyWritingCfg::set_timelagmin(double value) { + _internal_set_timelagmin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelagMin) +} +inline double SkyWritingCfg::_internal_timelagmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.timelagmin_; +} +inline void SkyWritingCfg::_internal_set_timelagmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.timelagmin_ = value; +} + +// double timelagMax = 4; +inline void SkyWritingCfg::clear_timelagmax() { + _impl_.timelagmax_ = 0; +} +inline double SkyWritingCfg::timelagmax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelagMax) + return _internal_timelagmax(); +} +inline void SkyWritingCfg::set_timelagmax(double value) { + _internal_set_timelagmax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelagMax) +} +inline double SkyWritingCfg::_internal_timelagmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.timelagmax_; +} +inline void SkyWritingCfg::_internal_set_timelagmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.timelagmax_ = value; +} + +// int64 laserOnShift = 5; +inline void SkyWritingCfg::clear_laseronshift() { + _impl_.laseronshift_ = ::int64_t{0}; +} +inline ::int64_t SkyWritingCfg::laseronshift() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShift) + return _internal_laseronshift(); +} +inline void SkyWritingCfg::set_laseronshift(::int64_t value) { + _internal_set_laseronshift(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShift) +} +inline ::int64_t SkyWritingCfg::_internal_laseronshift() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseronshift_; +} +inline void SkyWritingCfg::_internal_set_laseronshift(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseronshift_ = value; +} + +// int64 laserOnShiftMin = 6; +inline void SkyWritingCfg::clear_laseronshiftmin() { + _impl_.laseronshiftmin_ = ::int64_t{0}; +} +inline ::int64_t SkyWritingCfg::laseronshiftmin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShiftMin) + return _internal_laseronshiftmin(); +} +inline void SkyWritingCfg::set_laseronshiftmin(::int64_t value) { + _internal_set_laseronshiftmin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShiftMin) +} +inline ::int64_t SkyWritingCfg::_internal_laseronshiftmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseronshiftmin_; +} +inline void SkyWritingCfg::_internal_set_laseronshiftmin(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseronshiftmin_ = value; +} + +// int64 laserOnShiftMax = 7; +inline void SkyWritingCfg::clear_laseronshiftmax() { + _impl_.laseronshiftmax_ = ::int64_t{0}; +} +inline ::int64_t SkyWritingCfg::laseronshiftmax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShiftMax) + return _internal_laseronshiftmax(); +} +inline void SkyWritingCfg::set_laseronshiftmax(::int64_t value) { + _internal_set_laseronshiftmax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShiftMax) +} +inline ::int64_t SkyWritingCfg::_internal_laseronshiftmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseronshiftmax_; +} +inline void SkyWritingCfg::_internal_set_laseronshiftmax(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseronshiftmax_ = value; +} + +// uint32 nprev = 8; +inline void SkyWritingCfg::clear_nprev() { + _impl_.nprev_ = 0u; +} +inline ::uint32_t SkyWritingCfg::nprev() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprev) + return _internal_nprev(); +} +inline void SkyWritingCfg::set_nprev(::uint32_t value) { + _internal_set_nprev(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprev) +} +inline ::uint32_t SkyWritingCfg::_internal_nprev() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.nprev_; +} +inline void SkyWritingCfg::_internal_set_nprev(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.nprev_ = value; +} + +// uint32 nprevMin = 9; +inline void SkyWritingCfg::clear_nprevmin() { + _impl_.nprevmin_ = 0u; +} +inline ::uint32_t SkyWritingCfg::nprevmin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprevMin) + return _internal_nprevmin(); +} +inline void SkyWritingCfg::set_nprevmin(::uint32_t value) { + _internal_set_nprevmin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprevMin) +} +inline ::uint32_t SkyWritingCfg::_internal_nprevmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.nprevmin_; +} +inline void SkyWritingCfg::_internal_set_nprevmin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.nprevmin_ = value; +} + +// uint32 nprevMax = 10; +inline void SkyWritingCfg::clear_nprevmax() { + _impl_.nprevmax_ = 0u; +} +inline ::uint32_t SkyWritingCfg::nprevmax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprevMax) + return _internal_nprevmax(); +} +inline void SkyWritingCfg::set_nprevmax(::uint32_t value) { + _internal_set_nprevmax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprevMax) +} +inline ::uint32_t SkyWritingCfg::_internal_nprevmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.nprevmax_; +} +inline void SkyWritingCfg::_internal_set_nprevmax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.nprevmax_ = value; +} + +// uint32 npost = 11; +inline void SkyWritingCfg::clear_npost() { + _impl_.npost_ = 0u; +} +inline ::uint32_t SkyWritingCfg::npost() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npost) + return _internal_npost(); +} +inline void SkyWritingCfg::set_npost(::uint32_t value) { + _internal_set_npost(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npost) +} +inline ::uint32_t SkyWritingCfg::_internal_npost() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.npost_; +} +inline void SkyWritingCfg::_internal_set_npost(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.npost_ = value; +} + +// uint32 npostMin = 12; +inline void SkyWritingCfg::clear_npostmin() { + _impl_.npostmin_ = 0u; +} +inline ::uint32_t SkyWritingCfg::npostmin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npostMin) + return _internal_npostmin(); +} +inline void SkyWritingCfg::set_npostmin(::uint32_t value) { + _internal_set_npostmin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npostMin) +} +inline ::uint32_t SkyWritingCfg::_internal_npostmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.npostmin_; +} +inline void SkyWritingCfg::_internal_set_npostmin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.npostmin_ = value; +} + +// uint32 npostMax = 13; +inline void SkyWritingCfg::clear_npostmax() { + _impl_.npostmax_ = 0u; +} +inline ::uint32_t SkyWritingCfg::npostmax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npostMax) + return _internal_npostmax(); +} +inline void SkyWritingCfg::set_npostmax(::uint32_t value) { + _internal_set_npostmax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npostMax) +} +inline ::uint32_t SkyWritingCfg::_internal_npostmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.npostmax_; +} +inline void SkyWritingCfg::_internal_set_npostmax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.npostmax_ = value; +} + +// int32 mode = 14; +inline void SkyWritingCfg::clear_mode() { + _impl_.mode_ = 0; +} +inline ::int32_t SkyWritingCfg::mode() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.mode) + return _internal_mode(); +} +inline void SkyWritingCfg::set_mode(::int32_t value) { + _internal_set_mode(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.mode) +} +inline ::int32_t SkyWritingCfg::_internal_mode() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mode_; +} +inline void SkyWritingCfg::_internal_set_mode(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mode_ = value; +} + +// double limite = 15; +inline void SkyWritingCfg::clear_limite() { + _impl_.limite_ = 0; +} +inline double SkyWritingCfg::limite() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limite) + return _internal_limite(); +} +inline void SkyWritingCfg::set_limite(double value) { + _internal_set_limite(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limite) +} +inline double SkyWritingCfg::_internal_limite() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.limite_; +} +inline void SkyWritingCfg::_internal_set_limite(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.limite_ = value; +} + +// double limiteMin = 16; +inline void SkyWritingCfg::clear_limitemin() { + _impl_.limitemin_ = 0; +} +inline double SkyWritingCfg::limitemin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limiteMin) + return _internal_limitemin(); +} +inline void SkyWritingCfg::set_limitemin(double value) { + _internal_set_limitemin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limiteMin) +} +inline double SkyWritingCfg::_internal_limitemin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.limitemin_; +} +inline void SkyWritingCfg::_internal_set_limitemin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.limitemin_ = value; +} + +// double limiteMax = 17; +inline void SkyWritingCfg::clear_limitemax() { + _impl_.limitemax_ = 0; +} +inline double SkyWritingCfg::limitemax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limiteMax) + return _internal_limitemax(); +} +inline void SkyWritingCfg::set_limitemax(double value) { + _internal_set_limitemax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limiteMax) +} +inline double SkyWritingCfg::_internal_limitemax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.limitemax_; +} +inline void SkyWritingCfg::_internal_set_limitemax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.limitemax_ = value; +} + +// ------------------------------------------------------------------- + +// PowerCompensate + +// int32 cno = 1; +inline void PowerCompensate::clear_cno() { + _impl_.cno_ = 0; +} +inline ::int32_t PowerCompensate::cno() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.cno) + return _internal_cno(); +} +inline void PowerCompensate::set_cno(::int32_t value) { + _internal_set_cno(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.cno) +} +inline ::int32_t PowerCompensate::_internal_cno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cno_; +} +inline void PowerCompensate::_internal_set_cno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cno_ = value; +} + +// int32 percent = 2; +inline void PowerCompensate::clear_percent() { + _impl_.percent_ = 0; +} +inline ::int32_t PowerCompensate::percent() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.percent) + return _internal_percent(); +} +inline void PowerCompensate::set_percent(::int32_t value) { + _internal_set_percent(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.percent) +} +inline ::int32_t PowerCompensate::_internal_percent() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.percent_; +} +inline void PowerCompensate::_internal_set_percent(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.percent_ = value; +} + +// float value = 3; +inline void PowerCompensate::clear_value() { + _impl_.value_ = 0; +} +inline float PowerCompensate::value() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.value) + return _internal_value(); +} +inline void PowerCompensate::set_value(float value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.value) +} +inline float PowerCompensate::_internal_value() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.value_; +} +inline void PowerCompensate::_internal_set_value(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.value_ = value; +} + +// float value_min = 4; +inline void PowerCompensate::clear_value_min() { + _impl_.value_min_ = 0; +} +inline float PowerCompensate::value_min() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.value_min) + return _internal_value_min(); +} +inline void PowerCompensate::set_value_min(float value) { + _internal_set_value_min(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.value_min) +} +inline float PowerCompensate::_internal_value_min() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.value_min_; +} +inline void PowerCompensate::_internal_set_value_min(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.value_min_ = value; +} + +// float value_max = 5; +inline void PowerCompensate::clear_value_max() { + _impl_.value_max_ = 0; +} +inline float PowerCompensate::value_max() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.value_max) + return _internal_value_max(); +} +inline void PowerCompensate::set_value_max(float value) { + _internal_set_value_max(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.value_max) +} +inline float PowerCompensate::_internal_value_max() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.value_max_; +} +inline void PowerCompensate::_internal_set_value_max(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.value_max_ = value; +} + +// ------------------------------------------------------------------- + +// TimePowerCompensate + +// int32 id = 1; +inline void TimePowerCompensate::clear_id() { + _impl_.id_ = 0; +} +inline ::int32_t TimePowerCompensate::id() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.id) + return _internal_id(); +} +inline void TimePowerCompensate::set_id(::int32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.id) +} +inline ::int32_t TimePowerCompensate::_internal_id() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.id_; +} +inline void TimePowerCompensate::_internal_set_id(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.id_ = value; +} + +// int32 cno = 2; +inline void TimePowerCompensate::clear_cno() { + _impl_.cno_ = 0; +} +inline ::int32_t TimePowerCompensate::cno() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.cno) + return _internal_cno(); +} +inline void TimePowerCompensate::set_cno(::int32_t value) { + _internal_set_cno(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.cno) +} +inline ::int32_t TimePowerCompensate::_internal_cno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cno_; +} +inline void TimePowerCompensate::_internal_set_cno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cno_ = value; +} + +// uint32 startMinute = 3; +inline void TimePowerCompensate::clear_startminute() { + _impl_.startminute_ = 0u; +} +inline ::uint32_t TimePowerCompensate::startminute() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.startMinute) + return _internal_startminute(); +} +inline void TimePowerCompensate::set_startminute(::uint32_t value) { + _internal_set_startminute(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.startMinute) +} +inline ::uint32_t TimePowerCompensate::_internal_startminute() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.startminute_; +} +inline void TimePowerCompensate::_internal_set_startminute(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.startminute_ = value; +} + +// uint32 endMinute = 4; +inline void TimePowerCompensate::clear_endminute() { + _impl_.endminute_ = 0u; +} +inline ::uint32_t TimePowerCompensate::endminute() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.endMinute) + return _internal_endminute(); +} +inline void TimePowerCompensate::set_endminute(::uint32_t value) { + _internal_set_endminute(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.endMinute) +} +inline ::uint32_t TimePowerCompensate::_internal_endminute() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.endminute_; +} +inline void TimePowerCompensate::_internal_set_endminute(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.endminute_ = value; +} + +// float compensate = 5; +inline void TimePowerCompensate::clear_compensate() { + _impl_.compensate_ = 0; +} +inline float TimePowerCompensate::compensate() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.compensate) + return _internal_compensate(); +} +inline void TimePowerCompensate::set_compensate(float value) { + _internal_set_compensate(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.compensate) +} +inline float TimePowerCompensate::_internal_compensate() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.compensate_; +} +inline void TimePowerCompensate::_internal_set_compensate(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.compensate_ = value; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ diff --git a/PrintS/protobuf/stream.proto b/PrintS/protobuf/stream.proto index bd2e304..d5ff934 100644 --- a/PrintS/protobuf/stream.proto +++ b/PrintS/protobuf/stream.proto @@ -48,6 +48,15 @@ message ParamInfo{ int32 startLayer = 8; //层供粉量配置使用 struct PowderSet int32 endLayer = 9; float powder = 10; + + int32 seqNo = 11; //ScannerControlCfg使用 + int32 controlNo = 12; + int32 serialNo = 13; + int32 controlType = 14; + bytes cardName = 15; + bytes cardIP = 16; + bool hadAssign = 17; + bool hadMatch = 18; //isEnable公用 } message RequestInfo { //读 @@ -135,9 +144,174 @@ message ComResponce{ bytes data = 1; } +//ScannerCrtlCfg结构体 +message ScannerCrtlCfgResp{ + repeated ScannerCrtlCfgData scannerCfg = 1; +} + +message ScannerCrtlCfgData{ + int32 seqNo = 1; + + repeated FixPointData fixPointData = 2; + ScanParamCfg scanParamCfg = 3; + ScanParamCfg hatchingParams = 4; + ScanParamCfg borderParams = 5; + ScanParamCfg supportParams = 6; + CorrectParamCfg correctParamCfg = 7; + ScanTestCfg scanTestCfg = 8; + SkyWritingCfg skyWritingCfg = 9; + repeated PowerCompensate powerCompensate = 10; + repeated TimePowerCompensate tPowerCompensate = 11; + + int32 controlNo = 12; + int32 serialNo = 13; + int32 controlType = 14; + bytes cardName = 15; + bytes cardIP = 16; + bool isEnable = 17; //是否启动 + bool hadAssign = 18; + bool hadMatch = 19; +} + +message FixPointData{ + int32 id = 1; + int32 cno = 2; + float pointX = 3; + float pointY = 4; + uint32 duration = 5; +} + + + +message ScanParamCfg{ + int32 edgeLevel = 1; + int32 edgeLevelMin = 2; + int32 edgeLevelMax = 3; + uint32 jumpDelay = 4; + uint32 jumpDelayMin = 5; + uint32 jumpDelayMax = 6; + uint32 scanDelay = 7; + uint32 scanDelayMin = 8; + uint32 scanDelayMax = 9; + uint32 polygonDelay = 10; + uint32 polygonDelayMin = 11; + uint32 polygonDelayMax = 12; + int64 laseroffDelay = 13; + int64 laseroffDelayMin = 14; + int64 laseroffDelayMax = 15; + int64 laseronDelay = 16; + int64 laseronDelayMin = 17; + int64 laseronDelayMax = 18; + uint32 minJumpDelay = 19; + uint32 minJumpDelayMin = 20; + uint32 minJumpDelayMax = 21; + uint32 jumpLengthLimit = 22; + uint32 jumpLengthLimitMin = 23; + uint32 jumpLengthLimitMax = 24; + double jumpSpeed = 25; + double jumpSpeedMin = 26; + double jumpSpeedMax = 27; + double markSpeed = 28; + double markSpeedMin = 29; + double markSpeedMax = 30; +} + +message CorrectParamCfg{ + double xmeasureMin = 1; //x可打印最小位置 + double xmeasureMax = 2; //x可打印最大位置 + double ymeasureMin = 3; //y可打印最小位置 + double ymeasureMax = 4; //y可打印最大位置 + double xposfix = 5; //x位置修正 + double yposfix = 6; //y位置修正 + double scanAngle = 7; //旋转角度 逆时针 + double scanAngleMin = 8; + double scanAngleMax = 9; + double fixAngle = 10; //旋转角度 逆时针 + double fixAngleMin = 11; + double fixAngleMax = 12; + double xcorrect = 13; //x尺寸修正 + double ycorrect = 14; //y尺寸修正 + double xcorrectMin = 15; + double xcorrectMax = 16; + double ycorrectMin = 17; + double ycorrectMax = 18; + double realXOffset = 19; + double realYOffset = 20; + double factorK = 21; + bool isCorrectFile3D = 22; + bool isDynamicFocus = 23; //是否动态聚焦 + double defocusRatio = 24; //离焦比 + double defocusRatioMin = 25; + double defocusRatioMax = 26; +} + +message ScanTestCfg{ + int32 debugShape = 1; + int32 shapeSize = 2; + int32 shapeSizeMin = 3; + int32 shape_size_max = 4; + int32 laser_power = 5; + int32 laser_power_min = 6; + int32 laser_power_max = 7; + double defocus = 8; + double defocus_min = 9; + double defocus_max = 10; + bool is_cycle = 11; + double cross_x = 12; + double cross_y = 13; + double z_distance = 14; + bool isAutoHeatingScanner = 15; //开启暂停开始时预热振镜 + uint32 autoHeatingScannerMinutes = 16; + uint32 autoHeatingScannerSize = 17; + double autoHeatingScannerSpeed = 18; + double mark_test_start_x = 19; + double mark_test_start_y = 20; + double mark_test_end_x = 21; + double mark_test_end_y = 22; +} + +message SkyWritingCfg{ + bool isEnable = 1; + double timelag = 2; + double timelagMin = 3; + double timelagMax = 4; + int64 laserOnShift = 5; + int64 laserOnShiftMin = 6; + int64 laserOnShiftMax = 7; + uint32 nprev = 8; + uint32 nprevMin =9; + uint32 nprevMax = 10; + uint32 npost = 11; + uint32 npostMin = 12; + uint32 npostMax = 13; + int32 mode = 14; + double limite = 15; + double limiteMin = 16; + double limiteMax = 17; +} + + +message PowerCompensate{ + int32 cno = 1; + int32 percent = 2; + float value = 3; + float value_min = 4; + float value_max = 5; +} + +message TimePowerCompensate{ + int32 id = 1; + int32 cno = 2; + uint32 startMinute = 3; + uint32 endMinute = 4; + float compensate = 5; +} + service Stream { rpc Simple(RequestInfo) returns (ResponseAny) {} // 简单模式 rpc ServerStream (RequestInfo) returns (stream ResponseInfo) {} // 服务端数据流模式 rpc ClientStream (stream RequestInfo) returns (ResponseInfo) {} // 客户端数据流模式 rpc AllStream (stream RequestInfo) returns (stream ResponseInfo) {} // 双向数据流模式 } + + diff --git a/TestClient/DataManage/DataHandle.cpp b/TestClient/DataManage/DataHandle.cpp index f237791..ba4cd32 100644 --- a/TestClient/DataManage/DataHandle.cpp +++ b/TestClient/DataManage/DataHandle.cpp @@ -90,6 +90,11 @@ void DataHandle::PrintValue(const ReadData& msg){ printf("接收:dataType:%d,startLayer:%d,endLayer:%d,powder:%.2f\n", msg.dataType,it->start_layer, it->end_layer, it->powder); } + //else if (msg.dataType == SCANNERCONTROLCFGPARAM) { + // printf("接收:dataType:%d,seqNo:%d,controlNo:%d,serialNo:%d,controlType:%d,cardName:%s,cardIP:%s,isEnable:%d,hadAssign:%d,hadMatch:%d\n", + // msg.dataType, it->seqNo, it->controlNo, it->serialNo, it->controlType, + // it->cardName.data(), it->cardIP.data(),it->isEnable, it->hadAssign,it->hadMatch); + //} else { printf("接收:dataType:%d,nameKey:%*s, strvalue:%*s, valueType:%s\n", msg.dataType, 33, it->nameKey.data(), 13, it->strValue.data(), valueType.data()); @@ -185,18 +190,21 @@ void DataHandle::ParamReadUsage() { printf(" 37: " COLOR_YELLOW "print pausealarm cfg param data...\n" COLOR_RESET); printf(" 38: " COLOR_YELLOW "print warnalarm cfg param data...\n" COLOR_RESET); printf(" 39: " COLOR_YELLOW "print powder cfg param data...\n" COLOR_RESET); + printf(" 40: " COLOR_YELLOW "print powder cfg param data...\n" COLOR_RESET); + printf(" 41: " COLOR_YELLOW "print scaner ctrl cfg param data...\n" COLOR_RESET); - printf(" 40: " COLOR_YELLOW "print moldcfg param data...\n" COLOR_RESET); - printf(" 41: " COLOR_YELLOW "print loadcfg param data...\n" COLOR_RESET); - printf(" 42: " COLOR_YELLOW "print armcfgparam data...\n" COLOR_RESET); - printf(" 43: " COLOR_YELLOW "print supplycfgparam data...\n" COLOR_RESET); - printf(" 44: " COLOR_YELLOW "print cleancfgparam data...\n" COLOR_RESET); - printf(" 45: " COLOR_YELLOW "print elecfgparam data...\n" COLOR_RESET); - printf(" 46: " COLOR_YELLOW "print loadparamrsp data...\n" COLOR_RESET); - printf(" 47: " COLOR_YELLOW "print scan ctrl state data...\n" COLOR_RESET); - printf(" 48: " COLOR_YELLOW "print scan ctrl Param data...\n" COLOR_RESET); - printf(" 49: " COLOR_YELLOW "print xy scan state data...\n" COLOR_RESET); - printf(" 50: " COLOR_YELLOW "print camera param data...\n" COLOR_RESET); + printf(" 42: " COLOR_YELLOW "print moldcfg param data...\n" COLOR_RESET); + printf(" 43: " COLOR_YELLOW "print loadcfg param data...\n" COLOR_RESET); + printf(" 44: " COLOR_YELLOW "print armcfgparam data...\n" COLOR_RESET); + printf(" 45: " COLOR_YELLOW "print supplycfgparam data...\n" COLOR_RESET); + printf(" 46: " COLOR_YELLOW "print cleancfgparam data...\n" COLOR_RESET); + printf(" 47: " COLOR_YELLOW "print elecfgparam data...\n" COLOR_RESET); + printf(" 48: " COLOR_YELLOW "print loadparamrsp data...\n" COLOR_RESET); + printf(" 49: " COLOR_YELLOW "print scan ctrl state data...\n" COLOR_RESET); + printf(" 50: " COLOR_YELLOW "print scan ctrl Param data...\n" COLOR_RESET); + printf(" 51: " COLOR_YELLOW "print xy scan state data...\n" COLOR_RESET); + printf(" 52: " COLOR_YELLOW "print camera param data...\n" COLOR_RESET); + } int DataHandle::Request(int index) { @@ -235,7 +243,7 @@ int DataHandle::Request(int index) { ParamReadUsage(); } else if (userInput.find("push") != string::npos) { - UpdateParam(userInput); + UpdateParamToService(userInput); } else { ParamRequest(ConverType::TryToI(userInput)); @@ -264,6 +272,18 @@ void DataHandle::ParamRequest(int index) { if (index == VERSIONRSP) { PushMsg(VERSIONREQ); //获取版本信息 } + if (index == SCANERCTRLCFGPARAM) { + ::stream::ResponseAny resp; + stream::ScannerCrtlCfgResp result; + + WriteData wdata{ SCANERCTRLCFG }; + m_streamClient->Request(wdata, &resp); + if (resp.data().Is()) { + resp.data().UnpackTo(&result); + PrintScanerCfg(result); + } + index = -1; + } else if (index >= PARAMLIMITCFGPARAM && index <= ELECFGPARAM) { PushMsg(REQUEST); } @@ -289,8 +309,62 @@ void DataHandle::ParamRequest(int index) { } +void DataHandle::PrintScanerCfg(const stream::ScannerCrtlCfgResp& result) { + result.scannercfg().size(); + for (auto& rsp : result.scannercfg()) { + printf("seqNo:%d\n",rsp.seqno()); + printf("controlno:%d,serialno:%d,controlType:%d,cardname:%s,cardip:%s,isenable:%d,hadassign:%d,hadmatch:%d\n", + rsp.controlno(), rsp.serialno(), rsp.controltype(), rsp.cardname().data(), rsp.cardip().data(), rsp.isenable(), rsp.hadassign(), rsp.hadmatch()); + + for (auto& fp : rsp.fixpointdata()) { + printf("(pixpoint)id:%d,cno:%d,pointx:%f,pointy:%f,duration:%d\n" + , fp.id(), fp.cno(), fp.pointx(), fp.pointy(), fp.duration()); + } + + //打印部分内容 + auto& spc = rsp.scanparamcfg(); + printf("(scanparamcfg)edgelevel:%d,edgelevelmin:%d,edgelevelmax:%d,jumpDelay:%u\n", + spc.edgelevel(), spc.edgelevelmin(), spc.edgelevelmax(), spc.jumpdelay()); + + auto& hp = rsp.hatchingparams(); + printf("(hatchingparams)edgelevel:%d,edgelevelmin:%d,edgelevelmax:%d,jumpDelay:%u\n", + hp.edgelevel(), hp.edgelevelmin(), hp.edgelevelmax(), hp.jumpdelay()); + + auto& bp = rsp.borderparams(); + printf("(borderParams)edgelevel:%d,edgelevelmin:%d,edgelevelmax:%d,jumpDelay:%u\n", + hp.edgelevel(), hp.edgelevelmin(), hp.edgelevelmax(), hp.jumpdelay()); + + auto& sp = rsp.supportparams(); + printf("(supportparams)edgelevel:%d,edgelevelmin:%d,edgelevelmax:%d,jumpDelay:%u\n", + sp.edgelevel(), sp.edgelevelmin(), sp.edgelevelmax(), sp.jumpdelay()); + + auto& cpc = rsp.correctparamcfg(); + printf("(correctparamcfg)xmeasuremin:%.3f,xmeasuremax:%.3f,ymeasuremin:%.3f,ymeasuremax:%.3f\n", + cpc.xmeasuremin(), cpc.xmeasuremax(), cpc.ymeasuremin(), cpc.ymeasuremax()); + + auto& stc = rsp.scantestcfg(); + printf("(scantestcfg)debugshape:%d,shapesize:%d,shapesizemin:%d,shape_size_max:%d\n", + stc.debugshape(), stc.shapesize(), stc.shapesizemin(), stc.shape_size_max()); + + auto& swc = rsp.skywritingcfg(); + printf("(skywritingcfg)debugshape:%d,shapesize:%.3f,shapesizemin:%.3f,shape_size_max:%.3f\n", + swc.isenable(), swc.timelag(), swc.timelagmin(), swc.timelagmax()); + + for (auto& pc : rsp.powercompensate()) { + printf("(powercompensate)cno:%d,percent:%d,value:%.3f,value_min:%.3f,value_max:%.3f\n", + pc.cno(), pc.percent(), pc.value(), pc.value_min(),pc.value_max()); + } + + for (auto& tpc : rsp.tpowercompensate()) { + printf("(tpowercompensate)cno:%d,id:%d,value:%u,value_min:%u,value_max:%.3f\n", + tpc.cno(), tpc.id(), tpc.startminute(), tpc.endminute(), tpc.compensate()); + } + } + +} + //选择一个参数更新到服务 -void DataHandle::UpdateParam(const string& input) { +void DataHandle::UpdateParamToService(const string& input) { WriteData writeData; int index = ConverType::TryToI(input.substr(5)); switch (index) { @@ -338,6 +412,8 @@ void DataHandle::UpdateParam(const string& input) { writeData.items.emplace_back(Item{"","",UNKNOW,"",0,0,0,1,100,2}); PushMsg(writeData); break; + case SCANERCTRLCFGPARAM: + break; case ELECFGPARAM: break; case LOADPARAMRSP: diff --git a/TestClient/DataManage/DataHandle.h b/TestClient/DataManage/DataHandle.h index 2a9a707..4b11389 100644 --- a/TestClient/DataManage/DataHandle.h +++ b/TestClient/DataManage/DataHandle.h @@ -34,7 +34,7 @@ public: void PurifierTest(); //净化器功能测试 void ConfigTest(); //配置功能测试 - void UpdateParam(const string& input); + void UpdateParamToService(const string& input); void Usage(); void ParamReadUsage(); @@ -44,7 +44,7 @@ public: private: void DataCallBackHandle(const ReadData& msg); void PrintValue(const ReadData& msg); - + void PrintScanerCfg(const stream::ScannerCrtlCfgResp& result); //打印config的特殊配置 private: DataCallBack m_dataCallBack; StreamClient* m_streamClient; diff --git a/TestClient/DataManage/RWData.h b/TestClient/DataManage/RWData.h index 55bf19f..6d91078 100644 --- a/TestClient/DataManage/RWData.h +++ b/TestClient/DataManage/RWData.h @@ -51,6 +51,8 @@ enum READTYPE { PAUSEALARMCFGPARAM, //AlarmCfgWrapper pause参数 WARNALARMCFGPARAM, //AlarmCfgWrapper warn参数 POWDERSETPARAM, //PowderSet 参数 + SCANNERCONTROLCFGPARAM, //ScannerControlCfg 参数 + SCANERCTRLCFGPARAM, //scanerctrlcfg 参数 MOLDCFGPARAM, LOADCFGPARAM, @@ -103,6 +105,16 @@ struct Item { int start_layer; int end_layer; float powder; + + int seqNo; //ScannerControlCfg使用 + int controlNo; + int serialNo; + int controlType; + std::string cardName; + std::string cardIP; + //bool isEnable; //是否启动 + bool hadAssign; + bool hadMatch; }; struct ReadData { @@ -145,6 +157,7 @@ enum WRITETYPE { COMMUNICATIONCFG, ALARMCFG, POWDERSET, + SCANERCTRLCFG, LOADPARAM, //装载参数 SCANCTRLFUNC, //振镜控制函数 diff --git a/TestClient/DataManage/StreamClient.cpp b/TestClient/DataManage/StreamClient.cpp index cb308d6..bc336e9 100644 --- a/TestClient/DataManage/StreamClient.cpp +++ b/TestClient/DataManage/StreamClient.cpp @@ -71,11 +71,11 @@ void StreamClient::AllStream() { while (!m_readQuitFlag && stream->Read(&readInfo)) { ReadData readData; readData.dataType = (READTYPE)readInfo.datatype(); - for (const ::stream::ParamInfo& it : readInfo.item()) { readData.its.emplace_back(Item{ it.namekey(),it.strvalue(),(DATATYPE)it.valuetype() ,it.context(),it.isenable(),it.isalarm(),it.isshow() - ,it.startlayer(),it.endlayer(),it.powder() }); + ,it.startlayer(),it.endlayer(),it.powder(),it.seqno(),it.controlno(),it.serialno() + ,it.controltype(),it.cardname(),it.cardip(),it.hadassign(),it.hadmatch()}); //printf("接收到服务端消息：dataType:%d,nameKey:%s, strvalue:%s,valueType:%d\n", // readData.dataType, it.namekey().data(), it.strvalue().c_str(), it.valuetype()); } @@ -110,7 +110,6 @@ void StreamClient::AllStream() { } stream->Write(request); - //printf("write code:%d\n", ret); } else { std::this_thread::sleep_for(std::chrono::milliseconds(100)); diff --git a/TestClient/protobuf/stream.pb.cc b/TestClient/protobuf/stream.pb.cc index 4f1ed96..e7673c2 100644 --- a/TestClient/protobuf/stream.pb.cc +++ b/TestClient/protobuf/stream.pb.cc @@ -36,13 +36,27 @@ PROTOBUF_CONSTEXPR ParamInfo::ParamInfo(::_pbi::ConstantInitialized) &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}, }, + /*decltype(_impl_.cardname_)*/ { + &::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}, + }, + /*decltype(_impl_.cardip_)*/ { + &::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}, + }, /*decltype(_impl_.valuetype_)*/ 0, + /*decltype(_impl_.startlayer_)*/ 0, /*decltype(_impl_.isenable_)*/ false, /*decltype(_impl_.isalarm_)*/ false, /*decltype(_impl_.isshow_)*/ false, - /*decltype(_impl_.startlayer_)*/ 0, + /*decltype(_impl_.hadassign_)*/ false, /*decltype(_impl_.endlayer_)*/ 0, /*decltype(_impl_.powder_)*/ 0, + /*decltype(_impl_.seqno_)*/ 0, + /*decltype(_impl_.controlno_)*/ 0, + /*decltype(_impl_.serialno_)*/ 0, + /*decltype(_impl_.controltype_)*/ 0, + /*decltype(_impl_.hadmatch_)*/ false, /*decltype(_impl_._cached_size_)*/ {}, } {} struct ParamInfoDefaultTypeInternal { @@ -264,8 +278,280 @@ struct ComResponceDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ComResponceDefaultTypeInternal _ComResponce_default_instance_; + template +PROTOBUF_CONSTEXPR ScannerCrtlCfgResp::ScannerCrtlCfgResp(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.scannercfg_)*/ {}, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct ScannerCrtlCfgRespDefaultTypeInternal { + PROTOBUF_CONSTEXPR ScannerCrtlCfgRespDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ScannerCrtlCfgRespDefaultTypeInternal() {} + union { + ScannerCrtlCfgResp _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScannerCrtlCfgRespDefaultTypeInternal _ScannerCrtlCfgResp_default_instance_; + template +PROTOBUF_CONSTEXPR ScannerCrtlCfgData::ScannerCrtlCfgData(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_._has_bits_)*/ {}, + /*decltype(_impl_._cached_size_)*/ {}, + /*decltype(_impl_.fixpointdata_)*/ {}, + /*decltype(_impl_.powercompensate_)*/ {}, + /*decltype(_impl_.tpowercompensate_)*/ {}, + /*decltype(_impl_.cardname_)*/ { + &::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}, + }, + /*decltype(_impl_.cardip_)*/ { + &::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}, + }, + /*decltype(_impl_.scanparamcfg_)*/ nullptr, + /*decltype(_impl_.hatchingparams_)*/ nullptr, + /*decltype(_impl_.borderparams_)*/ nullptr, + /*decltype(_impl_.supportparams_)*/ nullptr, + /*decltype(_impl_.correctparamcfg_)*/ nullptr, + /*decltype(_impl_.scantestcfg_)*/ nullptr, + /*decltype(_impl_.skywritingcfg_)*/ nullptr, + /*decltype(_impl_.seqno_)*/ 0, + /*decltype(_impl_.controlno_)*/ 0, + /*decltype(_impl_.serialno_)*/ 0, + /*decltype(_impl_.controltype_)*/ 0, + /*decltype(_impl_.isenable_)*/ false, + /*decltype(_impl_.hadassign_)*/ false, + /*decltype(_impl_.hadmatch_)*/ false, + } {} +struct ScannerCrtlCfgDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR ScannerCrtlCfgDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ScannerCrtlCfgDataDefaultTypeInternal() {} + union { + ScannerCrtlCfgData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScannerCrtlCfgDataDefaultTypeInternal _ScannerCrtlCfgData_default_instance_; + template +PROTOBUF_CONSTEXPR FixPointData::FixPointData(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.id_)*/ 0, + /*decltype(_impl_.cno_)*/ 0, + /*decltype(_impl_.pointx_)*/ 0, + /*decltype(_impl_.pointy_)*/ 0, + /*decltype(_impl_.duration_)*/ 0u, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct FixPointDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR FixPointDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~FixPointDataDefaultTypeInternal() {} + union { + FixPointData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FixPointDataDefaultTypeInternal _FixPointData_default_instance_; + template +PROTOBUF_CONSTEXPR ScanParamCfg::ScanParamCfg(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.edgelevel_)*/ 0, + /*decltype(_impl_.edgelevelmin_)*/ 0, + /*decltype(_impl_.edgelevelmax_)*/ 0, + /*decltype(_impl_.jumpdelay_)*/ 0u, + /*decltype(_impl_.jumpdelaymin_)*/ 0u, + /*decltype(_impl_.jumpdelaymax_)*/ 0u, + /*decltype(_impl_.scandelay_)*/ 0u, + /*decltype(_impl_.scandelaymin_)*/ 0u, + /*decltype(_impl_.scandelaymax_)*/ 0u, + /*decltype(_impl_.polygondelay_)*/ 0u, + /*decltype(_impl_.polygondelaymin_)*/ 0u, + /*decltype(_impl_.polygondelaymax_)*/ 0u, + /*decltype(_impl_.laseroffdelay_)*/ ::int64_t{0}, + /*decltype(_impl_.laseroffdelaymin_)*/ ::int64_t{0}, + /*decltype(_impl_.laseroffdelaymax_)*/ ::int64_t{0}, + /*decltype(_impl_.laserondelay_)*/ ::int64_t{0}, + /*decltype(_impl_.laserondelaymin_)*/ ::int64_t{0}, + /*decltype(_impl_.laserondelaymax_)*/ ::int64_t{0}, + /*decltype(_impl_.minjumpdelay_)*/ 0u, + /*decltype(_impl_.minjumpdelaymin_)*/ 0u, + /*decltype(_impl_.minjumpdelaymax_)*/ 0u, + /*decltype(_impl_.jumplengthlimit_)*/ 0u, + /*decltype(_impl_.jumplengthlimitmin_)*/ 0u, + /*decltype(_impl_.jumplengthlimitmax_)*/ 0u, + /*decltype(_impl_.jumpspeed_)*/ 0, + /*decltype(_impl_.jumpspeedmin_)*/ 0, + /*decltype(_impl_.jumpspeedmax_)*/ 0, + /*decltype(_impl_.markspeed_)*/ 0, + /*decltype(_impl_.markspeedmin_)*/ 0, + /*decltype(_impl_.markspeedmax_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct ScanParamCfgDefaultTypeInternal { + PROTOBUF_CONSTEXPR ScanParamCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ScanParamCfgDefaultTypeInternal() {} + union { + ScanParamCfg _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScanParamCfgDefaultTypeInternal _ScanParamCfg_default_instance_; + template +PROTOBUF_CONSTEXPR CorrectParamCfg::CorrectParamCfg(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.xmeasuremin_)*/ 0, + /*decltype(_impl_.xmeasuremax_)*/ 0, + /*decltype(_impl_.ymeasuremin_)*/ 0, + /*decltype(_impl_.ymeasuremax_)*/ 0, + /*decltype(_impl_.xposfix_)*/ 0, + /*decltype(_impl_.yposfix_)*/ 0, + /*decltype(_impl_.scanangle_)*/ 0, + /*decltype(_impl_.scananglemin_)*/ 0, + /*decltype(_impl_.scananglemax_)*/ 0, + /*decltype(_impl_.fixangle_)*/ 0, + /*decltype(_impl_.fixanglemin_)*/ 0, + /*decltype(_impl_.fixanglemax_)*/ 0, + /*decltype(_impl_.xcorrect_)*/ 0, + /*decltype(_impl_.ycorrect_)*/ 0, + /*decltype(_impl_.xcorrectmin_)*/ 0, + /*decltype(_impl_.xcorrectmax_)*/ 0, + /*decltype(_impl_.ycorrectmin_)*/ 0, + /*decltype(_impl_.ycorrectmax_)*/ 0, + /*decltype(_impl_.realxoffset_)*/ 0, + /*decltype(_impl_.realyoffset_)*/ 0, + /*decltype(_impl_.factork_)*/ 0, + /*decltype(_impl_.defocusratio_)*/ 0, + /*decltype(_impl_.defocusratiomin_)*/ 0, + /*decltype(_impl_.defocusratiomax_)*/ 0, + /*decltype(_impl_.iscorrectfile3d_)*/ false, + /*decltype(_impl_.isdynamicfocus_)*/ false, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct CorrectParamCfgDefaultTypeInternal { + PROTOBUF_CONSTEXPR CorrectParamCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CorrectParamCfgDefaultTypeInternal() {} + union { + CorrectParamCfg _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CorrectParamCfgDefaultTypeInternal _CorrectParamCfg_default_instance_; + template +PROTOBUF_CONSTEXPR ScanTestCfg::ScanTestCfg(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.debugshape_)*/ 0, + /*decltype(_impl_.shapesize_)*/ 0, + /*decltype(_impl_.shapesizemin_)*/ 0, + /*decltype(_impl_.shape_size_max_)*/ 0, + /*decltype(_impl_.laser_power_)*/ 0, + /*decltype(_impl_.laser_power_min_)*/ 0, + /*decltype(_impl_.defocus_)*/ 0, + /*decltype(_impl_.defocus_min_)*/ 0, + /*decltype(_impl_.defocus_max_)*/ 0, + /*decltype(_impl_.laser_power_max_)*/ 0, + /*decltype(_impl_.is_cycle_)*/ false, + /*decltype(_impl_.isautoheatingscanner_)*/ false, + /*decltype(_impl_.cross_x_)*/ 0, + /*decltype(_impl_.cross_y_)*/ 0, + /*decltype(_impl_.z_distance_)*/ 0, + /*decltype(_impl_.autoheatingscannerminutes_)*/ 0u, + /*decltype(_impl_.autoheatingscannersize_)*/ 0u, + /*decltype(_impl_.autoheatingscannerspeed_)*/ 0, + /*decltype(_impl_.mark_test_start_x_)*/ 0, + /*decltype(_impl_.mark_test_start_y_)*/ 0, + /*decltype(_impl_.mark_test_end_x_)*/ 0, + /*decltype(_impl_.mark_test_end_y_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct ScanTestCfgDefaultTypeInternal { + PROTOBUF_CONSTEXPR ScanTestCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ScanTestCfgDefaultTypeInternal() {} + union { + ScanTestCfg _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScanTestCfgDefaultTypeInternal _ScanTestCfg_default_instance_; + template +PROTOBUF_CONSTEXPR SkyWritingCfg::SkyWritingCfg(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.timelag_)*/ 0, + /*decltype(_impl_.timelagmin_)*/ 0, + /*decltype(_impl_.timelagmax_)*/ 0, + /*decltype(_impl_.isenable_)*/ false, + /*decltype(_impl_.nprev_)*/ 0u, + /*decltype(_impl_.laseronshift_)*/ ::int64_t{0}, + /*decltype(_impl_.laseronshiftmin_)*/ ::int64_t{0}, + /*decltype(_impl_.laseronshiftmax_)*/ ::int64_t{0}, + /*decltype(_impl_.nprevmin_)*/ 0u, + /*decltype(_impl_.nprevmax_)*/ 0u, + /*decltype(_impl_.npost_)*/ 0u, + /*decltype(_impl_.npostmin_)*/ 0u, + /*decltype(_impl_.npostmax_)*/ 0u, + /*decltype(_impl_.mode_)*/ 0, + /*decltype(_impl_.limite_)*/ 0, + /*decltype(_impl_.limitemin_)*/ 0, + /*decltype(_impl_.limitemax_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct SkyWritingCfgDefaultTypeInternal { + PROTOBUF_CONSTEXPR SkyWritingCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SkyWritingCfgDefaultTypeInternal() {} + union { + SkyWritingCfg _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkyWritingCfgDefaultTypeInternal _SkyWritingCfg_default_instance_; + template +PROTOBUF_CONSTEXPR PowerCompensate::PowerCompensate(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.cno_)*/ 0, + /*decltype(_impl_.percent_)*/ 0, + /*decltype(_impl_.value_)*/ 0, + /*decltype(_impl_.value_min_)*/ 0, + /*decltype(_impl_.value_max_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct PowerCompensateDefaultTypeInternal { + PROTOBUF_CONSTEXPR PowerCompensateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PowerCompensateDefaultTypeInternal() {} + union { + PowerCompensate _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PowerCompensateDefaultTypeInternal _PowerCompensate_default_instance_; + template +PROTOBUF_CONSTEXPR TimePowerCompensate::TimePowerCompensate(::_pbi::ConstantInitialized) + : _impl_{ + /*decltype(_impl_.id_)*/ 0, + /*decltype(_impl_.cno_)*/ 0, + /*decltype(_impl_.startminute_)*/ 0u, + /*decltype(_impl_.endminute_)*/ 0u, + /*decltype(_impl_.compensate_)*/ 0, + /*decltype(_impl_._cached_size_)*/ {}, + } {} +struct TimePowerCompensateDefaultTypeInternal { + PROTOBUF_CONSTEXPR TimePowerCompensateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~TimePowerCompensateDefaultTypeInternal() {} + union { + TimePowerCompensate _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TimePowerCompensateDefaultTypeInternal _TimePowerCompensate_default_instance_; } // namespace stream -static ::_pb::Metadata file_level_metadata_stream_2eproto[12]; +static ::_pb::Metadata file_level_metadata_stream_2eproto[21]; static const ::_pb::EnumDescriptor* file_level_enum_descriptors_stream_2eproto[2]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_stream_2eproto = nullptr; @@ -289,6 +575,14 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.startlayer_), PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.endlayer_), PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.powder_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.seqno_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.controlno_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.serialno_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.controltype_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.cardname_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.cardip_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.hadassign_), + PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.hadmatch_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::stream::RequestInfo, _internal_metadata_), ~0u, // no _extensions_ @@ -412,22 +706,252 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::stream::ComResponce, _impl_.data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgResp, _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::ScannerCrtlCfgResp, _impl_.scannercfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _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::ScannerCrtlCfgData, _impl_.seqno_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.fixpointdata_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.scanparamcfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hatchingparams_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.borderparams_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.supportparams_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.correctparamcfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.scantestcfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.skywritingcfg_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.powercompensate_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.tpowercompensate_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.controlno_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.serialno_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.controltype_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.cardname_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.cardip_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.isenable_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hadassign_), + PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hadmatch_), + ~0u, + ~0u, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _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::FixPointData, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.cno_), + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.pointx_), + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.pointy_), + PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.duration_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _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::ScanParamCfg, _impl_.edgelevel_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevelmin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevelmax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelay_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelaymin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelaymax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimit_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimitmin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimitmax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeed_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeedmin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeedmax_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeed_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeedmin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeedmax_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _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::CorrectParamCfg, _impl_.xmeasuremin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xmeasuremax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ymeasuremin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ymeasuremax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xposfix_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.yposfix_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scanangle_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scananglemin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scananglemax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixangle_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixanglemin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixanglemax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrect_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrect_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrectmin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrectmax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrectmin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrectmax_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.realxoffset_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.realyoffset_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.factork_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.iscorrectfile3d_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.isdynamicfocus_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratio_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratiomin_), + PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratiomax_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _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::ScanTestCfg, _impl_.debugshape_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shapesize_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shapesizemin_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shape_size_max_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_min_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_max_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_min_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_max_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.is_cycle_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.cross_x_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.cross_y_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.z_distance_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.isautoheatingscanner_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannerminutes_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannersize_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannerspeed_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_start_x_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_start_y_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_end_x_), + PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_end_y_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _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::SkyWritingCfg, _impl_.isenable_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelag_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelagmin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelagmax_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshift_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshiftmin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshiftmax_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprev_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprevmin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprevmax_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npost_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npostmin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npostmax_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.mode_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limite_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limitemin_), + PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limitemax_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _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::PowerCompensate, _impl_.cno_), + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.percent_), + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_), + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_min_), + PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_max_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _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::TimePowerCompensate, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.cno_), + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.startminute_), + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.endminute_), + PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.compensate_), }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::stream::ParamInfo)}, - {18, -1, -1, sizeof(::stream::RequestInfo)}, - {32, -1, -1, sizeof(::stream::ResponseInfo)}, - {43, 52, -1, sizeof(::stream::ResponseAny)}, - {53, -1, -1, sizeof(::stream::LayerData)}, - {66, -1, -1, sizeof(::stream::LayerDataBlock)}, - {80, -1, -1, sizeof(::stream::VectorDataBlock)}, - {92, -1, -1, sizeof(::stream::ChainDataBlock)}, - {102, -1, -1, sizeof(::stream::Point)}, - {112, -1, -1, sizeof(::stream::RegResponce)}, - {121, -1, -1, sizeof(::stream::ImgInfoResponce)}, - {132, -1, -1, sizeof(::stream::ComResponce)}, + {26, -1, -1, sizeof(::stream::RequestInfo)}, + {40, -1, -1, sizeof(::stream::ResponseInfo)}, + {51, 60, -1, sizeof(::stream::ResponseAny)}, + {61, -1, -1, sizeof(::stream::LayerData)}, + {74, -1, -1, sizeof(::stream::LayerDataBlock)}, + {88, -1, -1, sizeof(::stream::VectorDataBlock)}, + {100, -1, -1, sizeof(::stream::ChainDataBlock)}, + {110, -1, -1, sizeof(::stream::Point)}, + {120, -1, -1, sizeof(::stream::RegResponce)}, + {129, -1, -1, sizeof(::stream::ImgInfoResponce)}, + {140, -1, -1, sizeof(::stream::ComResponce)}, + {149, -1, -1, sizeof(::stream::ScannerCrtlCfgResp)}, + {158, 185, -1, sizeof(::stream::ScannerCrtlCfgData)}, + {204, -1, -1, sizeof(::stream::FixPointData)}, + {217, -1, -1, sizeof(::stream::ScanParamCfg)}, + {255, -1, -1, sizeof(::stream::CorrectParamCfg)}, + {289, -1, -1, sizeof(::stream::ScanTestCfg)}, + {319, -1, -1, sizeof(::stream::SkyWritingCfg)}, + {344, -1, -1, sizeof(::stream::PowerCompensate)}, + {357, -1, -1, sizeof(::stream::TimePowerCompensate)}, }; static const ::_pb::Message* const file_default_instances[] = { @@ -443,51 +967,143 @@ static const ::_pb::Message* const file_default_instances[] = { &::stream::_RegResponce_default_instance_._instance, &::stream::_ImgInfoResponce_default_instance_._instance, &::stream::_ComResponce_default_instance_._instance, + &::stream::_ScannerCrtlCfgResp_default_instance_._instance, + &::stream::_ScannerCrtlCfgData_default_instance_._instance, + &::stream::_FixPointData_default_instance_._instance, + &::stream::_ScanParamCfg_default_instance_._instance, + &::stream::_CorrectParamCfg_default_instance_._instance, + &::stream::_ScanTestCfg_default_instance_._instance, + &::stream::_SkyWritingCfg_default_instance_._instance, + &::stream::_PowerCompensate_default_instance_._instance, + &::stream::_TimePowerCompensate_default_instance_._instance, }; const char descriptor_table_protodef_stream_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { "\n\014stream.proto\022\006stream\032\031google/protobuf/" - "any.proto\"\311\001\n\tParamInfo\022\017\n\007nameKey\030\001 \001(\014" + "any.proto\"\331\002\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." "stream.TYPE\022\017\n\007context\030\004 \001(\014\022\020\n\010isEnable" "\030\005 \001(\010\022\017\n\007isAlarm\030\006 \001(\010\022\016\n\006isShow\030\007 \001(\010\022" "\022\n\nstartLayer\030\010 \001(\005\022\020\n\010endLayer\030\t \001(\005\022\016\n" - "\006powder\030\n \001(\002\"\254\001\n\013RequestInfo\022\020\n\010dataTyp" - "e\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\022&\n\nh" - "andleType\030\005 \001(\0162\022.stream.DATAHANDLE\022\037\n\004i" - "tem\030\006 \003(\0132\021.stream.ParamInfo\"Q\n\014Response" - "Info\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\013Respo" - "nseAny\022\"\n\004data\030\001 \001(\0132\024.google.protobuf.A" - "ny\"\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.LayerData" - "Block\022\016\n\006result\030\005 \001(\010\"\266\001\n\016LayerDataBlock" - "\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\013chainBlock" - "s\030\005 \003(\0132\026.stream.ChainDataBlock\022\r\n\005order" - "\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\004endY\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\005Poin" - "t\022\014\n\004xPos\030\001 \001(\002\022\014\n\004yPos\030\002 \001(\002\"\033\n\013RegResp" - "once\022\014\n\004data\030\001 \001(\005\"D\n\017ImgInfoResponce\022\022\n" - "\nlevelImage\030\001 \001(\r\022\r\n\005width\030\002 \001(\005\022\016\n\006heig" - "ht\030\003 \001(\005\"\033\n\013ComResponce\022\014\n\004data\030\001 \001(\014*\223\001" - "\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\006iFLOAT\020\005\022\013\n\007i" - "STRING\020\006\022\t\n\005iCHAR\020\007\022\n\n\006iUCHAR\020\010\022\t\n\005iWORD" - "\020\t\022\013\n\007iDOUBLE\020\n\022\n\n\006iTIMET\020\013**\n\nDATAHANDL" - "E\022\n\n\006UPDATE\020\000\022\007\n\003ADD\020\001\022\007\n\003DEL\020\0022\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" + "\006powder\030\n \001(\002\022\r\n\005seqNo\030\013 \001(\005\022\021\n\tcontrolN" + "o\030\014 \001(\005\022\020\n\010serialNo\030\r \001(\005\022\023\n\013controlType" + "\030\016 \001(\005\022\020\n\010cardName\030\017 \001(\014\022\016\n\006cardIP\030\020 \001(\014" + "\022\021\n\thadAssign\030\021 \001(\010\022\020\n\010hadMatch\030\022 \001(\010\"\254\001" + "\n\013RequestInfo\022\020\n\010dataType\030\001 \001(\r\022\017\n\007nameK" + "ey\030\002 \001(\014\022\020\n\010strValue\030\003 \001(\014\022\037\n\tvalueType\030" + "\004 \001(\0162\014.stream.TYPE\022&\n\nhandleType\030\005 \001(\0162" + "\022.stream.DATAHANDLE\022\037\n\004item\030\006 \003(\0132\021.stre" + "am.ParamInfo\"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.s" + "tream.ParamInfo\"1\n\013ResponseAny\022\"\n\004data\030\001" + " \001(\0132\024.google.protobuf.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.LayerDataBlock\022\016\n\006result\030" + "\005 \001(\010\"\266\001\n\016LayerDataBlock\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.Vecto" + "rDataBlock\022+\n\013chainBlocks\030\005 \003(\0132\026.stream" + ".ChainDataBlock\022\r\n\005order\030\006 \001(\r\"M\n\017Vector" + "DataBlock\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\004endY\030\004 \001(\002\"A\n\016ChainDa" + "taBlock\022\016\n\006dotNum\030\001 \001(\r\022\037\n\010pointVec\030\002 \003(" + "\0132\r.stream.Point\"#\n\005Point\022\014\n\004xPos\030\001 \001(\002\022" + "\014\n\004yPos\030\002 \001(\002\"\033\n\013RegResponce\022\014\n\004data\030\001 \001" + "(\005\"D\n\017ImgInfoResponce\022\022\n\nlevelImage\030\001 \001(" + "\r\022\r\n\005width\030\002 \001(\005\022\016\n\006height\030\003 \001(\005\"\033\n\013ComR" + "esponce\022\014\n\004data\030\001 \001(\014\"D\n\022ScannerCrtlCfgR" + "esp\022.\n\nscannerCfg\030\001 \003(\0132\032.stream.Scanner" + "CrtlCfgData\"\210\005\n\022ScannerCrtlCfgData\022\r\n\005se" + "qNo\030\001 \001(\005\022*\n\014fixPointData\030\002 \003(\0132\024.stream" + ".FixPointData\022*\n\014scanParamCfg\030\003 \001(\0132\024.st" + "ream.ScanParamCfg\022,\n\016hatchingParams\030\004 \001(" + "\0132\024.stream.ScanParamCfg\022*\n\014borderParams\030" + "\005 \001(\0132\024.stream.ScanParamCfg\022+\n\rsupportPa" + "rams\030\006 \001(\0132\024.stream.ScanParamCfg\0220\n\017corr" + "ectParamCfg\030\007 \001(\0132\027.stream.CorrectParamC" + "fg\022(\n\013scanTestCfg\030\010 \001(\0132\023.stream.ScanTes" + "tCfg\022,\n\rskyWritingCfg\030\t \001(\0132\025.stream.Sky" + "WritingCfg\0220\n\017powerCompensate\030\n \003(\0132\027.st" + "ream.PowerCompensate\0225\n\020tPowerCompensate" + "\030\013 \003(\0132\033.stream.TimePowerCompensate\022\021\n\tc" + "ontrolNo\030\014 \001(\005\022\020\n\010serialNo\030\r \001(\005\022\023\n\013cont" + "rolType\030\016 \001(\005\022\020\n\010cardName\030\017 \001(\014\022\016\n\006cardI" + "P\030\020 \001(\014\022\020\n\010isEnable\030\021 \001(\010\022\021\n\thadAssign\030\022" + " \001(\010\022\020\n\010hadMatch\030\023 \001(\010\"Y\n\014FixPointData\022\n" + "\n\002id\030\001 \001(\005\022\013\n\003cno\030\002 \001(\005\022\016\n\006pointX\030\003 \001(\002\022" + "\016\n\006pointY\030\004 \001(\002\022\020\n\010duration\030\005 \001(\r\"\275\005\n\014Sc" + "anParamCfg\022\021\n\tedgeLevel\030\001 \001(\005\022\024\n\014edgeLev" + "elMin\030\002 \001(\005\022\024\n\014edgeLevelMax\030\003 \001(\005\022\021\n\tjum" + "pDelay\030\004 \001(\r\022\024\n\014jumpDelayMin\030\005 \001(\r\022\024\n\014ju" + "mpDelayMax\030\006 \001(\r\022\021\n\tscanDelay\030\007 \001(\r\022\024\n\014s" + "canDelayMin\030\010 \001(\r\022\024\n\014scanDelayMax\030\t \001(\r\022" + "\024\n\014polygonDelay\030\n \001(\r\022\027\n\017polygonDelayMin" + "\030\013 \001(\r\022\027\n\017polygonDelayMax\030\014 \001(\r\022\025\n\rlaser" + "offDelay\030\r \001(\003\022\030\n\020laseroffDelayMin\030\016 \001(\003" + "\022\030\n\020laseroffDelayMax\030\017 \001(\003\022\024\n\014laseronDel" + "ay\030\020 \001(\003\022\027\n\017laseronDelayMin\030\021 \001(\003\022\027\n\017las" + "eronDelayMax\030\022 \001(\003\022\024\n\014minJumpDelay\030\023 \001(\r" + "\022\027\n\017minJumpDelayMin\030\024 \001(\r\022\027\n\017minJumpDela" + "yMax\030\025 \001(\r\022\027\n\017jumpLengthLimit\030\026 \001(\r\022\032\n\022j" + "umpLengthLimitMin\030\027 \001(\r\022\032\n\022jumpLengthLim" + "itMax\030\030 \001(\r\022\021\n\tjumpSpeed\030\031 \001(\001\022\024\n\014jumpSp" + "eedMin\030\032 \001(\001\022\024\n\014jumpSpeedMax\030\033 \001(\001\022\021\n\tma" + "rkSpeed\030\034 \001(\001\022\024\n\014markSpeedMin\030\035 \001(\001\022\024\n\014m" + "arkSpeedMax\030\036 \001(\001\"\256\004\n\017CorrectParamCfg\022\023\n" + "\013xmeasureMin\030\001 \001(\001\022\023\n\013xmeasureMax\030\002 \001(\001\022" + "\023\n\013ymeasureMin\030\003 \001(\001\022\023\n\013ymeasureMax\030\004 \001(" + "\001\022\017\n\007xposfix\030\005 \001(\001\022\017\n\007yposfix\030\006 \001(\001\022\021\n\ts" + "canAngle\030\007 \001(\001\022\024\n\014scanAngleMin\030\010 \001(\001\022\024\n\014" + "scanAngleMax\030\t \001(\001\022\020\n\010fixAngle\030\n \001(\001\022\023\n\013" + "fixAngleMin\030\013 \001(\001\022\023\n\013fixAngleMax\030\014 \001(\001\022\020" + "\n\010xcorrect\030\r \001(\001\022\020\n\010ycorrect\030\016 \001(\001\022\023\n\013xc" + "orrectMin\030\017 \001(\001\022\023\n\013xcorrectMax\030\020 \001(\001\022\023\n\013" + "ycorrectMin\030\021 \001(\001\022\023\n\013ycorrectMax\030\022 \001(\001\022\023" + "\n\013realXOffset\030\023 \001(\001\022\023\n\013realYOffset\030\024 \001(\001" + "\022\017\n\007factorK\030\025 \001(\001\022\027\n\017isCorrectFile3D\030\026 \001" + "(\010\022\026\n\016isDynamicFocus\030\027 \001(\010\022\024\n\014defocusRat" + "io\030\030 \001(\001\022\027\n\017defocusRatioMin\030\031 \001(\001\022\027\n\017def" + "ocusRatioMax\030\032 \001(\001\"\226\004\n\013ScanTestCfg\022\022\n\nde" + "bugShape\030\001 \001(\005\022\021\n\tshapeSize\030\002 \001(\005\022\024\n\014sha" + "peSizeMin\030\003 \001(\005\022\026\n\016shape_size_max\030\004 \001(\005\022" + "\023\n\013laser_power\030\005 \001(\005\022\027\n\017laser_power_min\030" + "\006 \001(\005\022\027\n\017laser_power_max\030\007 \001(\005\022\017\n\007defocu" + "s\030\010 \001(\001\022\023\n\013defocus_min\030\t \001(\001\022\023\n\013defocus_" + "max\030\n \001(\001\022\020\n\010is_cycle\030\013 \001(\010\022\017\n\007cross_x\030\014" + " \001(\001\022\017\n\007cross_y\030\r \001(\001\022\022\n\nz_distance\030\016 \001(" + "\001\022\034\n\024isAutoHeatingScanner\030\017 \001(\010\022!\n\031autoH" + "eatingScannerMinutes\030\020 \001(\r\022\036\n\026autoHeatin" + "gScannerSize\030\021 \001(\r\022\037\n\027autoHeatingScanner" + "Speed\030\022 \001(\001\022\031\n\021mark_test_start_x\030\023 \001(\001\022\031" + "\n\021mark_test_start_y\030\024 \001(\001\022\027\n\017mark_test_e" + "nd_x\030\025 \001(\001\022\027\n\017mark_test_end_y\030\026 \001(\001\"\314\002\n\r" + "SkyWritingCfg\022\020\n\010isEnable\030\001 \001(\010\022\017\n\007timel" + "ag\030\002 \001(\001\022\022\n\ntimelagMin\030\003 \001(\001\022\022\n\ntimelagM" + "ax\030\004 \001(\001\022\024\n\014laserOnShift\030\005 \001(\003\022\027\n\017laserO" + "nShiftMin\030\006 \001(\003\022\027\n\017laserOnShiftMax\030\007 \001(\003" + "\022\r\n\005nprev\030\010 \001(\r\022\020\n\010nprevMin\030\t \001(\r\022\020\n\010npr" + "evMax\030\n \001(\r\022\r\n\005npost\030\013 \001(\r\022\020\n\010npostMin\030\014" + " \001(\r\022\020\n\010npostMax\030\r \001(\r\022\014\n\004mode\030\016 \001(\005\022\016\n\006" + "limite\030\017 \001(\001\022\021\n\tlimiteMin\030\020 \001(\001\022\021\n\tlimit" + "eMax\030\021 \001(\001\"d\n\017PowerCompensate\022\013\n\003cno\030\001 \001" + "(\005\022\017\n\007percent\030\002 \001(\005\022\r\n\005value\030\003 \001(\002\022\021\n\tva" + "lue_min\030\004 \001(\002\022\021\n\tvalue_max\030\005 \001(\002\"j\n\023Time" + "PowerCompensate\022\n\n\002id\030\001 \001(\005\022\013\n\003cno\030\002 \001(\005" + "\022\023\n\013startMinute\030\003 \001(\r\022\021\n\tendMinute\030\004 \001(\r" + "\022\022\n\ncompensate\030\005 \001(\002*\223\001\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\006\022\t\n\005iCHAR" + "\020\007\022\n\n\006iUCHAR\020\010\022\t\n\005iWORD\020\t\022\013\n\007iDOUBLE\020\n\022\n" + "\n\006iTIMET\020\013**\n\nDATAHANDLE\022\n\n\006UPDATE\020\000\022\007\n\003" + "ADD\020\001\022\007\n\003DEL\020\0022\372\001\n\006Stream\0224\n\006Simple\022\023.st" + "ream.RequestInfo\032\023.stream.ResponseAny\"\000\022" + "=\n\014ServerStream\022\023.stream.RequestInfo\032\024.s" + "tream.ResponseInfo\"\0000\001\022=\n\014ClientStream\022\023" + ".stream.RequestInfo\032\024.stream.ResponseInf" + "o\"\000(\001\022<\n\tAllStream\022\023.stream.RequestInfo\032" + "\024.stream.ResponseInfo\"\000(\0010\001B-\n\027io.grpc.e" + "xamples.streamB\013StreamProtoP\001\242\002\002STb\006prot" + "o3" }; static const ::_pbi::DescriptorTable* const descriptor_table_stream_2eproto_deps[1] = { @@ -497,13 +1113,13 @@ static ::absl::once_flag descriptor_table_stream_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_stream_2eproto = { false, false, - 1699, + 5002, descriptor_table_protodef_stream_2eproto, "stream.proto", &descriptor_table_stream_2eproto_once, descriptor_table_stream_2eproto_deps, 1, - 12, + 21, schemas, file_default_instances, TableStruct_stream_2eproto::offsets, @@ -585,13 +1201,21 @@ ParamInfo::ParamInfo(const ParamInfo& from) : ::google::protobuf::Message() { decltype(_impl_.namekey_){}, decltype(_impl_.strvalue_){}, decltype(_impl_.context_){}, + decltype(_impl_.cardname_){}, + decltype(_impl_.cardip_){}, decltype(_impl_.valuetype_){}, + decltype(_impl_.startlayer_){}, decltype(_impl_.isenable_){}, decltype(_impl_.isalarm_){}, decltype(_impl_.isshow_){}, - decltype(_impl_.startlayer_){}, + decltype(_impl_.hadassign_){}, decltype(_impl_.endlayer_){}, decltype(_impl_.powder_){}, + decltype(_impl_.seqno_){}, + decltype(_impl_.controlno_){}, + decltype(_impl_.serialno_){}, + decltype(_impl_.controltype_){}, + decltype(_impl_.hadmatch_){}, /*decltype(_impl_._cached_size_)*/ {}, }; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -617,9 +1241,23 @@ ParamInfo::ParamInfo(const ParamInfo& from) : ::google::protobuf::Message() { if (!from._internal_context().empty()) { _this->_impl_.context_.Set(from._internal_context(), _this->GetArenaForAllocation()); } + _impl_.cardname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_cardname().empty()) { + _this->_impl_.cardname_.Set(from._internal_cardname(), _this->GetArenaForAllocation()); + } + _impl_.cardip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_cardip().empty()) { + _this->_impl_.cardip_.Set(from._internal_cardip(), _this->GetArenaForAllocation()); + } ::memcpy(&_impl_.valuetype_, &from._impl_.valuetype_, - static_cast<::size_t>(reinterpret_cast(&_impl_.powder_) - - reinterpret_cast(&_impl_.valuetype_)) + sizeof(_impl_.powder_)); + static_cast<::size_t>(reinterpret_cast(&_impl_.hadmatch_) - + reinterpret_cast(&_impl_.valuetype_)) + sizeof(_impl_.hadmatch_)); // @@protoc_insertion_point(copy_constructor:stream.ParamInfo) } @@ -629,13 +1267,21 @@ inline void ParamInfo::SharedCtor(::_pb::Arena* arena) { decltype(_impl_.namekey_){}, decltype(_impl_.strvalue_){}, decltype(_impl_.context_){}, + decltype(_impl_.cardname_){}, + decltype(_impl_.cardip_){}, decltype(_impl_.valuetype_){0}, + decltype(_impl_.startlayer_){0}, decltype(_impl_.isenable_){false}, decltype(_impl_.isalarm_){false}, decltype(_impl_.isshow_){false}, - decltype(_impl_.startlayer_){0}, + decltype(_impl_.hadassign_){false}, decltype(_impl_.endlayer_){0}, decltype(_impl_.powder_){0}, + decltype(_impl_.seqno_){0}, + decltype(_impl_.controlno_){0}, + decltype(_impl_.serialno_){0}, + decltype(_impl_.controltype_){0}, + decltype(_impl_.hadmatch_){false}, /*decltype(_impl_._cached_size_)*/ {}, }; _impl_.namekey_.InitDefault(); @@ -650,6 +1296,14 @@ inline void ParamInfo::SharedCtor(::_pb::Arena* arena) { #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING _impl_.context_.Set("", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } ParamInfo::~ParamInfo() { // @@protoc_insertion_point(destructor:stream.ParamInfo) @@ -661,6 +1315,8 @@ inline void ParamInfo::SharedDtor() { _impl_.namekey_.Destroy(); _impl_.strvalue_.Destroy(); _impl_.context_.Destroy(); + _impl_.cardname_.Destroy(); + _impl_.cardip_.Destroy(); } void ParamInfo::SetCachedSize(int size) const { _impl_._cached_size_.Set(size); @@ -675,9 +1331,11 @@ PROTOBUF_NOINLINE void ParamInfo::Clear() { _impl_.namekey_.ClearToEmpty(); _impl_.strvalue_.ClearToEmpty(); _impl_.context_.ClearToEmpty(); + _impl_.cardname_.ClearToEmpty(); + _impl_.cardip_.ClearToEmpty(); ::memset(&_impl_.valuetype_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.powder_) - - reinterpret_cast(&_impl_.valuetype_)) + sizeof(_impl_.powder_)); + reinterpret_cast(&_impl_.hadmatch_) - + reinterpret_cast(&_impl_.valuetype_)) + sizeof(_impl_.hadmatch_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } @@ -689,15 +1347,15 @@ const char* ParamInfo::_InternalParse( PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { +const ::_pbi::TcParseTable<5, 18, 0, 0, 2> ParamInfo::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ - 10, 120, // max_field_number, fast_idx_mask + 18, 248, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294966272, // skipmap + 4294705152, // skipmap offsetof(decltype(_table_), field_entries), - 10, // num_field_entries + 18, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_ParamInfo_default_instance_._instance, @@ -734,6 +1392,38 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { // float powder = 10; {::_pbi::TcParser::FastF32S1, {85, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_)}}, + // int32 seqNo = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.seqno_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.seqno_)}}, + // int32 controlNo = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.controlno_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controlno_)}}, + // int32 serialNo = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.serialno_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.serialno_)}}, + // int32 controlType = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.controltype_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controltype_)}}, + // bytes cardName = 15; + {::_pbi::TcParser::FastBS1, + {122, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardname_)}}, + // bytes cardIP = 16; + {::_pbi::TcParser::FastBS2, + {386, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardip_)}}, + // bool hadAssign = 17; + {::_pbi::TcParser::FastV8S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadassign_)}}, + // bool hadMatch = 18; + {::_pbi::TcParser::FastV8S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, @@ -772,6 +1462,30 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { // float powder = 10; {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // int32 seqNo = 11; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.seqno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 controlNo = 12; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controlno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 serialNo = 13; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.serialno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 controlType = 14; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controltype_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bytes cardName = 15; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardname_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bytes cardIP = 16; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardip_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bool hadAssign = 17; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadassign_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool hadMatch = 18; + {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ @@ -857,6 +1571,60 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { 10, this->_internal_powder(), target); } + // int32 seqNo = 11; + if (this->_internal_seqno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<11>( + stream, this->_internal_seqno(), target); + } + + // int32 controlNo = 12; + if (this->_internal_controlno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<12>( + stream, this->_internal_controlno(), target); + } + + // int32 serialNo = 13; + if (this->_internal_serialno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<13>( + stream, this->_internal_serialno(), target); + } + + // int32 controlType = 14; + if (this->_internal_controltype() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this->_internal_controltype(), target); + } + + // bytes cardName = 15; + if (!this->_internal_cardname().empty()) { + const std::string& _s = this->_internal_cardname(); + target = stream->WriteBytesMaybeAliased(15, _s, target); + } + + // bytes cardIP = 16; + if (!this->_internal_cardip().empty()) { + const std::string& _s = this->_internal_cardip(); + target = stream->WriteBytesMaybeAliased(16, _s, target); + } + + // bool hadAssign = 17; + if (this->_internal_hadassign() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 17, this->_internal_hadassign(), target); + } + + // bool hadMatch = 18; + if (this->_internal_hadmatch() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 18, this->_internal_hadmatch(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( @@ -892,12 +1660,30 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { this->_internal_context()); } + // bytes cardName = 15; + if (!this->_internal_cardname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->_internal_cardname()); + } + + // bytes cardIP = 16; + if (!this->_internal_cardip().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->_internal_cardip()); + } + // .stream.TYPE valueType = 3; if (this->_internal_valuetype() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_valuetype()); } + // int32 startLayer = 8; + if (this->_internal_startlayer() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_startlayer()); + } + // bool isEnable = 5; if (this->_internal_isenable() != 0) { total_size += 2; @@ -913,10 +1699,9 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { total_size += 2; } - // int32 startLayer = 8; - if (this->_internal_startlayer() != 0) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( - this->_internal_startlayer()); + // bool hadAssign = 17; + if (this->_internal_hadassign() != 0) { + total_size += 3; } // int32 endLayer = 9; @@ -935,6 +1720,35 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = { total_size += 5; } + // int32 seqNo = 11; + if (this->_internal_seqno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_seqno()); + } + + // int32 controlNo = 12; + if (this->_internal_controlno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_controlno()); + } + + // int32 serialNo = 13; + if (this->_internal_serialno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_serialno()); + } + + // int32 controlType = 14; + if (this->_internal_controltype() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_controltype()); + } + + // bool hadMatch = 18; + if (this->_internal_hadmatch() != 0) { + total_size += 3; + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -962,9 +1776,18 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p if (!from._internal_context().empty()) { _this->_internal_set_context(from._internal_context()); } + if (!from._internal_cardname().empty()) { + _this->_internal_set_cardname(from._internal_cardname()); + } + if (!from._internal_cardip().empty()) { + _this->_internal_set_cardip(from._internal_cardip()); + } if (from._internal_valuetype() != 0) { _this->_internal_set_valuetype(from._internal_valuetype()); } + if (from._internal_startlayer() != 0) { + _this->_internal_set_startlayer(from._internal_startlayer()); + } if (from._internal_isenable() != 0) { _this->_internal_set_isenable(from._internal_isenable()); } @@ -974,8 +1797,8 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p if (from._internal_isshow() != 0) { _this->_internal_set_isshow(from._internal_isshow()); } - if (from._internal_startlayer() != 0) { - _this->_internal_set_startlayer(from._internal_startlayer()); + if (from._internal_hadassign() != 0) { + _this->_internal_set_hadassign(from._internal_hadassign()); } if (from._internal_endlayer() != 0) { _this->_internal_set_endlayer(from._internal_endlayer()); @@ -988,6 +1811,21 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p if (raw_powder != 0) { _this->_internal_set_powder(from._internal_powder()); } + if (from._internal_seqno() != 0) { + _this->_internal_set_seqno(from._internal_seqno()); + } + if (from._internal_controlno() != 0) { + _this->_internal_set_controlno(from._internal_controlno()); + } + if (from._internal_serialno() != 0) { + _this->_internal_set_serialno(from._internal_serialno()); + } + if (from._internal_controltype() != 0) { + _this->_internal_set_controltype(from._internal_controltype()); + } + if (from._internal_hadmatch() != 0) { + _this->_internal_set_hadmatch(from._internal_hadmatch()); + } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } @@ -1013,9 +1851,13 @@ void ParamInfo::InternalSwap(ParamInfo* other) { &other->_impl_.strvalue_, rhs_arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.context_, lhs_arena, &other->_impl_.context_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardname_, lhs_arena, + &other->_impl_.cardname_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardip_, lhs_arena, + &other->_impl_.cardip_, rhs_arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_) - + sizeof(ParamInfo::_impl_.powder_) + PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_) + + sizeof(ParamInfo::_impl_.hadmatch_) - PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.valuetype_)>( reinterpret_cast(&_impl_.valuetype_), reinterpret_cast(&other->_impl_.valuetype_)); @@ -3722,6 +4564,5342 @@ void ComResponce::InternalSwap(ComResponce* other) { &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, file_level_metadata_stream_2eproto[11]); } +// =================================================================== + +class ScannerCrtlCfgResp::_Internal { + public: +}; + +ScannerCrtlCfgResp::ScannerCrtlCfgResp(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ScannerCrtlCfgResp) +} +ScannerCrtlCfgResp::ScannerCrtlCfgResp(const ScannerCrtlCfgResp& from) : ::google::protobuf::Message() { + ScannerCrtlCfgResp* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.scannercfg_){from._impl_.scannercfg_}, + /*decltype(_impl_._cached_size_)*/ {}, + }; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:stream.ScannerCrtlCfgResp) +} +inline void ScannerCrtlCfgResp::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.scannercfg_){arena}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +ScannerCrtlCfgResp::~ScannerCrtlCfgResp() { + // @@protoc_insertion_point(destructor:stream.ScannerCrtlCfgResp) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ScannerCrtlCfgResp::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.scannercfg_.~RepeatedPtrField(); +} +void ScannerCrtlCfgResp::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ScannerCrtlCfgResp::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ScannerCrtlCfgResp) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_scannercfg()->Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ScannerCrtlCfgResp::_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> ScannerCrtlCfgResp::_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 + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_ScannerCrtlCfgResp_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // repeated .stream.ScannerCrtlCfgData scannerCfg = 1; + {::_pbi::TcParser::FastMtR1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgResp, _impl_.scannercfg_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .stream.ScannerCrtlCfgData scannerCfg = 1; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgResp, _impl_.scannercfg_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::stream::ScannerCrtlCfgData>()}, + }}, {{ + }}, +}; + +::uint8_t* ScannerCrtlCfgResp::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ScannerCrtlCfgResp) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated .stream.ScannerCrtlCfgData scannerCfg = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_scannercfg_size()); i < n; i++) { + const auto& repfield = this->_internal_scannercfg().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(1, 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.ScannerCrtlCfgResp) + return target; +} + +::size_t ScannerCrtlCfgResp::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ScannerCrtlCfgResp) + ::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.ScannerCrtlCfgData scannerCfg = 1; + total_size += 1UL * this->_internal_scannercfg_size(); + for (const auto& msg : this->_internal_scannercfg()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ScannerCrtlCfgResp::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ScannerCrtlCfgResp::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ScannerCrtlCfgResp::GetClassData() const { return &_class_data_; } + + +void ScannerCrtlCfgResp::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.ScannerCrtlCfgResp) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_scannercfg()->MergeFrom(from._internal_scannercfg()); + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ScannerCrtlCfgResp::CopyFrom(const ScannerCrtlCfgResp& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScannerCrtlCfgResp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ScannerCrtlCfgResp::IsInitialized() const { + return true; +} + +void ScannerCrtlCfgResp::InternalSwap(ScannerCrtlCfgResp* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.scannercfg_.InternalSwap(&other->_impl_.scannercfg_); +} + +::google::protobuf::Metadata ScannerCrtlCfgResp::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[12]); +} +// =================================================================== + +class ScannerCrtlCfgData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_._has_bits_); + static const ::stream::ScanParamCfg& scanparamcfg(const ScannerCrtlCfgData* msg); + static void set_has_scanparamcfg(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::stream::ScanParamCfg& hatchingparams(const ScannerCrtlCfgData* msg); + static void set_has_hatchingparams(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::stream::ScanParamCfg& borderparams(const ScannerCrtlCfgData* msg); + static void set_has_borderparams(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::stream::ScanParamCfg& supportparams(const ScannerCrtlCfgData* msg); + static void set_has_supportparams(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::stream::CorrectParamCfg& correctparamcfg(const ScannerCrtlCfgData* msg); + static void set_has_correctparamcfg(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::stream::ScanTestCfg& scantestcfg(const ScannerCrtlCfgData* msg); + static void set_has_scantestcfg(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::stream::SkyWritingCfg& skywritingcfg(const ScannerCrtlCfgData* msg); + static void set_has_skywritingcfg(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::scanparamcfg(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.scanparamcfg_; +} +const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::hatchingparams(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.hatchingparams_; +} +const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::borderparams(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.borderparams_; +} +const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::supportparams(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.supportparams_; +} +const ::stream::CorrectParamCfg& ScannerCrtlCfgData::_Internal::correctparamcfg(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.correctparamcfg_; +} +const ::stream::ScanTestCfg& ScannerCrtlCfgData::_Internal::scantestcfg(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.scantestcfg_; +} +const ::stream::SkyWritingCfg& ScannerCrtlCfgData::_Internal::skywritingcfg(const ScannerCrtlCfgData* msg) { + return *msg->_impl_.skywritingcfg_; +} +ScannerCrtlCfgData::ScannerCrtlCfgData(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ScannerCrtlCfgData) +} +ScannerCrtlCfgData::ScannerCrtlCfgData(const ScannerCrtlCfgData& from) : ::google::protobuf::Message() { + ScannerCrtlCfgData* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_}, + /*decltype(_impl_._cached_size_)*/ {}, + decltype(_impl_.fixpointdata_){from._impl_.fixpointdata_}, + decltype(_impl_.powercompensate_){from._impl_.powercompensate_}, + decltype(_impl_.tpowercompensate_){from._impl_.tpowercompensate_}, + decltype(_impl_.cardname_){}, + decltype(_impl_.cardip_){}, + decltype(_impl_.scanparamcfg_){nullptr}, + decltype(_impl_.hatchingparams_){nullptr}, + decltype(_impl_.borderparams_){nullptr}, + decltype(_impl_.supportparams_){nullptr}, + decltype(_impl_.correctparamcfg_){nullptr}, + decltype(_impl_.scantestcfg_){nullptr}, + decltype(_impl_.skywritingcfg_){nullptr}, + decltype(_impl_.seqno_){}, + decltype(_impl_.controlno_){}, + decltype(_impl_.serialno_){}, + decltype(_impl_.controltype_){}, + decltype(_impl_.isenable_){}, + decltype(_impl_.hadassign_){}, + decltype(_impl_.hadmatch_){}, + }; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + _impl_.cardname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_cardname().empty()) { + _this->_impl_.cardname_.Set(from._internal_cardname(), _this->GetArenaForAllocation()); + } + _impl_.cardip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_cardip().empty()) { + _this->_impl_.cardip_.Set(from._internal_cardip(), _this->GetArenaForAllocation()); + } + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.scanparamcfg_ = new ::stream::ScanParamCfg(*from._impl_.scanparamcfg_); + } + if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { + _this->_impl_.hatchingparams_ = new ::stream::ScanParamCfg(*from._impl_.hatchingparams_); + } + if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) { + _this->_impl_.borderparams_ = new ::stream::ScanParamCfg(*from._impl_.borderparams_); + } + if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) { + _this->_impl_.supportparams_ = new ::stream::ScanParamCfg(*from._impl_.supportparams_); + } + if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) { + _this->_impl_.correctparamcfg_ = new ::stream::CorrectParamCfg(*from._impl_.correctparamcfg_); + } + if ((from._impl_._has_bits_[0] & 0x00000020u) != 0) { + _this->_impl_.scantestcfg_ = new ::stream::ScanTestCfg(*from._impl_.scantestcfg_); + } + if ((from._impl_._has_bits_[0] & 0x00000040u) != 0) { + _this->_impl_.skywritingcfg_ = new ::stream::SkyWritingCfg(*from._impl_.skywritingcfg_); + } + ::memcpy(&_impl_.seqno_, &from._impl_.seqno_, + static_cast<::size_t>(reinterpret_cast(&_impl_.hadmatch_) - + reinterpret_cast(&_impl_.seqno_)) + sizeof(_impl_.hadmatch_)); + + // @@protoc_insertion_point(copy_constructor:stream.ScannerCrtlCfgData) +} +inline void ScannerCrtlCfgData::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){}, + /*decltype(_impl_._cached_size_)*/ {}, + decltype(_impl_.fixpointdata_){arena}, + decltype(_impl_.powercompensate_){arena}, + decltype(_impl_.tpowercompensate_){arena}, + decltype(_impl_.cardname_){}, + decltype(_impl_.cardip_){}, + decltype(_impl_.scanparamcfg_){nullptr}, + decltype(_impl_.hatchingparams_){nullptr}, + decltype(_impl_.borderparams_){nullptr}, + decltype(_impl_.supportparams_){nullptr}, + decltype(_impl_.correctparamcfg_){nullptr}, + decltype(_impl_.scantestcfg_){nullptr}, + decltype(_impl_.skywritingcfg_){nullptr}, + decltype(_impl_.seqno_){0}, + decltype(_impl_.controlno_){0}, + decltype(_impl_.serialno_){0}, + decltype(_impl_.controltype_){0}, + decltype(_impl_.isenable_){false}, + decltype(_impl_.hadassign_){false}, + decltype(_impl_.hadmatch_){false}, + }; + _impl_.cardname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.cardip_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} +ScannerCrtlCfgData::~ScannerCrtlCfgData() { + // @@protoc_insertion_point(destructor:stream.ScannerCrtlCfgData) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ScannerCrtlCfgData::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.fixpointdata_.~RepeatedPtrField(); + _impl_.powercompensate_.~RepeatedPtrField(); + _impl_.tpowercompensate_.~RepeatedPtrField(); + _impl_.cardname_.Destroy(); + _impl_.cardip_.Destroy(); + if (this != internal_default_instance()) delete _impl_.scanparamcfg_; + if (this != internal_default_instance()) delete _impl_.hatchingparams_; + if (this != internal_default_instance()) delete _impl_.borderparams_; + if (this != internal_default_instance()) delete _impl_.supportparams_; + if (this != internal_default_instance()) delete _impl_.correctparamcfg_; + if (this != internal_default_instance()) delete _impl_.scantestcfg_; + if (this != internal_default_instance()) delete _impl_.skywritingcfg_; +} +void ScannerCrtlCfgData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ScannerCrtlCfgData::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ScannerCrtlCfgData) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_fixpointdata()->Clear(); + _internal_mutable_powercompensate()->Clear(); + _internal_mutable_tpowercompensate()->Clear(); + _impl_.cardname_.ClearToEmpty(); + _impl_.cardip_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.scanparamcfg_ != nullptr); + _impl_.scanparamcfg_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.hatchingparams_ != nullptr); + _impl_.hatchingparams_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + ABSL_DCHECK(_impl_.borderparams_ != nullptr); + _impl_.borderparams_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + ABSL_DCHECK(_impl_.supportparams_ != nullptr); + _impl_.supportparams_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + ABSL_DCHECK(_impl_.correctparamcfg_ != nullptr); + _impl_.correctparamcfg_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + ABSL_DCHECK(_impl_.scantestcfg_ != nullptr); + _impl_.scantestcfg_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + ABSL_DCHECK(_impl_.skywritingcfg_ != nullptr); + _impl_.skywritingcfg_->Clear(); + } + } + ::memset(&_impl_.seqno_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.hadmatch_) - + reinterpret_cast(&_impl_.seqno_)) + sizeof(_impl_.hadmatch_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ScannerCrtlCfgData::_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<5, 19, 10, 0, 2> ScannerCrtlCfgData::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_._has_bits_), + 0, // no _extensions_ + 19, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294443008, // skipmap + offsetof(decltype(_table_), field_entries), + 19, // num_field_entries + 10, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_ScannerCrtlCfgData_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 seqNo = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.seqno_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.seqno_)}}, + // repeated .stream.FixPointData fixPointData = 2; + {::_pbi::TcParser::FastMtR1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.fixpointdata_)}}, + // .stream.ScanParamCfg scanParamCfg = 3; + {::_pbi::TcParser::FastMtS1, + {26, 0, 1, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_)}}, + // .stream.ScanParamCfg hatchingParams = 4; + {::_pbi::TcParser::FastMtS1, + {34, 1, 2, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hatchingparams_)}}, + // .stream.ScanParamCfg borderParams = 5; + {::_pbi::TcParser::FastMtS1, + {42, 2, 3, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.borderparams_)}}, + // .stream.ScanParamCfg supportParams = 6; + {::_pbi::TcParser::FastMtS1, + {50, 3, 4, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.supportparams_)}}, + // .stream.CorrectParamCfg correctParamCfg = 7; + {::_pbi::TcParser::FastMtS1, + {58, 4, 5, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.correctparamcfg_)}}, + // .stream.ScanTestCfg scanTestCfg = 8; + {::_pbi::TcParser::FastMtS1, + {66, 5, 6, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scantestcfg_)}}, + // .stream.SkyWritingCfg skyWritingCfg = 9; + {::_pbi::TcParser::FastMtS1, + {74, 6, 7, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.skywritingcfg_)}}, + // repeated .stream.PowerCompensate powerCompensate = 10; + {::_pbi::TcParser::FastMtR1, + {82, 63, 8, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.powercompensate_)}}, + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + {::_pbi::TcParser::FastMtR1, + {90, 63, 9, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.tpowercompensate_)}}, + // int32 controlNo = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.controlno_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controlno_)}}, + // int32 serialNo = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.serialno_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.serialno_)}}, + // int32 controlType = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.controltype_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controltype_)}}, + // bytes cardName = 15; + {::_pbi::TcParser::FastBS1, + {122, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardname_)}}, + // bytes cardIP = 16; + {::_pbi::TcParser::FastBS2, + {386, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardip_)}}, + // bool isEnable = 17; + {::_pbi::TcParser::FastV8S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.isenable_)}}, + // bool hadAssign = 18; + {::_pbi::TcParser::FastV8S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadassign_)}}, + // bool hadMatch = 19; + {::_pbi::TcParser::FastV8S2, + {408, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 seqNo = 1; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.seqno_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // repeated .stream.FixPointData fixPointData = 2; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.fixpointdata_), -1, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanParamCfg scanParamCfg = 3; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_), _Internal::kHasBitsOffset + 0, 1, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanParamCfg hatchingParams = 4; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hatchingparams_), _Internal::kHasBitsOffset + 1, 2, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanParamCfg borderParams = 5; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.borderparams_), _Internal::kHasBitsOffset + 2, 3, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanParamCfg supportParams = 6; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.supportparams_), _Internal::kHasBitsOffset + 3, 4, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.CorrectParamCfg correctParamCfg = 7; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.correctparamcfg_), _Internal::kHasBitsOffset + 4, 5, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.ScanTestCfg scanTestCfg = 8; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scantestcfg_), _Internal::kHasBitsOffset + 5, 6, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .stream.SkyWritingCfg skyWritingCfg = 9; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.skywritingcfg_), _Internal::kHasBitsOffset + 6, 7, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .stream.PowerCompensate powerCompensate = 10; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.powercompensate_), -1, 8, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.tpowercompensate_), -1, 9, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // int32 controlNo = 12; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controlno_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 serialNo = 13; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.serialno_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 controlType = 14; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controltype_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bytes cardName = 15; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardname_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bytes cardIP = 16; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardip_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bool isEnable = 17; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.isenable_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool hadAssign = 18; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadassign_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool hadMatch = 19; + {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, {{ + {::_pbi::TcParser::GetTable<::stream::FixPointData>()}, + {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::CorrectParamCfg>()}, + {::_pbi::TcParser::GetTable<::stream::ScanTestCfg>()}, + {::_pbi::TcParser::GetTable<::stream::SkyWritingCfg>()}, + {::_pbi::TcParser::GetTable<::stream::PowerCompensate>()}, + {::_pbi::TcParser::GetTable<::stream::TimePowerCompensate>()}, + }}, {{ + }}, +}; + +::uint8_t* ScannerCrtlCfgData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ScannerCrtlCfgData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 seqNo = 1; + if (this->_internal_seqno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_seqno(), target); + } + + // repeated .stream.FixPointData fixPointData = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_fixpointdata_size()); i < n; i++) { + const auto& repfield = this->_internal_fixpointdata().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[0]; + // .stream.ScanParamCfg scanParamCfg = 3; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::scanparamcfg(this), + _Internal::scanparamcfg(this).GetCachedSize(), target, stream); + } + + // .stream.ScanParamCfg hatchingParams = 4; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::hatchingparams(this), + _Internal::hatchingparams(this).GetCachedSize(), target, stream); + } + + // .stream.ScanParamCfg borderParams = 5; + if (cached_has_bits & 0x00000004u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::borderparams(this), + _Internal::borderparams(this).GetCachedSize(), target, stream); + } + + // .stream.ScanParamCfg supportParams = 6; + if (cached_has_bits & 0x00000008u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::supportparams(this), + _Internal::supportparams(this).GetCachedSize(), target, stream); + } + + // .stream.CorrectParamCfg correctParamCfg = 7; + if (cached_has_bits & 0x00000010u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::correctparamcfg(this), + _Internal::correctparamcfg(this).GetCachedSize(), target, stream); + } + + // .stream.ScanTestCfg scanTestCfg = 8; + if (cached_has_bits & 0x00000020u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::scantestcfg(this), + _Internal::scantestcfg(this).GetCachedSize(), target, stream); + } + + // .stream.SkyWritingCfg skyWritingCfg = 9; + if (cached_has_bits & 0x00000040u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(9, _Internal::skywritingcfg(this), + _Internal::skywritingcfg(this).GetCachedSize(), target, stream); + } + + // repeated .stream.PowerCompensate powerCompensate = 10; + for (unsigned i = 0, + n = static_cast(this->_internal_powercompensate_size()); i < n; i++) { + const auto& repfield = this->_internal_powercompensate().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(10, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + for (unsigned i = 0, + n = static_cast(this->_internal_tpowercompensate_size()); i < n; i++) { + const auto& repfield = this->_internal_tpowercompensate().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream); + } + + // int32 controlNo = 12; + if (this->_internal_controlno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<12>( + stream, this->_internal_controlno(), target); + } + + // int32 serialNo = 13; + if (this->_internal_serialno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<13>( + stream, this->_internal_serialno(), target); + } + + // int32 controlType = 14; + if (this->_internal_controltype() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this->_internal_controltype(), target); + } + + // bytes cardName = 15; + if (!this->_internal_cardname().empty()) { + const std::string& _s = this->_internal_cardname(); + target = stream->WriteBytesMaybeAliased(15, _s, target); + } + + // bytes cardIP = 16; + if (!this->_internal_cardip().empty()) { + const std::string& _s = this->_internal_cardip(); + target = stream->WriteBytesMaybeAliased(16, _s, target); + } + + // bool isEnable = 17; + if (this->_internal_isenable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 17, this->_internal_isenable(), target); + } + + // bool hadAssign = 18; + if (this->_internal_hadassign() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 18, this->_internal_hadassign(), target); + } + + // bool hadMatch = 19; + if (this->_internal_hadmatch() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 19, this->_internal_hadmatch(), 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.ScannerCrtlCfgData) + return target; +} + +::size_t ScannerCrtlCfgData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ScannerCrtlCfgData) + ::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.FixPointData fixPointData = 2; + total_size += 1UL * this->_internal_fixpointdata_size(); + for (const auto& msg : this->_internal_fixpointdata()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // repeated .stream.PowerCompensate powerCompensate = 10; + total_size += 1UL * this->_internal_powercompensate_size(); + for (const auto& msg : this->_internal_powercompensate()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + total_size += 1UL * this->_internal_tpowercompensate_size(); + for (const auto& msg : this->_internal_tpowercompensate()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // bytes cardName = 15; + if (!this->_internal_cardname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->_internal_cardname()); + } + + // bytes cardIP = 16; + if (!this->_internal_cardip().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->_internal_cardip()); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // .stream.ScanParamCfg scanParamCfg = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.scanparamcfg_); + } + + // .stream.ScanParamCfg hatchingParams = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.hatchingparams_); + } + + // .stream.ScanParamCfg borderParams = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.borderparams_); + } + + // .stream.ScanParamCfg supportParams = 6; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.supportparams_); + } + + // .stream.CorrectParamCfg correctParamCfg = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.correctparamcfg_); + } + + // .stream.ScanTestCfg scanTestCfg = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.scantestcfg_); + } + + // .stream.SkyWritingCfg skyWritingCfg = 9; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *_impl_.skywritingcfg_); + } + + } + // int32 seqNo = 1; + if (this->_internal_seqno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_seqno()); + } + + // int32 controlNo = 12; + if (this->_internal_controlno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_controlno()); + } + + // int32 serialNo = 13; + if (this->_internal_serialno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_serialno()); + } + + // int32 controlType = 14; + if (this->_internal_controltype() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_controltype()); + } + + // bool isEnable = 17; + if (this->_internal_isenable() != 0) { + total_size += 3; + } + + // bool hadAssign = 18; + if (this->_internal_hadassign() != 0) { + total_size += 3; + } + + // bool hadMatch = 19; + if (this->_internal_hadmatch() != 0) { + total_size += 3; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ScannerCrtlCfgData::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ScannerCrtlCfgData::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ScannerCrtlCfgData::GetClassData() const { return &_class_data_; } + + +void ScannerCrtlCfgData::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.ScannerCrtlCfgData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_fixpointdata()->MergeFrom(from._internal_fixpointdata()); + _this->_internal_mutable_powercompensate()->MergeFrom(from._internal_powercompensate()); + _this->_internal_mutable_tpowercompensate()->MergeFrom(from._internal_tpowercompensate()); + if (!from._internal_cardname().empty()) { + _this->_internal_set_cardname(from._internal_cardname()); + } + if (!from._internal_cardip().empty()) { + _this->_internal_set_cardip(from._internal_cardip()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_scanparamcfg()->::stream::ScanParamCfg::MergeFrom( + from._internal_scanparamcfg()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_hatchingparams()->::stream::ScanParamCfg::MergeFrom( + from._internal_hatchingparams()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_borderparams()->::stream::ScanParamCfg::MergeFrom( + from._internal_borderparams()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_supportparams()->::stream::ScanParamCfg::MergeFrom( + from._internal_supportparams()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_correctparamcfg()->::stream::CorrectParamCfg::MergeFrom( + from._internal_correctparamcfg()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_scantestcfg()->::stream::ScanTestCfg::MergeFrom( + from._internal_scantestcfg()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_skywritingcfg()->::stream::SkyWritingCfg::MergeFrom( + from._internal_skywritingcfg()); + } + } + if (from._internal_seqno() != 0) { + _this->_internal_set_seqno(from._internal_seqno()); + } + if (from._internal_controlno() != 0) { + _this->_internal_set_controlno(from._internal_controlno()); + } + if (from._internal_serialno() != 0) { + _this->_internal_set_serialno(from._internal_serialno()); + } + if (from._internal_controltype() != 0) { + _this->_internal_set_controltype(from._internal_controltype()); + } + if (from._internal_isenable() != 0) { + _this->_internal_set_isenable(from._internal_isenable()); + } + if (from._internal_hadassign() != 0) { + _this->_internal_set_hadassign(from._internal_hadassign()); + } + if (from._internal_hadmatch() != 0) { + _this->_internal_set_hadmatch(from._internal_hadmatch()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ScannerCrtlCfgData::CopyFrom(const ScannerCrtlCfgData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScannerCrtlCfgData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ScannerCrtlCfgData::IsInitialized() const { + return true; +} + +void ScannerCrtlCfgData::InternalSwap(ScannerCrtlCfgData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.fixpointdata_.InternalSwap(&other->_impl_.fixpointdata_); + _impl_.powercompensate_.InternalSwap(&other->_impl_.powercompensate_); + _impl_.tpowercompensate_.InternalSwap(&other->_impl_.tpowercompensate_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardname_, lhs_arena, + &other->_impl_.cardname_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardip_, lhs_arena, + &other->_impl_.cardip_, rhs_arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_) + + sizeof(ScannerCrtlCfgData::_impl_.hadmatch_) + - PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_)>( + reinterpret_cast(&_impl_.scanparamcfg_), + reinterpret_cast(&other->_impl_.scanparamcfg_)); +} + +::google::protobuf::Metadata ScannerCrtlCfgData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[13]); +} +// =================================================================== + +class FixPointData::_Internal { + public: +}; + +FixPointData::FixPointData(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.FixPointData) +} +FixPointData::FixPointData(const FixPointData& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.FixPointData) +} +inline void FixPointData::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.id_){0}, + decltype(_impl_.cno_){0}, + decltype(_impl_.pointx_){0}, + decltype(_impl_.pointy_){0}, + decltype(_impl_.duration_){0u}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +FixPointData::~FixPointData() { + // @@protoc_insertion_point(destructor:stream.FixPointData) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void FixPointData::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void FixPointData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void FixPointData::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.FixPointData) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.duration_) - + reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.duration_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* FixPointData::_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, 0, 0, 2> FixPointData::_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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_FixPointData_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_)}}, + // int32 cno = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.cno_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.cno_)}}, + // float pointX = 3; + {::_pbi::TcParser::FastF32S1, + {29, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointx_)}}, + // float pointY = 4; + {::_pbi::TcParser::FastF32S1, + {37, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointy_)}}, + // uint32 duration = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.duration_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 id = 1; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 cno = 2; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.cno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // float pointX = 3; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float pointY = 4; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointy_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // uint32 duration = 5; + {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* FixPointData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.FixPointData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 id = 1; + if (this->_internal_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_id(), target); + } + + // int32 cno = 2; + if (this->_internal_cno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_cno(), target); + } + + // float pointX = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointx = this->_internal_pointx(); + ::uint32_t raw_pointx; + memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx)); + if (raw_pointx != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 3, this->_internal_pointx(), target); + } + + // float pointY = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointy = this->_internal_pointy(); + ::uint32_t raw_pointy; + memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy)); + if (raw_pointy != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 4, this->_internal_pointy(), target); + } + + // uint32 duration = 5; + if (this->_internal_duration() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 5, this->_internal_duration(), 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.FixPointData) + return target; +} + +::size_t FixPointData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.FixPointData) + ::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 id = 1; + if (this->_internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_id()); + } + + // int32 cno = 2; + if (this->_internal_cno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_cno()); + } + + // float pointX = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointx = this->_internal_pointx(); + ::uint32_t raw_pointx; + memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx)); + if (raw_pointx != 0) { + total_size += 5; + } + + // float pointY = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointy = this->_internal_pointy(); + ::uint32_t raw_pointy; + memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy)); + if (raw_pointy != 0) { + total_size += 5; + } + + // uint32 duration = 5; + if (this->_internal_duration() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_duration()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData FixPointData::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + FixPointData::MergeImpl +}; +const ::google::protobuf::Message::ClassData*FixPointData::GetClassData() const { return &_class_data_; } + + +void FixPointData::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.FixPointData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_internal_set_id(from._internal_id()); + } + if (from._internal_cno() != 0) { + _this->_internal_set_cno(from._internal_cno()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointx = from._internal_pointx(); + ::uint32_t raw_pointx; + memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx)); + if (raw_pointx != 0) { + _this->_internal_set_pointx(from._internal_pointx()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_pointy = from._internal_pointy(); + ::uint32_t raw_pointy; + memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy)); + if (raw_pointy != 0) { + _this->_internal_set_pointy(from._internal_pointy()); + } + if (from._internal_duration() != 0) { + _this->_internal_set_duration(from._internal_duration()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void FixPointData::CopyFrom(const FixPointData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.FixPointData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool FixPointData::IsInitialized() const { + return true; +} + +void FixPointData::InternalSwap(FixPointData* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_) + + sizeof(FixPointData::_impl_.duration_) + - PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_)>( + reinterpret_cast(&_impl_.id_), + reinterpret_cast(&other->_impl_.id_)); +} + +::google::protobuf::Metadata FixPointData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[14]); +} +// =================================================================== + +class ScanParamCfg::_Internal { + public: +}; + +ScanParamCfg::ScanParamCfg(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ScanParamCfg) +} +ScanParamCfg::ScanParamCfg(const ScanParamCfg& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.ScanParamCfg) +} +inline void ScanParamCfg::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.edgelevel_){0}, + decltype(_impl_.edgelevelmin_){0}, + decltype(_impl_.edgelevelmax_){0}, + decltype(_impl_.jumpdelay_){0u}, + decltype(_impl_.jumpdelaymin_){0u}, + decltype(_impl_.jumpdelaymax_){0u}, + decltype(_impl_.scandelay_){0u}, + decltype(_impl_.scandelaymin_){0u}, + decltype(_impl_.scandelaymax_){0u}, + decltype(_impl_.polygondelay_){0u}, + decltype(_impl_.polygondelaymin_){0u}, + decltype(_impl_.polygondelaymax_){0u}, + decltype(_impl_.laseroffdelay_){::int64_t{0}}, + decltype(_impl_.laseroffdelaymin_){::int64_t{0}}, + decltype(_impl_.laseroffdelaymax_){::int64_t{0}}, + decltype(_impl_.laserondelay_){::int64_t{0}}, + decltype(_impl_.laserondelaymin_){::int64_t{0}}, + decltype(_impl_.laserondelaymax_){::int64_t{0}}, + decltype(_impl_.minjumpdelay_){0u}, + decltype(_impl_.minjumpdelaymin_){0u}, + decltype(_impl_.minjumpdelaymax_){0u}, + decltype(_impl_.jumplengthlimit_){0u}, + decltype(_impl_.jumplengthlimitmin_){0u}, + decltype(_impl_.jumplengthlimitmax_){0u}, + decltype(_impl_.jumpspeed_){0}, + decltype(_impl_.jumpspeedmin_){0}, + decltype(_impl_.jumpspeedmax_){0}, + decltype(_impl_.markspeed_){0}, + decltype(_impl_.markspeedmin_){0}, + decltype(_impl_.markspeedmax_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +ScanParamCfg::~ScanParamCfg() { + // @@protoc_insertion_point(destructor:stream.ScanParamCfg) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ScanParamCfg::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void ScanParamCfg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ScanParamCfg::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ScanParamCfg) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.edgelevel_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.markspeedmax_) - + reinterpret_cast(&_impl_.edgelevel_)) + sizeof(_impl_.markspeedmax_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ScanParamCfg::_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<5, 30, 0, 0, 2> ScanParamCfg::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 30, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 3221225472, // skipmap + offsetof(decltype(_table_), field_entries), + 30, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_ScanParamCfg_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 edgeLevel = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevel_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_)}}, + // int32 edgeLevelMin = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevelmin_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmin_)}}, + // int32 edgeLevelMax = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevelmax_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmax_)}}, + // uint32 jumpDelay = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelay_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelay_)}}, + // uint32 jumpDelayMin = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelaymin_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymin_)}}, + // uint32 jumpDelayMax = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelaymax_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymax_)}}, + // uint32 scanDelay = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelay_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelay_)}}, + // uint32 scanDelayMin = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelaymin_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymin_)}}, + // uint32 scanDelayMax = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelaymax_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymax_)}}, + // uint32 polygonDelay = 10; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelay_), 63>(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelay_)}}, + // uint32 polygonDelayMin = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelaymin_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymin_)}}, + // uint32 polygonDelayMax = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelaymax_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymax_)}}, + // int64 laseroffDelay = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelay_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelay_)}}, + // int64 laseroffDelayMin = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelaymin_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymin_)}}, + // int64 laseroffDelayMax = 15; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelaymax_), 63>(), + {120, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymax_)}}, + // int64 laseronDelay = 16; + {::_pbi::TcParser::FastV64S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelay_)}}, + // int64 laseronDelayMin = 17; + {::_pbi::TcParser::FastV64S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymin_)}}, + // int64 laseronDelayMax = 18; + {::_pbi::TcParser::FastV64S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymax_)}}, + // uint32 minJumpDelay = 19; + {::_pbi::TcParser::FastV32S2, + {408, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelay_)}}, + // uint32 minJumpDelayMin = 20; + {::_pbi::TcParser::FastV32S2, + {416, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymin_)}}, + // uint32 minJumpDelayMax = 21; + {::_pbi::TcParser::FastV32S2, + {424, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymax_)}}, + // uint32 jumpLengthLimit = 22; + {::_pbi::TcParser::FastV32S2, + {432, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimit_)}}, + // uint32 jumpLengthLimitMin = 23; + {::_pbi::TcParser::FastV32S2, + {440, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmin_)}}, + // uint32 jumpLengthLimitMax = 24; + {::_pbi::TcParser::FastV32S2, + {448, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmax_)}}, + // double jumpSpeed = 25; + {::_pbi::TcParser::FastF64S2, + {457, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeed_)}}, + // double jumpSpeedMin = 26; + {::_pbi::TcParser::FastF64S2, + {465, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmin_)}}, + // double jumpSpeedMax = 27; + {::_pbi::TcParser::FastF64S2, + {473, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmax_)}}, + // double markSpeed = 28; + {::_pbi::TcParser::FastF64S2, + {481, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeed_)}}, + // double markSpeedMin = 29; + {::_pbi::TcParser::FastF64S2, + {489, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmin_)}}, + // double markSpeedMax = 30; + {::_pbi::TcParser::FastF64S2, + {497, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 edgeLevel = 1; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 edgeLevelMin = 2; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 edgeLevelMax = 3; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint32 jumpDelay = 4; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpDelayMin = 5; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpDelayMax = 6; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 scanDelay = 7; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 scanDelayMin = 8; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 scanDelayMax = 9; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 polygonDelay = 10; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 polygonDelayMin = 11; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 polygonDelayMax = 12; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // int64 laseroffDelay = 13; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseroffDelayMin = 14; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseroffDelayMax = 15; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseronDelay = 16; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseronDelayMin = 17; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laseronDelayMax = 18; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // uint32 minJumpDelay = 19; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelay_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 minJumpDelayMin = 20; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 minJumpDelayMax = 21; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpLengthLimit = 22; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimit_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpLengthLimitMin = 23; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 jumpLengthLimitMax = 24; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // double jumpSpeed = 25; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeed_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double jumpSpeedMin = 26; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double jumpSpeedMax = 27; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double markSpeed = 28; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeed_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double markSpeedMin = 29; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double markSpeedMax = 30; + {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* ScanParamCfg::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ScanParamCfg) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 edgeLevel = 1; + if (this->_internal_edgelevel() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_edgelevel(), target); + } + + // int32 edgeLevelMin = 2; + if (this->_internal_edgelevelmin() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_edgelevelmin(), target); + } + + // int32 edgeLevelMax = 3; + if (this->_internal_edgelevelmax() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this->_internal_edgelevelmax(), target); + } + + // uint32 jumpDelay = 4; + if (this->_internal_jumpdelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 4, this->_internal_jumpdelay(), target); + } + + // uint32 jumpDelayMin = 5; + if (this->_internal_jumpdelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 5, this->_internal_jumpdelaymin(), target); + } + + // uint32 jumpDelayMax = 6; + if (this->_internal_jumpdelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 6, this->_internal_jumpdelaymax(), target); + } + + // uint32 scanDelay = 7; + if (this->_internal_scandelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 7, this->_internal_scandelay(), target); + } + + // uint32 scanDelayMin = 8; + if (this->_internal_scandelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 8, this->_internal_scandelaymin(), target); + } + + // uint32 scanDelayMax = 9; + if (this->_internal_scandelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this->_internal_scandelaymax(), target); + } + + // uint32 polygonDelay = 10; + if (this->_internal_polygondelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 10, this->_internal_polygondelay(), target); + } + + // uint32 polygonDelayMin = 11; + if (this->_internal_polygondelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 11, this->_internal_polygondelaymin(), target); + } + + // uint32 polygonDelayMax = 12; + if (this->_internal_polygondelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 12, this->_internal_polygondelaymax(), target); + } + + // int64 laseroffDelay = 13; + if (this->_internal_laseroffdelay() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<13>( + stream, this->_internal_laseroffdelay(), target); + } + + // int64 laseroffDelayMin = 14; + if (this->_internal_laseroffdelaymin() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<14>( + stream, this->_internal_laseroffdelaymin(), target); + } + + // int64 laseroffDelayMax = 15; + if (this->_internal_laseroffdelaymax() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<15>( + stream, this->_internal_laseroffdelaymax(), target); + } + + // int64 laseronDelay = 16; + if (this->_internal_laserondelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 16, this->_internal_laserondelay(), target); + } + + // int64 laseronDelayMin = 17; + if (this->_internal_laserondelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 17, this->_internal_laserondelaymin(), target); + } + + // int64 laseronDelayMax = 18; + if (this->_internal_laserondelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 18, this->_internal_laserondelaymax(), target); + } + + // uint32 minJumpDelay = 19; + if (this->_internal_minjumpdelay() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 19, this->_internal_minjumpdelay(), target); + } + + // uint32 minJumpDelayMin = 20; + if (this->_internal_minjumpdelaymin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 20, this->_internal_minjumpdelaymin(), target); + } + + // uint32 minJumpDelayMax = 21; + if (this->_internal_minjumpdelaymax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 21, this->_internal_minjumpdelaymax(), target); + } + + // uint32 jumpLengthLimit = 22; + if (this->_internal_jumplengthlimit() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 22, this->_internal_jumplengthlimit(), target); + } + + // uint32 jumpLengthLimitMin = 23; + if (this->_internal_jumplengthlimitmin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 23, this->_internal_jumplengthlimitmin(), target); + } + + // uint32 jumpLengthLimitMax = 24; + if (this->_internal_jumplengthlimitmax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 24, this->_internal_jumplengthlimitmax(), target); + } + + // double jumpSpeed = 25; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeed = this->_internal_jumpspeed(); + ::uint64_t raw_jumpspeed; + memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed)); + if (raw_jumpspeed != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 25, this->_internal_jumpspeed(), target); + } + + // double jumpSpeedMin = 26; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmin = this->_internal_jumpspeedmin(); + ::uint64_t raw_jumpspeedmin; + memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin)); + if (raw_jumpspeedmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 26, this->_internal_jumpspeedmin(), target); + } + + // double jumpSpeedMax = 27; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmax = this->_internal_jumpspeedmax(); + ::uint64_t raw_jumpspeedmax; + memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax)); + if (raw_jumpspeedmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 27, this->_internal_jumpspeedmax(), target); + } + + // double markSpeed = 28; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeed = this->_internal_markspeed(); + ::uint64_t raw_markspeed; + memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed)); + if (raw_markspeed != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 28, this->_internal_markspeed(), target); + } + + // double markSpeedMin = 29; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmin = this->_internal_markspeedmin(); + ::uint64_t raw_markspeedmin; + memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin)); + if (raw_markspeedmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 29, this->_internal_markspeedmin(), target); + } + + // double markSpeedMax = 30; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmax = this->_internal_markspeedmax(); + ::uint64_t raw_markspeedmax; + memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax)); + if (raw_markspeedmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 30, this->_internal_markspeedmax(), 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.ScanParamCfg) + return target; +} + +::size_t ScanParamCfg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ScanParamCfg) + ::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 edgeLevel = 1; + if (this->_internal_edgelevel() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_edgelevel()); + } + + // int32 edgeLevelMin = 2; + if (this->_internal_edgelevelmin() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_edgelevelmin()); + } + + // int32 edgeLevelMax = 3; + if (this->_internal_edgelevelmax() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_edgelevelmax()); + } + + // uint32 jumpDelay = 4; + if (this->_internal_jumpdelay() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_jumpdelay()); + } + + // uint32 jumpDelayMin = 5; + if (this->_internal_jumpdelaymin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_jumpdelaymin()); + } + + // uint32 jumpDelayMax = 6; + if (this->_internal_jumpdelaymax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_jumpdelaymax()); + } + + // uint32 scanDelay = 7; + if (this->_internal_scandelay() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_scandelay()); + } + + // uint32 scanDelayMin = 8; + if (this->_internal_scandelaymin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_scandelaymin()); + } + + // uint32 scanDelayMax = 9; + if (this->_internal_scandelaymax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_scandelaymax()); + } + + // uint32 polygonDelay = 10; + if (this->_internal_polygondelay() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_polygondelay()); + } + + // uint32 polygonDelayMin = 11; + if (this->_internal_polygondelaymin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_polygondelaymin()); + } + + // uint32 polygonDelayMax = 12; + if (this->_internal_polygondelaymax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_polygondelaymax()); + } + + // int64 laseroffDelay = 13; + if (this->_internal_laseroffdelay() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseroffdelay()); + } + + // int64 laseroffDelayMin = 14; + if (this->_internal_laseroffdelaymin() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseroffdelaymin()); + } + + // int64 laseroffDelayMax = 15; + if (this->_internal_laseroffdelaymax() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseroffdelaymax()); + } + + // int64 laseronDelay = 16; + if (this->_internal_laserondelay() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int64Size( + this->_internal_laserondelay()); + } + + // int64 laseronDelayMin = 17; + if (this->_internal_laserondelaymin() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int64Size( + this->_internal_laserondelaymin()); + } + + // int64 laseronDelayMax = 18; + if (this->_internal_laserondelaymax() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int64Size( + this->_internal_laserondelaymax()); + } + + // uint32 minJumpDelay = 19; + if (this->_internal_minjumpdelay() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_minjumpdelay()); + } + + // uint32 minJumpDelayMin = 20; + if (this->_internal_minjumpdelaymin() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_minjumpdelaymin()); + } + + // uint32 minJumpDelayMax = 21; + if (this->_internal_minjumpdelaymax() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_minjumpdelaymax()); + } + + // uint32 jumpLengthLimit = 22; + if (this->_internal_jumplengthlimit() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_jumplengthlimit()); + } + + // uint32 jumpLengthLimitMin = 23; + if (this->_internal_jumplengthlimitmin() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_jumplengthlimitmin()); + } + + // uint32 jumpLengthLimitMax = 24; + if (this->_internal_jumplengthlimitmax() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_jumplengthlimitmax()); + } + + // double jumpSpeed = 25; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeed = this->_internal_jumpspeed(); + ::uint64_t raw_jumpspeed; + memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed)); + if (raw_jumpspeed != 0) { + total_size += 10; + } + + // double jumpSpeedMin = 26; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmin = this->_internal_jumpspeedmin(); + ::uint64_t raw_jumpspeedmin; + memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin)); + if (raw_jumpspeedmin != 0) { + total_size += 10; + } + + // double jumpSpeedMax = 27; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmax = this->_internal_jumpspeedmax(); + ::uint64_t raw_jumpspeedmax; + memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax)); + if (raw_jumpspeedmax != 0) { + total_size += 10; + } + + // double markSpeed = 28; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeed = this->_internal_markspeed(); + ::uint64_t raw_markspeed; + memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed)); + if (raw_markspeed != 0) { + total_size += 10; + } + + // double markSpeedMin = 29; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmin = this->_internal_markspeedmin(); + ::uint64_t raw_markspeedmin; + memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin)); + if (raw_markspeedmin != 0) { + total_size += 10; + } + + // double markSpeedMax = 30; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmax = this->_internal_markspeedmax(); + ::uint64_t raw_markspeedmax; + memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax)); + if (raw_markspeedmax != 0) { + total_size += 10; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ScanParamCfg::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ScanParamCfg::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ScanParamCfg::GetClassData() const { return &_class_data_; } + + +void ScanParamCfg::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.ScanParamCfg) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_edgelevel() != 0) { + _this->_internal_set_edgelevel(from._internal_edgelevel()); + } + if (from._internal_edgelevelmin() != 0) { + _this->_internal_set_edgelevelmin(from._internal_edgelevelmin()); + } + if (from._internal_edgelevelmax() != 0) { + _this->_internal_set_edgelevelmax(from._internal_edgelevelmax()); + } + if (from._internal_jumpdelay() != 0) { + _this->_internal_set_jumpdelay(from._internal_jumpdelay()); + } + if (from._internal_jumpdelaymin() != 0) { + _this->_internal_set_jumpdelaymin(from._internal_jumpdelaymin()); + } + if (from._internal_jumpdelaymax() != 0) { + _this->_internal_set_jumpdelaymax(from._internal_jumpdelaymax()); + } + if (from._internal_scandelay() != 0) { + _this->_internal_set_scandelay(from._internal_scandelay()); + } + if (from._internal_scandelaymin() != 0) { + _this->_internal_set_scandelaymin(from._internal_scandelaymin()); + } + if (from._internal_scandelaymax() != 0) { + _this->_internal_set_scandelaymax(from._internal_scandelaymax()); + } + if (from._internal_polygondelay() != 0) { + _this->_internal_set_polygondelay(from._internal_polygondelay()); + } + if (from._internal_polygondelaymin() != 0) { + _this->_internal_set_polygondelaymin(from._internal_polygondelaymin()); + } + if (from._internal_polygondelaymax() != 0) { + _this->_internal_set_polygondelaymax(from._internal_polygondelaymax()); + } + if (from._internal_laseroffdelay() != 0) { + _this->_internal_set_laseroffdelay(from._internal_laseroffdelay()); + } + if (from._internal_laseroffdelaymin() != 0) { + _this->_internal_set_laseroffdelaymin(from._internal_laseroffdelaymin()); + } + if (from._internal_laseroffdelaymax() != 0) { + _this->_internal_set_laseroffdelaymax(from._internal_laseroffdelaymax()); + } + if (from._internal_laserondelay() != 0) { + _this->_internal_set_laserondelay(from._internal_laserondelay()); + } + if (from._internal_laserondelaymin() != 0) { + _this->_internal_set_laserondelaymin(from._internal_laserondelaymin()); + } + if (from._internal_laserondelaymax() != 0) { + _this->_internal_set_laserondelaymax(from._internal_laserondelaymax()); + } + if (from._internal_minjumpdelay() != 0) { + _this->_internal_set_minjumpdelay(from._internal_minjumpdelay()); + } + if (from._internal_minjumpdelaymin() != 0) { + _this->_internal_set_minjumpdelaymin(from._internal_minjumpdelaymin()); + } + if (from._internal_minjumpdelaymax() != 0) { + _this->_internal_set_minjumpdelaymax(from._internal_minjumpdelaymax()); + } + if (from._internal_jumplengthlimit() != 0) { + _this->_internal_set_jumplengthlimit(from._internal_jumplengthlimit()); + } + if (from._internal_jumplengthlimitmin() != 0) { + _this->_internal_set_jumplengthlimitmin(from._internal_jumplengthlimitmin()); + } + if (from._internal_jumplengthlimitmax() != 0) { + _this->_internal_set_jumplengthlimitmax(from._internal_jumplengthlimitmax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeed = from._internal_jumpspeed(); + ::uint64_t raw_jumpspeed; + memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed)); + if (raw_jumpspeed != 0) { + _this->_internal_set_jumpspeed(from._internal_jumpspeed()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmin = from._internal_jumpspeedmin(); + ::uint64_t raw_jumpspeedmin; + memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin)); + if (raw_jumpspeedmin != 0) { + _this->_internal_set_jumpspeedmin(from._internal_jumpspeedmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_jumpspeedmax = from._internal_jumpspeedmax(); + ::uint64_t raw_jumpspeedmax; + memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax)); + if (raw_jumpspeedmax != 0) { + _this->_internal_set_jumpspeedmax(from._internal_jumpspeedmax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeed = from._internal_markspeed(); + ::uint64_t raw_markspeed; + memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed)); + if (raw_markspeed != 0) { + _this->_internal_set_markspeed(from._internal_markspeed()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmin = from._internal_markspeedmin(); + ::uint64_t raw_markspeedmin; + memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin)); + if (raw_markspeedmin != 0) { + _this->_internal_set_markspeedmin(from._internal_markspeedmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_markspeedmax = from._internal_markspeedmax(); + ::uint64_t raw_markspeedmax; + memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax)); + if (raw_markspeedmax != 0) { + _this->_internal_set_markspeedmax(from._internal_markspeedmax()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ScanParamCfg::CopyFrom(const ScanParamCfg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScanParamCfg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ScanParamCfg::IsInitialized() const { + return true; +} + +void ScanParamCfg::InternalSwap(ScanParamCfg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_) + + sizeof(ScanParamCfg::_impl_.markspeedmax_) + - PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_)>( + reinterpret_cast(&_impl_.edgelevel_), + reinterpret_cast(&other->_impl_.edgelevel_)); +} + +::google::protobuf::Metadata ScanParamCfg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[15]); +} +// =================================================================== + +class CorrectParamCfg::_Internal { + public: +}; + +CorrectParamCfg::CorrectParamCfg(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.CorrectParamCfg) +} +CorrectParamCfg::CorrectParamCfg(const CorrectParamCfg& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.CorrectParamCfg) +} +inline void CorrectParamCfg::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.xmeasuremin_){0}, + decltype(_impl_.xmeasuremax_){0}, + decltype(_impl_.ymeasuremin_){0}, + decltype(_impl_.ymeasuremax_){0}, + decltype(_impl_.xposfix_){0}, + decltype(_impl_.yposfix_){0}, + decltype(_impl_.scanangle_){0}, + decltype(_impl_.scananglemin_){0}, + decltype(_impl_.scananglemax_){0}, + decltype(_impl_.fixangle_){0}, + decltype(_impl_.fixanglemin_){0}, + decltype(_impl_.fixanglemax_){0}, + decltype(_impl_.xcorrect_){0}, + decltype(_impl_.ycorrect_){0}, + decltype(_impl_.xcorrectmin_){0}, + decltype(_impl_.xcorrectmax_){0}, + decltype(_impl_.ycorrectmin_){0}, + decltype(_impl_.ycorrectmax_){0}, + decltype(_impl_.realxoffset_){0}, + decltype(_impl_.realyoffset_){0}, + decltype(_impl_.factork_){0}, + decltype(_impl_.defocusratio_){0}, + decltype(_impl_.defocusratiomin_){0}, + decltype(_impl_.defocusratiomax_){0}, + decltype(_impl_.iscorrectfile3d_){false}, + decltype(_impl_.isdynamicfocus_){false}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +CorrectParamCfg::~CorrectParamCfg() { + // @@protoc_insertion_point(destructor:stream.CorrectParamCfg) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void CorrectParamCfg::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void CorrectParamCfg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void CorrectParamCfg::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.CorrectParamCfg) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.xmeasuremin_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.isdynamicfocus_) - + reinterpret_cast(&_impl_.xmeasuremin_)) + sizeof(_impl_.isdynamicfocus_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* CorrectParamCfg::_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<5, 26, 0, 0, 2> CorrectParamCfg::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 26, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4227858432, // skipmap + offsetof(decltype(_table_), field_entries), + 26, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_CorrectParamCfg_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // double xmeasureMin = 1; + {::_pbi::TcParser::FastF64S1, + {9, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_)}}, + // double xmeasureMax = 2; + {::_pbi::TcParser::FastF64S1, + {17, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremax_)}}, + // double ymeasureMin = 3; + {::_pbi::TcParser::FastF64S1, + {25, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremin_)}}, + // double ymeasureMax = 4; + {::_pbi::TcParser::FastF64S1, + {33, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremax_)}}, + // double xposfix = 5; + {::_pbi::TcParser::FastF64S1, + {41, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xposfix_)}}, + // double yposfix = 6; + {::_pbi::TcParser::FastF64S1, + {49, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.yposfix_)}}, + // double scanAngle = 7; + {::_pbi::TcParser::FastF64S1, + {57, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scanangle_)}}, + // double scanAngleMin = 8; + {::_pbi::TcParser::FastF64S1, + {65, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemin_)}}, + // double scanAngleMax = 9; + {::_pbi::TcParser::FastF64S1, + {73, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemax_)}}, + // double fixAngle = 10; + {::_pbi::TcParser::FastF64S1, + {81, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixangle_)}}, + // double fixAngleMin = 11; + {::_pbi::TcParser::FastF64S1, + {89, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemin_)}}, + // double fixAngleMax = 12; + {::_pbi::TcParser::FastF64S1, + {97, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemax_)}}, + // double xcorrect = 13; + {::_pbi::TcParser::FastF64S1, + {105, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrect_)}}, + // double ycorrect = 14; + {::_pbi::TcParser::FastF64S1, + {113, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrect_)}}, + // double xcorrectMin = 15; + {::_pbi::TcParser::FastF64S1, + {121, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmin_)}}, + // double xcorrectMax = 16; + {::_pbi::TcParser::FastF64S2, + {385, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmax_)}}, + // double ycorrectMin = 17; + {::_pbi::TcParser::FastF64S2, + {393, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmin_)}}, + // double ycorrectMax = 18; + {::_pbi::TcParser::FastF64S2, + {401, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmax_)}}, + // double realXOffset = 19; + {::_pbi::TcParser::FastF64S2, + {409, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realxoffset_)}}, + // double realYOffset = 20; + {::_pbi::TcParser::FastF64S2, + {417, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realyoffset_)}}, + // double factorK = 21; + {::_pbi::TcParser::FastF64S2, + {425, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.factork_)}}, + // bool isCorrectFile3D = 22; + {::_pbi::TcParser::FastV8S2, + {432, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.iscorrectfile3d_)}}, + // bool isDynamicFocus = 23; + {::_pbi::TcParser::FastV8S2, + {440, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_)}}, + // double defocusRatio = 24; + {::_pbi::TcParser::FastF64S2, + {449, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratio_)}}, + // double defocusRatioMin = 25; + {::_pbi::TcParser::FastF64S2, + {457, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomin_)}}, + // double defocusRatioMax = 26; + {::_pbi::TcParser::FastF64S2, + {465, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomax_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // double xmeasureMin = 1; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xmeasureMax = 2; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ymeasureMin = 3; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ymeasureMax = 4; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xposfix = 5; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xposfix_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double yposfix = 6; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.yposfix_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double scanAngle = 7; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scanangle_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double scanAngleMin = 8; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double scanAngleMax = 9; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double fixAngle = 10; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixangle_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double fixAngleMin = 11; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double fixAngleMax = 12; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xcorrect = 13; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrect_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ycorrect = 14; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrect_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xcorrectMin = 15; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double xcorrectMax = 16; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ycorrectMin = 17; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double ycorrectMax = 18; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double realXOffset = 19; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realxoffset_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double realYOffset = 20; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realyoffset_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double factorK = 21; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.factork_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool isCorrectFile3D = 22; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.iscorrectfile3d_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool isDynamicFocus = 23; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // double defocusRatio = 24; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratio_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double defocusRatioMin = 25; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double defocusRatioMax = 26; + {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* CorrectParamCfg::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.CorrectParamCfg) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // double xmeasureMin = 1; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremin = this->_internal_xmeasuremin(); + ::uint64_t raw_xmeasuremin; + memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin)); + if (raw_xmeasuremin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 1, this->_internal_xmeasuremin(), target); + } + + // double xmeasureMax = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremax = this->_internal_xmeasuremax(); + ::uint64_t raw_xmeasuremax; + memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax)); + if (raw_xmeasuremax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 2, this->_internal_xmeasuremax(), target); + } + + // double ymeasureMin = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremin = this->_internal_ymeasuremin(); + ::uint64_t raw_ymeasuremin; + memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin)); + if (raw_ymeasuremin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 3, this->_internal_ymeasuremin(), target); + } + + // double ymeasureMax = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremax = this->_internal_ymeasuremax(); + ::uint64_t raw_ymeasuremax; + memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax)); + if (raw_ymeasuremax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 4, this->_internal_ymeasuremax(), target); + } + + // double xposfix = 5; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xposfix = this->_internal_xposfix(); + ::uint64_t raw_xposfix; + memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix)); + if (raw_xposfix != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 5, this->_internal_xposfix(), target); + } + + // double yposfix = 6; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_yposfix = this->_internal_yposfix(); + ::uint64_t raw_yposfix; + memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix)); + if (raw_yposfix != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 6, this->_internal_yposfix(), target); + } + + // double scanAngle = 7; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scanangle = this->_internal_scanangle(); + ::uint64_t raw_scanangle; + memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle)); + if (raw_scanangle != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 7, this->_internal_scanangle(), target); + } + + // double scanAngleMin = 8; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemin = this->_internal_scananglemin(); + ::uint64_t raw_scananglemin; + memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin)); + if (raw_scananglemin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 8, this->_internal_scananglemin(), target); + } + + // double scanAngleMax = 9; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemax = this->_internal_scananglemax(); + ::uint64_t raw_scananglemax; + memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax)); + if (raw_scananglemax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 9, this->_internal_scananglemax(), target); + } + + // double fixAngle = 10; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixangle = this->_internal_fixangle(); + ::uint64_t raw_fixangle; + memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle)); + if (raw_fixangle != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 10, this->_internal_fixangle(), target); + } + + // double fixAngleMin = 11; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemin = this->_internal_fixanglemin(); + ::uint64_t raw_fixanglemin; + memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin)); + if (raw_fixanglemin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 11, this->_internal_fixanglemin(), target); + } + + // double fixAngleMax = 12; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemax = this->_internal_fixanglemax(); + ::uint64_t raw_fixanglemax; + memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax)); + if (raw_fixanglemax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 12, this->_internal_fixanglemax(), target); + } + + // double xcorrect = 13; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrect = this->_internal_xcorrect(); + ::uint64_t raw_xcorrect; + memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect)); + if (raw_xcorrect != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 13, this->_internal_xcorrect(), target); + } + + // double ycorrect = 14; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrect = this->_internal_ycorrect(); + ::uint64_t raw_ycorrect; + memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect)); + if (raw_ycorrect != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 14, this->_internal_ycorrect(), target); + } + + // double xcorrectMin = 15; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmin = this->_internal_xcorrectmin(); + ::uint64_t raw_xcorrectmin; + memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin)); + if (raw_xcorrectmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 15, this->_internal_xcorrectmin(), target); + } + + // double xcorrectMax = 16; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmax = this->_internal_xcorrectmax(); + ::uint64_t raw_xcorrectmax; + memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax)); + if (raw_xcorrectmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 16, this->_internal_xcorrectmax(), target); + } + + // double ycorrectMin = 17; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmin = this->_internal_ycorrectmin(); + ::uint64_t raw_ycorrectmin; + memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin)); + if (raw_ycorrectmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 17, this->_internal_ycorrectmin(), target); + } + + // double ycorrectMax = 18; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmax = this->_internal_ycorrectmax(); + ::uint64_t raw_ycorrectmax; + memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax)); + if (raw_ycorrectmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 18, this->_internal_ycorrectmax(), target); + } + + // double realXOffset = 19; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realxoffset = this->_internal_realxoffset(); + ::uint64_t raw_realxoffset; + memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset)); + if (raw_realxoffset != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 19, this->_internal_realxoffset(), target); + } + + // double realYOffset = 20; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realyoffset = this->_internal_realyoffset(); + ::uint64_t raw_realyoffset; + memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset)); + if (raw_realyoffset != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 20, this->_internal_realyoffset(), target); + } + + // double factorK = 21; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_factork = this->_internal_factork(); + ::uint64_t raw_factork; + memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork)); + if (raw_factork != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 21, this->_internal_factork(), target); + } + + // bool isCorrectFile3D = 22; + if (this->_internal_iscorrectfile3d() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 22, this->_internal_iscorrectfile3d(), target); + } + + // bool isDynamicFocus = 23; + if (this->_internal_isdynamicfocus() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 23, this->_internal_isdynamicfocus(), target); + } + + // double defocusRatio = 24; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratio = this->_internal_defocusratio(); + ::uint64_t raw_defocusratio; + memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio)); + if (raw_defocusratio != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 24, this->_internal_defocusratio(), target); + } + + // double defocusRatioMin = 25; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomin = this->_internal_defocusratiomin(); + ::uint64_t raw_defocusratiomin; + memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin)); + if (raw_defocusratiomin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 25, this->_internal_defocusratiomin(), target); + } + + // double defocusRatioMax = 26; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomax = this->_internal_defocusratiomax(); + ::uint64_t raw_defocusratiomax; + memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax)); + if (raw_defocusratiomax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 26, this->_internal_defocusratiomax(), 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.CorrectParamCfg) + return target; +} + +::size_t CorrectParamCfg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.CorrectParamCfg) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // double xmeasureMin = 1; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremin = this->_internal_xmeasuremin(); + ::uint64_t raw_xmeasuremin; + memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin)); + if (raw_xmeasuremin != 0) { + total_size += 9; + } + + // double xmeasureMax = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremax = this->_internal_xmeasuremax(); + ::uint64_t raw_xmeasuremax; + memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax)); + if (raw_xmeasuremax != 0) { + total_size += 9; + } + + // double ymeasureMin = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremin = this->_internal_ymeasuremin(); + ::uint64_t raw_ymeasuremin; + memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin)); + if (raw_ymeasuremin != 0) { + total_size += 9; + } + + // double ymeasureMax = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremax = this->_internal_ymeasuremax(); + ::uint64_t raw_ymeasuremax; + memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax)); + if (raw_ymeasuremax != 0) { + total_size += 9; + } + + // double xposfix = 5; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xposfix = this->_internal_xposfix(); + ::uint64_t raw_xposfix; + memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix)); + if (raw_xposfix != 0) { + total_size += 9; + } + + // double yposfix = 6; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_yposfix = this->_internal_yposfix(); + ::uint64_t raw_yposfix; + memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix)); + if (raw_yposfix != 0) { + total_size += 9; + } + + // double scanAngle = 7; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scanangle = this->_internal_scanangle(); + ::uint64_t raw_scanangle; + memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle)); + if (raw_scanangle != 0) { + total_size += 9; + } + + // double scanAngleMin = 8; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemin = this->_internal_scananglemin(); + ::uint64_t raw_scananglemin; + memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin)); + if (raw_scananglemin != 0) { + total_size += 9; + } + + // double scanAngleMax = 9; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemax = this->_internal_scananglemax(); + ::uint64_t raw_scananglemax; + memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax)); + if (raw_scananglemax != 0) { + total_size += 9; + } + + // double fixAngle = 10; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixangle = this->_internal_fixangle(); + ::uint64_t raw_fixangle; + memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle)); + if (raw_fixangle != 0) { + total_size += 9; + } + + // double fixAngleMin = 11; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemin = this->_internal_fixanglemin(); + ::uint64_t raw_fixanglemin; + memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin)); + if (raw_fixanglemin != 0) { + total_size += 9; + } + + // double fixAngleMax = 12; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemax = this->_internal_fixanglemax(); + ::uint64_t raw_fixanglemax; + memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax)); + if (raw_fixanglemax != 0) { + total_size += 9; + } + + // double xcorrect = 13; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrect = this->_internal_xcorrect(); + ::uint64_t raw_xcorrect; + memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect)); + if (raw_xcorrect != 0) { + total_size += 9; + } + + // double ycorrect = 14; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrect = this->_internal_ycorrect(); + ::uint64_t raw_ycorrect; + memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect)); + if (raw_ycorrect != 0) { + total_size += 9; + } + + // double xcorrectMin = 15; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmin = this->_internal_xcorrectmin(); + ::uint64_t raw_xcorrectmin; + memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin)); + if (raw_xcorrectmin != 0) { + total_size += 9; + } + + // double xcorrectMax = 16; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmax = this->_internal_xcorrectmax(); + ::uint64_t raw_xcorrectmax; + memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax)); + if (raw_xcorrectmax != 0) { + total_size += 10; + } + + // double ycorrectMin = 17; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmin = this->_internal_ycorrectmin(); + ::uint64_t raw_ycorrectmin; + memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin)); + if (raw_ycorrectmin != 0) { + total_size += 10; + } + + // double ycorrectMax = 18; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmax = this->_internal_ycorrectmax(); + ::uint64_t raw_ycorrectmax; + memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax)); + if (raw_ycorrectmax != 0) { + total_size += 10; + } + + // double realXOffset = 19; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realxoffset = this->_internal_realxoffset(); + ::uint64_t raw_realxoffset; + memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset)); + if (raw_realxoffset != 0) { + total_size += 10; + } + + // double realYOffset = 20; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realyoffset = this->_internal_realyoffset(); + ::uint64_t raw_realyoffset; + memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset)); + if (raw_realyoffset != 0) { + total_size += 10; + } + + // double factorK = 21; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_factork = this->_internal_factork(); + ::uint64_t raw_factork; + memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork)); + if (raw_factork != 0) { + total_size += 10; + } + + // double defocusRatio = 24; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratio = this->_internal_defocusratio(); + ::uint64_t raw_defocusratio; + memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio)); + if (raw_defocusratio != 0) { + total_size += 10; + } + + // double defocusRatioMin = 25; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomin = this->_internal_defocusratiomin(); + ::uint64_t raw_defocusratiomin; + memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin)); + if (raw_defocusratiomin != 0) { + total_size += 10; + } + + // double defocusRatioMax = 26; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomax = this->_internal_defocusratiomax(); + ::uint64_t raw_defocusratiomax; + memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax)); + if (raw_defocusratiomax != 0) { + total_size += 10; + } + + // bool isCorrectFile3D = 22; + if (this->_internal_iscorrectfile3d() != 0) { + total_size += 3; + } + + // bool isDynamicFocus = 23; + if (this->_internal_isdynamicfocus() != 0) { + total_size += 3; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData CorrectParamCfg::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + CorrectParamCfg::MergeImpl +}; +const ::google::protobuf::Message::ClassData*CorrectParamCfg::GetClassData() const { return &_class_data_; } + + +void CorrectParamCfg::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.CorrectParamCfg) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremin = from._internal_xmeasuremin(); + ::uint64_t raw_xmeasuremin; + memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin)); + if (raw_xmeasuremin != 0) { + _this->_internal_set_xmeasuremin(from._internal_xmeasuremin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xmeasuremax = from._internal_xmeasuremax(); + ::uint64_t raw_xmeasuremax; + memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax)); + if (raw_xmeasuremax != 0) { + _this->_internal_set_xmeasuremax(from._internal_xmeasuremax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremin = from._internal_ymeasuremin(); + ::uint64_t raw_ymeasuremin; + memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin)); + if (raw_ymeasuremin != 0) { + _this->_internal_set_ymeasuremin(from._internal_ymeasuremin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ymeasuremax = from._internal_ymeasuremax(); + ::uint64_t raw_ymeasuremax; + memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax)); + if (raw_ymeasuremax != 0) { + _this->_internal_set_ymeasuremax(from._internal_ymeasuremax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xposfix = from._internal_xposfix(); + ::uint64_t raw_xposfix; + memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix)); + if (raw_xposfix != 0) { + _this->_internal_set_xposfix(from._internal_xposfix()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_yposfix = from._internal_yposfix(); + ::uint64_t raw_yposfix; + memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix)); + if (raw_yposfix != 0) { + _this->_internal_set_yposfix(from._internal_yposfix()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scanangle = from._internal_scanangle(); + ::uint64_t raw_scanangle; + memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle)); + if (raw_scanangle != 0) { + _this->_internal_set_scanangle(from._internal_scanangle()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemin = from._internal_scananglemin(); + ::uint64_t raw_scananglemin; + memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin)); + if (raw_scananglemin != 0) { + _this->_internal_set_scananglemin(from._internal_scananglemin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_scananglemax = from._internal_scananglemax(); + ::uint64_t raw_scananglemax; + memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax)); + if (raw_scananglemax != 0) { + _this->_internal_set_scananglemax(from._internal_scananglemax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixangle = from._internal_fixangle(); + ::uint64_t raw_fixangle; + memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle)); + if (raw_fixangle != 0) { + _this->_internal_set_fixangle(from._internal_fixangle()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemin = from._internal_fixanglemin(); + ::uint64_t raw_fixanglemin; + memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin)); + if (raw_fixanglemin != 0) { + _this->_internal_set_fixanglemin(from._internal_fixanglemin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_fixanglemax = from._internal_fixanglemax(); + ::uint64_t raw_fixanglemax; + memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax)); + if (raw_fixanglemax != 0) { + _this->_internal_set_fixanglemax(from._internal_fixanglemax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrect = from._internal_xcorrect(); + ::uint64_t raw_xcorrect; + memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect)); + if (raw_xcorrect != 0) { + _this->_internal_set_xcorrect(from._internal_xcorrect()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrect = from._internal_ycorrect(); + ::uint64_t raw_ycorrect; + memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect)); + if (raw_ycorrect != 0) { + _this->_internal_set_ycorrect(from._internal_ycorrect()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmin = from._internal_xcorrectmin(); + ::uint64_t raw_xcorrectmin; + memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin)); + if (raw_xcorrectmin != 0) { + _this->_internal_set_xcorrectmin(from._internal_xcorrectmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_xcorrectmax = from._internal_xcorrectmax(); + ::uint64_t raw_xcorrectmax; + memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax)); + if (raw_xcorrectmax != 0) { + _this->_internal_set_xcorrectmax(from._internal_xcorrectmax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmin = from._internal_ycorrectmin(); + ::uint64_t raw_ycorrectmin; + memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin)); + if (raw_ycorrectmin != 0) { + _this->_internal_set_ycorrectmin(from._internal_ycorrectmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_ycorrectmax = from._internal_ycorrectmax(); + ::uint64_t raw_ycorrectmax; + memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax)); + if (raw_ycorrectmax != 0) { + _this->_internal_set_ycorrectmax(from._internal_ycorrectmax()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realxoffset = from._internal_realxoffset(); + ::uint64_t raw_realxoffset; + memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset)); + if (raw_realxoffset != 0) { + _this->_internal_set_realxoffset(from._internal_realxoffset()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_realyoffset = from._internal_realyoffset(); + ::uint64_t raw_realyoffset; + memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset)); + if (raw_realyoffset != 0) { + _this->_internal_set_realyoffset(from._internal_realyoffset()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_factork = from._internal_factork(); + ::uint64_t raw_factork; + memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork)); + if (raw_factork != 0) { + _this->_internal_set_factork(from._internal_factork()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratio = from._internal_defocusratio(); + ::uint64_t raw_defocusratio; + memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio)); + if (raw_defocusratio != 0) { + _this->_internal_set_defocusratio(from._internal_defocusratio()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomin = from._internal_defocusratiomin(); + ::uint64_t raw_defocusratiomin; + memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin)); + if (raw_defocusratiomin != 0) { + _this->_internal_set_defocusratiomin(from._internal_defocusratiomin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocusratiomax = from._internal_defocusratiomax(); + ::uint64_t raw_defocusratiomax; + memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax)); + if (raw_defocusratiomax != 0) { + _this->_internal_set_defocusratiomax(from._internal_defocusratiomax()); + } + if (from._internal_iscorrectfile3d() != 0) { + _this->_internal_set_iscorrectfile3d(from._internal_iscorrectfile3d()); + } + if (from._internal_isdynamicfocus() != 0) { + _this->_internal_set_isdynamicfocus(from._internal_isdynamicfocus()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void CorrectParamCfg::CopyFrom(const CorrectParamCfg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.CorrectParamCfg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool CorrectParamCfg::IsInitialized() const { + return true; +} + +void CorrectParamCfg::InternalSwap(CorrectParamCfg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_) + + sizeof(CorrectParamCfg::_impl_.isdynamicfocus_) + - PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_)>( + reinterpret_cast(&_impl_.xmeasuremin_), + reinterpret_cast(&other->_impl_.xmeasuremin_)); +} + +::google::protobuf::Metadata CorrectParamCfg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[16]); +} +// =================================================================== + +class ScanTestCfg::_Internal { + public: +}; + +ScanTestCfg::ScanTestCfg(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.ScanTestCfg) +} +ScanTestCfg::ScanTestCfg(const ScanTestCfg& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.ScanTestCfg) +} +inline void ScanTestCfg::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.debugshape_){0}, + decltype(_impl_.shapesize_){0}, + decltype(_impl_.shapesizemin_){0}, + decltype(_impl_.shape_size_max_){0}, + decltype(_impl_.laser_power_){0}, + decltype(_impl_.laser_power_min_){0}, + decltype(_impl_.defocus_){0}, + decltype(_impl_.defocus_min_){0}, + decltype(_impl_.defocus_max_){0}, + decltype(_impl_.laser_power_max_){0}, + decltype(_impl_.is_cycle_){false}, + decltype(_impl_.isautoheatingscanner_){false}, + decltype(_impl_.cross_x_){0}, + decltype(_impl_.cross_y_){0}, + decltype(_impl_.z_distance_){0}, + decltype(_impl_.autoheatingscannerminutes_){0u}, + decltype(_impl_.autoheatingscannersize_){0u}, + decltype(_impl_.autoheatingscannerspeed_){0}, + decltype(_impl_.mark_test_start_x_){0}, + decltype(_impl_.mark_test_start_y_){0}, + decltype(_impl_.mark_test_end_x_){0}, + decltype(_impl_.mark_test_end_y_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +ScanTestCfg::~ScanTestCfg() { + // @@protoc_insertion_point(destructor:stream.ScanTestCfg) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void ScanTestCfg::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void ScanTestCfg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void ScanTestCfg::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.ScanTestCfg) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.debugshape_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.mark_test_end_y_) - + reinterpret_cast(&_impl_.debugshape_)) + sizeof(_impl_.mark_test_end_y_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* ScanTestCfg::_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<5, 22, 0, 0, 2> ScanTestCfg::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 22, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4290772992, // skipmap + offsetof(decltype(_table_), field_entries), + 22, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_ScanTestCfg_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 debugShape = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.debugshape_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_)}}, + // int32 shapeSize = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shapesize_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesize_)}}, + // int32 shapeSizeMin = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shapesizemin_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesizemin_)}}, + // int32 shape_size_max = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shape_size_max_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shape_size_max_)}}, + // int32 laser_power = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_)}}, + // int32 laser_power_min = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_min_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_min_)}}, + // int32 laser_power_max = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_max_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_max_)}}, + // double defocus = 8; + {::_pbi::TcParser::FastF64S1, + {65, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_)}}, + // double defocus_min = 9; + {::_pbi::TcParser::FastF64S1, + {73, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_min_)}}, + // double defocus_max = 10; + {::_pbi::TcParser::FastF64S1, + {81, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_max_)}}, + // bool is_cycle = 11; + {::_pbi::TcParser::SingularVarintNoZag1(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.is_cycle_)}}, + // double cross_x = 12; + {::_pbi::TcParser::FastF64S1, + {97, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_x_)}}, + // double cross_y = 13; + {::_pbi::TcParser::FastF64S1, + {105, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_y_)}}, + // double z_distance = 14; + {::_pbi::TcParser::FastF64S1, + {113, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.z_distance_)}}, + // bool isAutoHeatingScanner = 15; + {::_pbi::TcParser::SingularVarintNoZag1(), + {120, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.isautoheatingscanner_)}}, + // uint32 autoHeatingScannerMinutes = 16; + {::_pbi::TcParser::FastV32S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerminutes_)}}, + // uint32 autoHeatingScannerSize = 17; + {::_pbi::TcParser::FastV32S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannersize_)}}, + // double autoHeatingScannerSpeed = 18; + {::_pbi::TcParser::FastF64S2, + {401, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerspeed_)}}, + // double mark_test_start_x = 19; + {::_pbi::TcParser::FastF64S2, + {409, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_x_)}}, + // double mark_test_start_y = 20; + {::_pbi::TcParser::FastF64S2, + {417, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_y_)}}, + // double mark_test_end_x = 21; + {::_pbi::TcParser::FastF64S2, + {425, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_x_)}}, + // double mark_test_end_y = 22; + {::_pbi::TcParser::FastF64S2, + {433, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 debugShape = 1; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 shapeSize = 2; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesize_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 shapeSizeMin = 3; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesizemin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 shape_size_max = 4; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shape_size_max_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 laser_power = 5; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 laser_power_min = 6; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_min_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 laser_power_max = 7; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_max_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // double defocus = 8; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double defocus_min = 9; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_min_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double defocus_max = 10; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_max_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool is_cycle = 11; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.is_cycle_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // double cross_x = 12; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double cross_y = 13; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double z_distance = 14; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.z_distance_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool isAutoHeatingScanner = 15; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.isautoheatingscanner_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // uint32 autoHeatingScannerMinutes = 16; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerminutes_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 autoHeatingScannerSize = 17; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannersize_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // double autoHeatingScannerSpeed = 18; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerspeed_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double mark_test_start_x = 19; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double mark_test_start_y = 20; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double mark_test_end_x = 21; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double mark_test_end_y = 22; + {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* ScanTestCfg::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.ScanTestCfg) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 debugShape = 1; + if (this->_internal_debugshape() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_debugshape(), target); + } + + // int32 shapeSize = 2; + if (this->_internal_shapesize() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_shapesize(), target); + } + + // int32 shapeSizeMin = 3; + if (this->_internal_shapesizemin() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this->_internal_shapesizemin(), target); + } + + // int32 shape_size_max = 4; + if (this->_internal_shape_size_max() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this->_internal_shape_size_max(), target); + } + + // int32 laser_power = 5; + if (this->_internal_laser_power() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<5>( + stream, this->_internal_laser_power(), target); + } + + // int32 laser_power_min = 6; + if (this->_internal_laser_power_min() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<6>( + stream, this->_internal_laser_power_min(), target); + } + + // int32 laser_power_max = 7; + if (this->_internal_laser_power_max() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<7>( + stream, this->_internal_laser_power_max(), target); + } + + // double defocus = 8; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus = this->_internal_defocus(); + ::uint64_t raw_defocus; + memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus)); + if (raw_defocus != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 8, this->_internal_defocus(), target); + } + + // double defocus_min = 9; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_min = this->_internal_defocus_min(); + ::uint64_t raw_defocus_min; + memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min)); + if (raw_defocus_min != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 9, this->_internal_defocus_min(), target); + } + + // double defocus_max = 10; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_max = this->_internal_defocus_max(); + ::uint64_t raw_defocus_max; + memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max)); + if (raw_defocus_max != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 10, this->_internal_defocus_max(), target); + } + + // bool is_cycle = 11; + if (this->_internal_is_cycle() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 11, this->_internal_is_cycle(), target); + } + + // double cross_x = 12; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_x = this->_internal_cross_x(); + ::uint64_t raw_cross_x; + memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x)); + if (raw_cross_x != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 12, this->_internal_cross_x(), target); + } + + // double cross_y = 13; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_y = this->_internal_cross_y(); + ::uint64_t raw_cross_y; + memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y)); + if (raw_cross_y != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 13, this->_internal_cross_y(), target); + } + + // double z_distance = 14; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z_distance = this->_internal_z_distance(); + ::uint64_t raw_z_distance; + memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance)); + if (raw_z_distance != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 14, this->_internal_z_distance(), target); + } + + // bool isAutoHeatingScanner = 15; + if (this->_internal_isautoheatingscanner() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 15, this->_internal_isautoheatingscanner(), target); + } + + // uint32 autoHeatingScannerMinutes = 16; + if (this->_internal_autoheatingscannerminutes() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 16, this->_internal_autoheatingscannerminutes(), target); + } + + // uint32 autoHeatingScannerSize = 17; + if (this->_internal_autoheatingscannersize() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 17, this->_internal_autoheatingscannersize(), target); + } + + // double autoHeatingScannerSpeed = 18; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_autoheatingscannerspeed = this->_internal_autoheatingscannerspeed(); + ::uint64_t raw_autoheatingscannerspeed; + memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed)); + if (raw_autoheatingscannerspeed != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 18, this->_internal_autoheatingscannerspeed(), target); + } + + // double mark_test_start_x = 19; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_x = this->_internal_mark_test_start_x(); + ::uint64_t raw_mark_test_start_x; + memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x)); + if (raw_mark_test_start_x != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 19, this->_internal_mark_test_start_x(), target); + } + + // double mark_test_start_y = 20; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_y = this->_internal_mark_test_start_y(); + ::uint64_t raw_mark_test_start_y; + memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y)); + if (raw_mark_test_start_y != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 20, this->_internal_mark_test_start_y(), target); + } + + // double mark_test_end_x = 21; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_x = this->_internal_mark_test_end_x(); + ::uint64_t raw_mark_test_end_x; + memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x)); + if (raw_mark_test_end_x != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 21, this->_internal_mark_test_end_x(), target); + } + + // double mark_test_end_y = 22; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_y = this->_internal_mark_test_end_y(); + ::uint64_t raw_mark_test_end_y; + memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y)); + if (raw_mark_test_end_y != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 22, this->_internal_mark_test_end_y(), 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.ScanTestCfg) + return target; +} + +::size_t ScanTestCfg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.ScanTestCfg) + ::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 debugShape = 1; + if (this->_internal_debugshape() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_debugshape()); + } + + // int32 shapeSize = 2; + if (this->_internal_shapesize() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_shapesize()); + } + + // int32 shapeSizeMin = 3; + if (this->_internal_shapesizemin() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_shapesizemin()); + } + + // int32 shape_size_max = 4; + if (this->_internal_shape_size_max() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_shape_size_max()); + } + + // int32 laser_power = 5; + if (this->_internal_laser_power() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_laser_power()); + } + + // int32 laser_power_min = 6; + if (this->_internal_laser_power_min() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_laser_power_min()); + } + + // double defocus = 8; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus = this->_internal_defocus(); + ::uint64_t raw_defocus; + memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus)); + if (raw_defocus != 0) { + total_size += 9; + } + + // double defocus_min = 9; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_min = this->_internal_defocus_min(); + ::uint64_t raw_defocus_min; + memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min)); + if (raw_defocus_min != 0) { + total_size += 9; + } + + // double defocus_max = 10; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_max = this->_internal_defocus_max(); + ::uint64_t raw_defocus_max; + memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max)); + if (raw_defocus_max != 0) { + total_size += 9; + } + + // int32 laser_power_max = 7; + if (this->_internal_laser_power_max() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_laser_power_max()); + } + + // bool is_cycle = 11; + if (this->_internal_is_cycle() != 0) { + total_size += 2; + } + + // bool isAutoHeatingScanner = 15; + if (this->_internal_isautoheatingscanner() != 0) { + total_size += 2; + } + + // double cross_x = 12; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_x = this->_internal_cross_x(); + ::uint64_t raw_cross_x; + memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x)); + if (raw_cross_x != 0) { + total_size += 9; + } + + // double cross_y = 13; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_y = this->_internal_cross_y(); + ::uint64_t raw_cross_y; + memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y)); + if (raw_cross_y != 0) { + total_size += 9; + } + + // double z_distance = 14; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z_distance = this->_internal_z_distance(); + ::uint64_t raw_z_distance; + memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance)); + if (raw_z_distance != 0) { + total_size += 9; + } + + // uint32 autoHeatingScannerMinutes = 16; + if (this->_internal_autoheatingscannerminutes() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_autoheatingscannerminutes()); + } + + // uint32 autoHeatingScannerSize = 17; + if (this->_internal_autoheatingscannersize() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_autoheatingscannersize()); + } + + // double autoHeatingScannerSpeed = 18; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_autoheatingscannerspeed = this->_internal_autoheatingscannerspeed(); + ::uint64_t raw_autoheatingscannerspeed; + memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed)); + if (raw_autoheatingscannerspeed != 0) { + total_size += 10; + } + + // double mark_test_start_x = 19; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_x = this->_internal_mark_test_start_x(); + ::uint64_t raw_mark_test_start_x; + memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x)); + if (raw_mark_test_start_x != 0) { + total_size += 10; + } + + // double mark_test_start_y = 20; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_y = this->_internal_mark_test_start_y(); + ::uint64_t raw_mark_test_start_y; + memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y)); + if (raw_mark_test_start_y != 0) { + total_size += 10; + } + + // double mark_test_end_x = 21; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_x = this->_internal_mark_test_end_x(); + ::uint64_t raw_mark_test_end_x; + memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x)); + if (raw_mark_test_end_x != 0) { + total_size += 10; + } + + // double mark_test_end_y = 22; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_y = this->_internal_mark_test_end_y(); + ::uint64_t raw_mark_test_end_y; + memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y)); + if (raw_mark_test_end_y != 0) { + total_size += 10; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData ScanTestCfg::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + ScanTestCfg::MergeImpl +}; +const ::google::protobuf::Message::ClassData*ScanTestCfg::GetClassData() const { return &_class_data_; } + + +void ScanTestCfg::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.ScanTestCfg) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_debugshape() != 0) { + _this->_internal_set_debugshape(from._internal_debugshape()); + } + if (from._internal_shapesize() != 0) { + _this->_internal_set_shapesize(from._internal_shapesize()); + } + if (from._internal_shapesizemin() != 0) { + _this->_internal_set_shapesizemin(from._internal_shapesizemin()); + } + if (from._internal_shape_size_max() != 0) { + _this->_internal_set_shape_size_max(from._internal_shape_size_max()); + } + if (from._internal_laser_power() != 0) { + _this->_internal_set_laser_power(from._internal_laser_power()); + } + if (from._internal_laser_power_min() != 0) { + _this->_internal_set_laser_power_min(from._internal_laser_power_min()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus = from._internal_defocus(); + ::uint64_t raw_defocus; + memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus)); + if (raw_defocus != 0) { + _this->_internal_set_defocus(from._internal_defocus()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_min = from._internal_defocus_min(); + ::uint64_t raw_defocus_min; + memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min)); + if (raw_defocus_min != 0) { + _this->_internal_set_defocus_min(from._internal_defocus_min()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_defocus_max = from._internal_defocus_max(); + ::uint64_t raw_defocus_max; + memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max)); + if (raw_defocus_max != 0) { + _this->_internal_set_defocus_max(from._internal_defocus_max()); + } + if (from._internal_laser_power_max() != 0) { + _this->_internal_set_laser_power_max(from._internal_laser_power_max()); + } + if (from._internal_is_cycle() != 0) { + _this->_internal_set_is_cycle(from._internal_is_cycle()); + } + if (from._internal_isautoheatingscanner() != 0) { + _this->_internal_set_isautoheatingscanner(from._internal_isautoheatingscanner()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_x = from._internal_cross_x(); + ::uint64_t raw_cross_x; + memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x)); + if (raw_cross_x != 0) { + _this->_internal_set_cross_x(from._internal_cross_x()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_cross_y = from._internal_cross_y(); + ::uint64_t raw_cross_y; + memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y)); + if (raw_cross_y != 0) { + _this->_internal_set_cross_y(from._internal_cross_y()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z_distance = from._internal_z_distance(); + ::uint64_t raw_z_distance; + memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance)); + if (raw_z_distance != 0) { + _this->_internal_set_z_distance(from._internal_z_distance()); + } + if (from._internal_autoheatingscannerminutes() != 0) { + _this->_internal_set_autoheatingscannerminutes(from._internal_autoheatingscannerminutes()); + } + if (from._internal_autoheatingscannersize() != 0) { + _this->_internal_set_autoheatingscannersize(from._internal_autoheatingscannersize()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_autoheatingscannerspeed = from._internal_autoheatingscannerspeed(); + ::uint64_t raw_autoheatingscannerspeed; + memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed)); + if (raw_autoheatingscannerspeed != 0) { + _this->_internal_set_autoheatingscannerspeed(from._internal_autoheatingscannerspeed()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_x = from._internal_mark_test_start_x(); + ::uint64_t raw_mark_test_start_x; + memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x)); + if (raw_mark_test_start_x != 0) { + _this->_internal_set_mark_test_start_x(from._internal_mark_test_start_x()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_start_y = from._internal_mark_test_start_y(); + ::uint64_t raw_mark_test_start_y; + memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y)); + if (raw_mark_test_start_y != 0) { + _this->_internal_set_mark_test_start_y(from._internal_mark_test_start_y()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_x = from._internal_mark_test_end_x(); + ::uint64_t raw_mark_test_end_x; + memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x)); + if (raw_mark_test_end_x != 0) { + _this->_internal_set_mark_test_end_x(from._internal_mark_test_end_x()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_mark_test_end_y = from._internal_mark_test_end_y(); + ::uint64_t raw_mark_test_end_y; + memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y)); + if (raw_mark_test_end_y != 0) { + _this->_internal_set_mark_test_end_y(from._internal_mark_test_end_y()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ScanTestCfg::CopyFrom(const ScanTestCfg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScanTestCfg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool ScanTestCfg::IsInitialized() const { + return true; +} + +void ScanTestCfg::InternalSwap(ScanTestCfg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_) + + sizeof(ScanTestCfg::_impl_.mark_test_end_y_) + - PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_)>( + reinterpret_cast(&_impl_.debugshape_), + reinterpret_cast(&other->_impl_.debugshape_)); +} + +::google::protobuf::Metadata ScanTestCfg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[17]); +} +// =================================================================== + +class SkyWritingCfg::_Internal { + public: +}; + +SkyWritingCfg::SkyWritingCfg(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.SkyWritingCfg) +} +SkyWritingCfg::SkyWritingCfg(const SkyWritingCfg& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.SkyWritingCfg) +} +inline void SkyWritingCfg::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.timelag_){0}, + decltype(_impl_.timelagmin_){0}, + decltype(_impl_.timelagmax_){0}, + decltype(_impl_.isenable_){false}, + decltype(_impl_.nprev_){0u}, + decltype(_impl_.laseronshift_){::int64_t{0}}, + decltype(_impl_.laseronshiftmin_){::int64_t{0}}, + decltype(_impl_.laseronshiftmax_){::int64_t{0}}, + decltype(_impl_.nprevmin_){0u}, + decltype(_impl_.nprevmax_){0u}, + decltype(_impl_.npost_){0u}, + decltype(_impl_.npostmin_){0u}, + decltype(_impl_.npostmax_){0u}, + decltype(_impl_.mode_){0}, + decltype(_impl_.limite_){0}, + decltype(_impl_.limitemin_){0}, + decltype(_impl_.limitemax_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +SkyWritingCfg::~SkyWritingCfg() { + // @@protoc_insertion_point(destructor:stream.SkyWritingCfg) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void SkyWritingCfg::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void SkyWritingCfg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void SkyWritingCfg::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.SkyWritingCfg) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.timelag_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.limitemax_) - + reinterpret_cast(&_impl_.timelag_)) + sizeof(_impl_.limitemax_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* SkyWritingCfg::_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<5, 17, 0, 0, 2> SkyWritingCfg::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 17, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294836224, // skipmap + offsetof(decltype(_table_), field_entries), + 17, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_SkyWritingCfg_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bool isEnable = 1; + {::_pbi::TcParser::SingularVarintNoZag1(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.isenable_)}}, + // double timelag = 2; + {::_pbi::TcParser::FastF64S1, + {17, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_)}}, + // double timelagMin = 3; + {::_pbi::TcParser::FastF64S1, + {25, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmin_)}}, + // double timelagMax = 4; + {::_pbi::TcParser::FastF64S1, + {33, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmax_)}}, + // int64 laserOnShift = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshift_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshift_)}}, + // int64 laserOnShiftMin = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshiftmin_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmin_)}}, + // int64 laserOnShiftMax = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshiftmax_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmax_)}}, + // uint32 nprev = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprev_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprev_)}}, + // uint32 nprevMin = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprevmin_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmin_)}}, + // uint32 nprevMax = 10; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprevmax_), 63>(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmax_)}}, + // uint32 npost = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npost_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npost_)}}, + // uint32 npostMin = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npostmin_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmin_)}}, + // uint32 npostMax = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npostmax_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmax_)}}, + // int32 mode = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.mode_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.mode_)}}, + // double limite = 15; + {::_pbi::TcParser::FastF64S1, + {121, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limite_)}}, + // double limiteMin = 16; + {::_pbi::TcParser::FastF64S2, + {385, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemin_)}}, + // double limiteMax = 17; + {::_pbi::TcParser::FastF64S2, + {393, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool isEnable = 1; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.isenable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // double timelag = 2; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double timelagMin = 3; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double timelagMax = 4; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // int64 laserOnShift = 5; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshift_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laserOnShiftMin = 6; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 laserOnShiftMax = 7; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // uint32 nprev = 8; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprev_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 nprevMin = 9; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 nprevMax = 10; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 npost = 11; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npost_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 npostMin = 12; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 npostMax = 13; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // int32 mode = 14; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.mode_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // double limite = 15; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limite_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double limiteMin = 16; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemin_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double limiteMax = 17; + {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* SkyWritingCfg::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.SkyWritingCfg) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // bool isEnable = 1; + if (this->_internal_isenable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 1, this->_internal_isenable(), target); + } + + // double timelag = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelag = this->_internal_timelag(); + ::uint64_t raw_timelag; + memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag)); + if (raw_timelag != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 2, this->_internal_timelag(), target); + } + + // double timelagMin = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmin = this->_internal_timelagmin(); + ::uint64_t raw_timelagmin; + memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin)); + if (raw_timelagmin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 3, this->_internal_timelagmin(), target); + } + + // double timelagMax = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmax = this->_internal_timelagmax(); + ::uint64_t raw_timelagmax; + memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax)); + if (raw_timelagmax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 4, this->_internal_timelagmax(), target); + } + + // int64 laserOnShift = 5; + if (this->_internal_laseronshift() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<5>( + stream, this->_internal_laseronshift(), target); + } + + // int64 laserOnShiftMin = 6; + if (this->_internal_laseronshiftmin() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<6>( + stream, this->_internal_laseronshiftmin(), target); + } + + // int64 laserOnShiftMax = 7; + if (this->_internal_laseronshiftmax() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<7>( + stream, this->_internal_laseronshiftmax(), target); + } + + // uint32 nprev = 8; + if (this->_internal_nprev() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 8, this->_internal_nprev(), target); + } + + // uint32 nprevMin = 9; + if (this->_internal_nprevmin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this->_internal_nprevmin(), target); + } + + // uint32 nprevMax = 10; + if (this->_internal_nprevmax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 10, this->_internal_nprevmax(), target); + } + + // uint32 npost = 11; + if (this->_internal_npost() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 11, this->_internal_npost(), target); + } + + // uint32 npostMin = 12; + if (this->_internal_npostmin() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 12, this->_internal_npostmin(), target); + } + + // uint32 npostMax = 13; + if (this->_internal_npostmax() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 13, this->_internal_npostmax(), target); + } + + // int32 mode = 14; + if (this->_internal_mode() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this->_internal_mode(), target); + } + + // double limite = 15; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limite = this->_internal_limite(); + ::uint64_t raw_limite; + memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite)); + if (raw_limite != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 15, this->_internal_limite(), target); + } + + // double limiteMin = 16; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemin = this->_internal_limitemin(); + ::uint64_t raw_limitemin; + memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin)); + if (raw_limitemin != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 16, this->_internal_limitemin(), target); + } + + // double limiteMax = 17; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemax = this->_internal_limitemax(); + ::uint64_t raw_limitemax; + memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax)); + if (raw_limitemax != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 17, this->_internal_limitemax(), 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.SkyWritingCfg) + return target; +} + +::size_t SkyWritingCfg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.SkyWritingCfg) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // double timelag = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelag = this->_internal_timelag(); + ::uint64_t raw_timelag; + memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag)); + if (raw_timelag != 0) { + total_size += 9; + } + + // double timelagMin = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmin = this->_internal_timelagmin(); + ::uint64_t raw_timelagmin; + memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin)); + if (raw_timelagmin != 0) { + total_size += 9; + } + + // double timelagMax = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmax = this->_internal_timelagmax(); + ::uint64_t raw_timelagmax; + memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax)); + if (raw_timelagmax != 0) { + total_size += 9; + } + + // bool isEnable = 1; + if (this->_internal_isenable() != 0) { + total_size += 2; + } + + // uint32 nprev = 8; + if (this->_internal_nprev() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_nprev()); + } + + // int64 laserOnShift = 5; + if (this->_internal_laseronshift() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseronshift()); + } + + // int64 laserOnShiftMin = 6; + if (this->_internal_laseronshiftmin() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseronshiftmin()); + } + + // int64 laserOnShiftMax = 7; + if (this->_internal_laseronshiftmax() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_laseronshiftmax()); + } + + // uint32 nprevMin = 9; + if (this->_internal_nprevmin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_nprevmin()); + } + + // uint32 nprevMax = 10; + if (this->_internal_nprevmax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_nprevmax()); + } + + // uint32 npost = 11; + if (this->_internal_npost() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_npost()); + } + + // uint32 npostMin = 12; + if (this->_internal_npostmin() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_npostmin()); + } + + // uint32 npostMax = 13; + if (this->_internal_npostmax() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_npostmax()); + } + + // int32 mode = 14; + if (this->_internal_mode() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_mode()); + } + + // double limite = 15; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limite = this->_internal_limite(); + ::uint64_t raw_limite; + memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite)); + if (raw_limite != 0) { + total_size += 9; + } + + // double limiteMin = 16; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemin = this->_internal_limitemin(); + ::uint64_t raw_limitemin; + memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin)); + if (raw_limitemin != 0) { + total_size += 10; + } + + // double limiteMax = 17; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemax = this->_internal_limitemax(); + ::uint64_t raw_limitemax; + memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax)); + if (raw_limitemax != 0) { + total_size += 10; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData SkyWritingCfg::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + SkyWritingCfg::MergeImpl +}; +const ::google::protobuf::Message::ClassData*SkyWritingCfg::GetClassData() const { return &_class_data_; } + + +void SkyWritingCfg::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.SkyWritingCfg) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelag = from._internal_timelag(); + ::uint64_t raw_timelag; + memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag)); + if (raw_timelag != 0) { + _this->_internal_set_timelag(from._internal_timelag()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmin = from._internal_timelagmin(); + ::uint64_t raw_timelagmin; + memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin)); + if (raw_timelagmin != 0) { + _this->_internal_set_timelagmin(from._internal_timelagmin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_timelagmax = from._internal_timelagmax(); + ::uint64_t raw_timelagmax; + memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax)); + if (raw_timelagmax != 0) { + _this->_internal_set_timelagmax(from._internal_timelagmax()); + } + if (from._internal_isenable() != 0) { + _this->_internal_set_isenable(from._internal_isenable()); + } + if (from._internal_nprev() != 0) { + _this->_internal_set_nprev(from._internal_nprev()); + } + if (from._internal_laseronshift() != 0) { + _this->_internal_set_laseronshift(from._internal_laseronshift()); + } + if (from._internal_laseronshiftmin() != 0) { + _this->_internal_set_laseronshiftmin(from._internal_laseronshiftmin()); + } + if (from._internal_laseronshiftmax() != 0) { + _this->_internal_set_laseronshiftmax(from._internal_laseronshiftmax()); + } + if (from._internal_nprevmin() != 0) { + _this->_internal_set_nprevmin(from._internal_nprevmin()); + } + if (from._internal_nprevmax() != 0) { + _this->_internal_set_nprevmax(from._internal_nprevmax()); + } + if (from._internal_npost() != 0) { + _this->_internal_set_npost(from._internal_npost()); + } + if (from._internal_npostmin() != 0) { + _this->_internal_set_npostmin(from._internal_npostmin()); + } + if (from._internal_npostmax() != 0) { + _this->_internal_set_npostmax(from._internal_npostmax()); + } + if (from._internal_mode() != 0) { + _this->_internal_set_mode(from._internal_mode()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limite = from._internal_limite(); + ::uint64_t raw_limite; + memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite)); + if (raw_limite != 0) { + _this->_internal_set_limite(from._internal_limite()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemin = from._internal_limitemin(); + ::uint64_t raw_limitemin; + memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin)); + if (raw_limitemin != 0) { + _this->_internal_set_limitemin(from._internal_limitemin()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_limitemax = from._internal_limitemax(); + ::uint64_t raw_limitemax; + memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax)); + if (raw_limitemax != 0) { + _this->_internal_set_limitemax(from._internal_limitemax()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SkyWritingCfg::CopyFrom(const SkyWritingCfg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.SkyWritingCfg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool SkyWritingCfg::IsInitialized() const { + return true; +} + +void SkyWritingCfg::InternalSwap(SkyWritingCfg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_) + + sizeof(SkyWritingCfg::_impl_.limitemax_) + - PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_)>( + reinterpret_cast(&_impl_.timelag_), + reinterpret_cast(&other->_impl_.timelag_)); +} + +::google::protobuf::Metadata SkyWritingCfg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[18]); +} +// =================================================================== + +class PowerCompensate::_Internal { + public: +}; + +PowerCompensate::PowerCompensate(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.PowerCompensate) +} +PowerCompensate::PowerCompensate(const PowerCompensate& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.PowerCompensate) +} +inline void PowerCompensate::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.cno_){0}, + decltype(_impl_.percent_){0}, + decltype(_impl_.value_){0}, + decltype(_impl_.value_min_){0}, + decltype(_impl_.value_max_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +PowerCompensate::~PowerCompensate() { + // @@protoc_insertion_point(destructor:stream.PowerCompensate) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void PowerCompensate::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void PowerCompensate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void PowerCompensate::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.PowerCompensate) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.cno_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.value_max_) - + reinterpret_cast(&_impl_.cno_)) + sizeof(_impl_.value_max_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* PowerCompensate::_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, 0, 0, 2> PowerCompensate::_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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_PowerCompensate_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 cno = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PowerCompensate, _impl_.cno_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_)}}, + // int32 percent = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PowerCompensate, _impl_.percent_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.percent_)}}, + // float value = 3; + {::_pbi::TcParser::FastF32S1, + {29, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_)}}, + // float value_min = 4; + {::_pbi::TcParser::FastF32S1, + {37, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_min_)}}, + // float value_max = 5; + {::_pbi::TcParser::FastF32S1, + {45, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 cno = 1; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 percent = 2; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.percent_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // float value = 3; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float value_min = 4; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_min_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + // float value_max = 5; + {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* PowerCompensate::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.PowerCompensate) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 cno = 1; + if (this->_internal_cno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_cno(), target); + } + + // int32 percent = 2; + if (this->_internal_percent() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_percent(), target); + } + + // float value = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value = this->_internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 3, this->_internal_value(), target); + } + + // float value_min = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_min = this->_internal_value_min(); + ::uint32_t raw_value_min; + memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min)); + if (raw_value_min != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 4, this->_internal_value_min(), target); + } + + // float value_max = 5; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_max = this->_internal_value_max(); + ::uint32_t raw_value_max; + memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max)); + if (raw_value_max != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 5, this->_internal_value_max(), 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.PowerCompensate) + return target; +} + +::size_t PowerCompensate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.PowerCompensate) + ::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 cno = 1; + if (this->_internal_cno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_cno()); + } + + // int32 percent = 2; + if (this->_internal_percent() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_percent()); + } + + // float value = 3; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value = this->_internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + total_size += 5; + } + + // float value_min = 4; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_min = this->_internal_value_min(); + ::uint32_t raw_value_min; + memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min)); + if (raw_value_min != 0) { + total_size += 5; + } + + // float value_max = 5; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_max = this->_internal_value_max(); + ::uint32_t raw_value_max; + memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max)); + if (raw_value_max != 0) { + total_size += 5; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData PowerCompensate::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + PowerCompensate::MergeImpl +}; +const ::google::protobuf::Message::ClassData*PowerCompensate::GetClassData() const { return &_class_data_; } + + +void PowerCompensate::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.PowerCompensate) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_cno() != 0) { + _this->_internal_set_cno(from._internal_cno()); + } + if (from._internal_percent() != 0) { + _this->_internal_set_percent(from._internal_percent()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value = from._internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + _this->_internal_set_value(from._internal_value()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_min = from._internal_value_min(); + ::uint32_t raw_value_min; + memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min)); + if (raw_value_min != 0) { + _this->_internal_set_value_min(from._internal_value_min()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_value_max = from._internal_value_max(); + ::uint32_t raw_value_max; + memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max)); + if (raw_value_max != 0) { + _this->_internal_set_value_max(from._internal_value_max()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void PowerCompensate::CopyFrom(const PowerCompensate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.PowerCompensate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool PowerCompensate::IsInitialized() const { + return true; +} + +void PowerCompensate::InternalSwap(PowerCompensate* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_) + + sizeof(PowerCompensate::_impl_.value_max_) + - PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_)>( + reinterpret_cast(&_impl_.cno_), + reinterpret_cast(&other->_impl_.cno_)); +} + +::google::protobuf::Metadata PowerCompensate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[19]); +} +// =================================================================== + +class TimePowerCompensate::_Internal { + public: +}; + +TimePowerCompensate::TimePowerCompensate(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:stream.TimePowerCompensate) +} +TimePowerCompensate::TimePowerCompensate(const TimePowerCompensate& from) + : ::google::protobuf::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:stream.TimePowerCompensate) +} +inline void TimePowerCompensate::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.id_){0}, + decltype(_impl_.cno_){0}, + decltype(_impl_.startminute_){0u}, + decltype(_impl_.endminute_){0u}, + decltype(_impl_.compensate_){0}, + /*decltype(_impl_._cached_size_)*/ {}, + }; +} +TimePowerCompensate::~TimePowerCompensate() { + // @@protoc_insertion_point(destructor:stream.TimePowerCompensate) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void TimePowerCompensate::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} +void TimePowerCompensate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +PROTOBUF_NOINLINE void TimePowerCompensate::Clear() { +// @@protoc_insertion_point(message_clear_start:stream.TimePowerCompensate) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.compensate_) - + reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.compensate_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* TimePowerCompensate::_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, 0, 0, 2> TimePowerCompensate::_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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_TimePowerCompensate_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_)}}, + // int32 cno = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.cno_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.cno_)}}, + // uint32 startMinute = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.startminute_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.startminute_)}}, + // uint32 endMinute = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.endminute_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.endminute_)}}, + // float compensate = 5; + {::_pbi::TcParser::FastF32S1, + {45, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 id = 1; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 cno = 2; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.cno_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint32 startMinute = 3; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.startminute_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 endMinute = 4; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.endminute_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // float compensate = 5; + {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kFloat)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* TimePowerCompensate::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:stream.TimePowerCompensate) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 id = 1; + if (this->_internal_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this->_internal_id(), target); + } + + // int32 cno = 2; + if (this->_internal_cno() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this->_internal_cno(), target); + } + + // uint32 startMinute = 3; + if (this->_internal_startminute() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this->_internal_startminute(), target); + } + + // uint32 endMinute = 4; + if (this->_internal_endminute() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 4, this->_internal_endminute(), target); + } + + // float compensate = 5; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_compensate = this->_internal_compensate(); + ::uint32_t raw_compensate; + memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate)); + if (raw_compensate != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 5, this->_internal_compensate(), 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.TimePowerCompensate) + return target; +} + +::size_t TimePowerCompensate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:stream.TimePowerCompensate) + ::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 id = 1; + if (this->_internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_id()); + } + + // int32 cno = 2; + if (this->_internal_cno() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_cno()); + } + + // uint32 startMinute = 3; + if (this->_internal_startminute() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_startminute()); + } + + // uint32 endMinute = 4; + if (this->_internal_endminute() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_endminute()); + } + + // float compensate = 5; + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_compensate = this->_internal_compensate(); + ::uint32_t raw_compensate; + memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate)); + if (raw_compensate != 0) { + total_size += 5; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData TimePowerCompensate::_class_data_ = { + ::google::protobuf::Message::CopyWithSourceCheck, + TimePowerCompensate::MergeImpl +}; +const ::google::protobuf::Message::ClassData*TimePowerCompensate::GetClassData() const { return &_class_data_; } + + +void TimePowerCompensate::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.TimePowerCompensate) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_internal_set_id(from._internal_id()); + } + if (from._internal_cno() != 0) { + _this->_internal_set_cno(from._internal_cno()); + } + if (from._internal_startminute() != 0) { + _this->_internal_set_startminute(from._internal_startminute()); + } + if (from._internal_endminute() != 0) { + _this->_internal_set_endminute(from._internal_endminute()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), + "Code assumes ::uint32_t and float are the same size."); + float tmp_compensate = from._internal_compensate(); + ::uint32_t raw_compensate; + memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate)); + if (raw_compensate != 0) { + _this->_internal_set_compensate(from._internal_compensate()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void TimePowerCompensate::CopyFrom(const TimePowerCompensate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:stream.TimePowerCompensate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool TimePowerCompensate::IsInitialized() const { + return true; +} + +void TimePowerCompensate::InternalSwap(TimePowerCompensate* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_) + + sizeof(TimePowerCompensate::_impl_.compensate_) + - PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_)>( + reinterpret_cast(&_impl_.id_), + reinterpret_cast(&other->_impl_.id_)); +} + +::google::protobuf::Metadata TimePowerCompensate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once, + file_level_metadata_stream_2eproto[20]); +} // @@protoc_insertion_point(namespace_scope) } // namespace stream namespace google { diff --git a/TestClient/protobuf/stream.pb.h b/TestClient/protobuf/stream.pb.h index 4fd7990..f1a7c96 100644 --- a/TestClient/protobuf/stream.pb.h +++ b/TestClient/protobuf/stream.pb.h @@ -62,6 +62,12 @@ extern ChainDataBlockDefaultTypeInternal _ChainDataBlock_default_instance_; class ComResponce; struct ComResponceDefaultTypeInternal; extern ComResponceDefaultTypeInternal _ComResponce_default_instance_; +class CorrectParamCfg; +struct CorrectParamCfgDefaultTypeInternal; +extern CorrectParamCfgDefaultTypeInternal _CorrectParamCfg_default_instance_; +class FixPointData; +struct FixPointDataDefaultTypeInternal; +extern FixPointDataDefaultTypeInternal _FixPointData_default_instance_; class ImgInfoResponce; struct ImgInfoResponceDefaultTypeInternal; extern ImgInfoResponceDefaultTypeInternal _ImgInfoResponce_default_instance_; @@ -77,6 +83,9 @@ extern ParamInfoDefaultTypeInternal _ParamInfo_default_instance_; class Point; struct PointDefaultTypeInternal; extern PointDefaultTypeInternal _Point_default_instance_; +class PowerCompensate; +struct PowerCompensateDefaultTypeInternal; +extern PowerCompensateDefaultTypeInternal _PowerCompensate_default_instance_; class RegResponce; struct RegResponceDefaultTypeInternal; extern RegResponceDefaultTypeInternal _RegResponce_default_instance_; @@ -89,6 +98,24 @@ extern ResponseAnyDefaultTypeInternal _ResponseAny_default_instance_; class ResponseInfo; struct ResponseInfoDefaultTypeInternal; extern ResponseInfoDefaultTypeInternal _ResponseInfo_default_instance_; +class ScanParamCfg; +struct ScanParamCfgDefaultTypeInternal; +extern ScanParamCfgDefaultTypeInternal _ScanParamCfg_default_instance_; +class ScanTestCfg; +struct ScanTestCfgDefaultTypeInternal; +extern ScanTestCfgDefaultTypeInternal _ScanTestCfg_default_instance_; +class ScannerCrtlCfgData; +struct ScannerCrtlCfgDataDefaultTypeInternal; +extern ScannerCrtlCfgDataDefaultTypeInternal _ScannerCrtlCfgData_default_instance_; +class ScannerCrtlCfgResp; +struct ScannerCrtlCfgRespDefaultTypeInternal; +extern ScannerCrtlCfgRespDefaultTypeInternal _ScannerCrtlCfgResp_default_instance_; +class SkyWritingCfg; +struct SkyWritingCfgDefaultTypeInternal; +extern SkyWritingCfgDefaultTypeInternal _SkyWritingCfg_default_instance_; +class TimePowerCompensate; +struct TimePowerCompensateDefaultTypeInternal; +extern TimePowerCompensateDefaultTypeInternal _TimePowerCompensate_default_instance_; class VectorDataBlock; struct VectorDataBlockDefaultTypeInternal; extern VectorDataBlockDefaultTypeInternal _VectorDataBlock_default_instance_; @@ -311,13 +338,21 @@ class ParamInfo final : kNameKeyFieldNumber = 1, kStrValueFieldNumber = 2, kContextFieldNumber = 4, + kCardNameFieldNumber = 15, + kCardIPFieldNumber = 16, kValueTypeFieldNumber = 3, + kStartLayerFieldNumber = 8, kIsEnableFieldNumber = 5, kIsAlarmFieldNumber = 6, kIsShowFieldNumber = 7, - kStartLayerFieldNumber = 8, + kHadAssignFieldNumber = 17, kEndLayerFieldNumber = 9, kPowderFieldNumber = 10, + kSeqNoFieldNumber = 11, + kControlNoFieldNumber = 12, + kSerialNoFieldNumber = 13, + kControlTypeFieldNumber = 14, + kHadMatchFieldNumber = 18, }; // bytes nameKey = 1; void clear_namekey() ; @@ -366,6 +401,38 @@ class ParamInfo final : const std::string& value); std::string* _internal_mutable_context(); + public: + // bytes cardName = 15; + void clear_cardname() ; + const std::string& cardname() const; + template + void set_cardname(Arg_&& arg, Args_... args); + std::string* mutable_cardname(); + PROTOBUF_NODISCARD std::string* release_cardname(); + void set_allocated_cardname(std::string* ptr); + + private: + const std::string& _internal_cardname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardname( + const std::string& value); + std::string* _internal_mutable_cardname(); + + public: + // bytes cardIP = 16; + void clear_cardip() ; + const std::string& cardip() const; + template + void set_cardip(Arg_&& arg, Args_... args); + std::string* mutable_cardip(); + PROTOBUF_NODISCARD std::string* release_cardip(); + void set_allocated_cardip(std::string* ptr); + + private: + const std::string& _internal_cardip() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardip( + const std::string& value); + std::string* _internal_mutable_cardip(); + public: // .stream.TYPE valueType = 3; void clear_valuetype() ; @@ -376,6 +443,16 @@ class ParamInfo final : ::stream::TYPE _internal_valuetype() const; void _internal_set_valuetype(::stream::TYPE value); + public: + // int32 startLayer = 8; + void clear_startlayer() ; + ::int32_t startlayer() const; + void set_startlayer(::int32_t value); + + private: + ::int32_t _internal_startlayer() const; + void _internal_set_startlayer(::int32_t value); + public: // bool isEnable = 5; void clear_isenable() ; @@ -407,14 +484,14 @@ class ParamInfo final : void _internal_set_isshow(bool value); public: - // int32 startLayer = 8; - void clear_startlayer() ; - ::int32_t startlayer() const; - void set_startlayer(::int32_t value); + // bool hadAssign = 17; + void clear_hadassign() ; + bool hadassign() const; + void set_hadassign(bool value); private: - ::int32_t _internal_startlayer() const; - void _internal_set_startlayer(::int32_t value); + bool _internal_hadassign() const; + void _internal_set_hadassign(bool value); public: // int32 endLayer = 9; @@ -436,13 +513,63 @@ class ParamInfo final : float _internal_powder() const; void _internal_set_powder(float value); + public: + // int32 seqNo = 11; + void clear_seqno() ; + ::int32_t seqno() const; + void set_seqno(::int32_t value); + + private: + ::int32_t _internal_seqno() const; + void _internal_set_seqno(::int32_t value); + + public: + // int32 controlNo = 12; + void clear_controlno() ; + ::int32_t controlno() const; + void set_controlno(::int32_t value); + + private: + ::int32_t _internal_controlno() const; + void _internal_set_controlno(::int32_t value); + + public: + // int32 serialNo = 13; + void clear_serialno() ; + ::int32_t serialno() const; + void set_serialno(::int32_t value); + + private: + ::int32_t _internal_serialno() const; + void _internal_set_serialno(::int32_t value); + + public: + // int32 controlType = 14; + void clear_controltype() ; + ::int32_t controltype() const; + void set_controltype(::int32_t value); + + private: + ::int32_t _internal_controltype() const; + void _internal_set_controltype(::int32_t value); + + public: + // bool hadMatch = 18; + void clear_hadmatch() ; + bool hadmatch() const; + void set_hadmatch(bool value); + + private: + bool _internal_hadmatch() const; + void _internal_set_hadmatch(bool value); + public: // @@protoc_insertion_point(class_scope:stream.ParamInfo) private: class _Internal; friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<4, 10, 0, 0, 2> _table_; + static const ::google::protobuf::internal::TcParseTable<5, 18, 0, 0, 2> _table_; template friend class ::google::protobuf::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; @@ -450,13 +577,21 @@ class ParamInfo final : ::google::protobuf::internal::ArenaStringPtr namekey_; ::google::protobuf::internal::ArenaStringPtr strvalue_; ::google::protobuf::internal::ArenaStringPtr context_; + ::google::protobuf::internal::ArenaStringPtr cardname_; + ::google::protobuf::internal::ArenaStringPtr cardip_; int valuetype_; + ::int32_t startlayer_; bool isenable_; bool isalarm_; bool isshow_; - ::int32_t startlayer_; + bool hadassign_; ::int32_t endlayer_; float powder_; + ::int32_t seqno_; + ::int32_t controlno_; + ::int32_t serialno_; + ::int32_t controltype_; + bool hadmatch_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; @@ -2548,6 +2683,2960 @@ class ComResponce final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ScannerCrtlCfgResp final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScannerCrtlCfgResp) */ { + public: + inline ScannerCrtlCfgResp() : ScannerCrtlCfgResp(nullptr) {} + ~ScannerCrtlCfgResp() override; + template + explicit PROTOBUF_CONSTEXPR ScannerCrtlCfgResp(::google::protobuf::internal::ConstantInitialized); + + ScannerCrtlCfgResp(const ScannerCrtlCfgResp& from); + ScannerCrtlCfgResp(ScannerCrtlCfgResp&& from) noexcept + : ScannerCrtlCfgResp() { + *this = ::std::move(from); + } + + inline ScannerCrtlCfgResp& operator=(const ScannerCrtlCfgResp& from) { + CopyFrom(from); + return *this; + } + inline ScannerCrtlCfgResp& operator=(ScannerCrtlCfgResp&& 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 ScannerCrtlCfgResp& default_instance() { + return *internal_default_instance(); + } + static inline const ScannerCrtlCfgResp* internal_default_instance() { + return reinterpret_cast( + &_ScannerCrtlCfgResp_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(ScannerCrtlCfgResp& a, ScannerCrtlCfgResp& b) { + a.Swap(&b); + } + inline void Swap(ScannerCrtlCfgResp* 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(ScannerCrtlCfgResp* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScannerCrtlCfgResp* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ScannerCrtlCfgResp& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ScannerCrtlCfgResp& from) { + ScannerCrtlCfgResp::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(ScannerCrtlCfgResp* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ScannerCrtlCfgResp"; + } + protected: + explicit ScannerCrtlCfgResp(::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 { + kScannerCfgFieldNumber = 1, + }; + // repeated .stream.ScannerCrtlCfgData scannerCfg = 1; + int scannercfg_size() const; + private: + int _internal_scannercfg_size() const; + + public: + void clear_scannercfg() ; + ::stream::ScannerCrtlCfgData* mutable_scannercfg(int index); + ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >* + mutable_scannercfg(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>& _internal_scannercfg() const; + ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>* _internal_mutable_scannercfg(); + public: + const ::stream::ScannerCrtlCfgData& scannercfg(int index) const; + ::stream::ScannerCrtlCfgData* add_scannercfg(); + const ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >& + scannercfg() const; + // @@protoc_insertion_point(class_scope:stream.ScannerCrtlCfgResp) + 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::RepeatedPtrField< ::stream::ScannerCrtlCfgData > scannercfg_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ScannerCrtlCfgData final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScannerCrtlCfgData) */ { + public: + inline ScannerCrtlCfgData() : ScannerCrtlCfgData(nullptr) {} + ~ScannerCrtlCfgData() override; + template + explicit PROTOBUF_CONSTEXPR ScannerCrtlCfgData(::google::protobuf::internal::ConstantInitialized); + + ScannerCrtlCfgData(const ScannerCrtlCfgData& from); + ScannerCrtlCfgData(ScannerCrtlCfgData&& from) noexcept + : ScannerCrtlCfgData() { + *this = ::std::move(from); + } + + inline ScannerCrtlCfgData& operator=(const ScannerCrtlCfgData& from) { + CopyFrom(from); + return *this; + } + inline ScannerCrtlCfgData& operator=(ScannerCrtlCfgData&& 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 ScannerCrtlCfgData& default_instance() { + return *internal_default_instance(); + } + static inline const ScannerCrtlCfgData* internal_default_instance() { + return reinterpret_cast( + &_ScannerCrtlCfgData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(ScannerCrtlCfgData& a, ScannerCrtlCfgData& b) { + a.Swap(&b); + } + inline void Swap(ScannerCrtlCfgData* 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(ScannerCrtlCfgData* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScannerCrtlCfgData* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ScannerCrtlCfgData& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ScannerCrtlCfgData& from) { + ScannerCrtlCfgData::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(ScannerCrtlCfgData* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ScannerCrtlCfgData"; + } + protected: + explicit ScannerCrtlCfgData(::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 { + kFixPointDataFieldNumber = 2, + kPowerCompensateFieldNumber = 10, + kTPowerCompensateFieldNumber = 11, + kCardNameFieldNumber = 15, + kCardIPFieldNumber = 16, + kScanParamCfgFieldNumber = 3, + kHatchingParamsFieldNumber = 4, + kBorderParamsFieldNumber = 5, + kSupportParamsFieldNumber = 6, + kCorrectParamCfgFieldNumber = 7, + kScanTestCfgFieldNumber = 8, + kSkyWritingCfgFieldNumber = 9, + kSeqNoFieldNumber = 1, + kControlNoFieldNumber = 12, + kSerialNoFieldNumber = 13, + kControlTypeFieldNumber = 14, + kIsEnableFieldNumber = 17, + kHadAssignFieldNumber = 18, + kHadMatchFieldNumber = 19, + }; + // repeated .stream.FixPointData fixPointData = 2; + int fixpointdata_size() const; + private: + int _internal_fixpointdata_size() const; + + public: + void clear_fixpointdata() ; + ::stream::FixPointData* mutable_fixpointdata(int index); + ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >* + mutable_fixpointdata(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::FixPointData>& _internal_fixpointdata() const; + ::google::protobuf::RepeatedPtrField<::stream::FixPointData>* _internal_mutable_fixpointdata(); + public: + const ::stream::FixPointData& fixpointdata(int index) const; + ::stream::FixPointData* add_fixpointdata(); + const ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >& + fixpointdata() const; + // repeated .stream.PowerCompensate powerCompensate = 10; + int powercompensate_size() const; + private: + int _internal_powercompensate_size() const; + + public: + void clear_powercompensate() ; + ::stream::PowerCompensate* mutable_powercompensate(int index); + ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >* + mutable_powercompensate(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>& _internal_powercompensate() const; + ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>* _internal_mutable_powercompensate(); + public: + const ::stream::PowerCompensate& powercompensate(int index) const; + ::stream::PowerCompensate* add_powercompensate(); + const ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >& + powercompensate() const; + // repeated .stream.TimePowerCompensate tPowerCompensate = 11; + int tpowercompensate_size() const; + private: + int _internal_tpowercompensate_size() const; + + public: + void clear_tpowercompensate() ; + ::stream::TimePowerCompensate* mutable_tpowercompensate(int index); + ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >* + mutable_tpowercompensate(); + private: + const ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>& _internal_tpowercompensate() const; + ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>* _internal_mutable_tpowercompensate(); + public: + const ::stream::TimePowerCompensate& tpowercompensate(int index) const; + ::stream::TimePowerCompensate* add_tpowercompensate(); + const ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >& + tpowercompensate() const; + // bytes cardName = 15; + void clear_cardname() ; + const std::string& cardname() const; + template + void set_cardname(Arg_&& arg, Args_... args); + std::string* mutable_cardname(); + PROTOBUF_NODISCARD std::string* release_cardname(); + void set_allocated_cardname(std::string* ptr); + + private: + const std::string& _internal_cardname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardname( + const std::string& value); + std::string* _internal_mutable_cardname(); + + public: + // bytes cardIP = 16; + void clear_cardip() ; + const std::string& cardip() const; + template + void set_cardip(Arg_&& arg, Args_... args); + std::string* mutable_cardip(); + PROTOBUF_NODISCARD std::string* release_cardip(); + void set_allocated_cardip(std::string* ptr); + + private: + const std::string& _internal_cardip() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardip( + const std::string& value); + std::string* _internal_mutable_cardip(); + + public: + // .stream.ScanParamCfg scanParamCfg = 3; + bool has_scanparamcfg() const; + void clear_scanparamcfg() ; + const ::stream::ScanParamCfg& scanparamcfg() const; + PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_scanparamcfg(); + ::stream::ScanParamCfg* mutable_scanparamcfg(); + void set_allocated_scanparamcfg(::stream::ScanParamCfg* value); + void unsafe_arena_set_allocated_scanparamcfg(::stream::ScanParamCfg* value); + ::stream::ScanParamCfg* unsafe_arena_release_scanparamcfg(); + + private: + const ::stream::ScanParamCfg& _internal_scanparamcfg() const; + ::stream::ScanParamCfg* _internal_mutable_scanparamcfg(); + + public: + // .stream.ScanParamCfg hatchingParams = 4; + bool has_hatchingparams() const; + void clear_hatchingparams() ; + const ::stream::ScanParamCfg& hatchingparams() const; + PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_hatchingparams(); + ::stream::ScanParamCfg* mutable_hatchingparams(); + void set_allocated_hatchingparams(::stream::ScanParamCfg* value); + void unsafe_arena_set_allocated_hatchingparams(::stream::ScanParamCfg* value); + ::stream::ScanParamCfg* unsafe_arena_release_hatchingparams(); + + private: + const ::stream::ScanParamCfg& _internal_hatchingparams() const; + ::stream::ScanParamCfg* _internal_mutable_hatchingparams(); + + public: + // .stream.ScanParamCfg borderParams = 5; + bool has_borderparams() const; + void clear_borderparams() ; + const ::stream::ScanParamCfg& borderparams() const; + PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_borderparams(); + ::stream::ScanParamCfg* mutable_borderparams(); + void set_allocated_borderparams(::stream::ScanParamCfg* value); + void unsafe_arena_set_allocated_borderparams(::stream::ScanParamCfg* value); + ::stream::ScanParamCfg* unsafe_arena_release_borderparams(); + + private: + const ::stream::ScanParamCfg& _internal_borderparams() const; + ::stream::ScanParamCfg* _internal_mutable_borderparams(); + + public: + // .stream.ScanParamCfg supportParams = 6; + bool has_supportparams() const; + void clear_supportparams() ; + const ::stream::ScanParamCfg& supportparams() const; + PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_supportparams(); + ::stream::ScanParamCfg* mutable_supportparams(); + void set_allocated_supportparams(::stream::ScanParamCfg* value); + void unsafe_arena_set_allocated_supportparams(::stream::ScanParamCfg* value); + ::stream::ScanParamCfg* unsafe_arena_release_supportparams(); + + private: + const ::stream::ScanParamCfg& _internal_supportparams() const; + ::stream::ScanParamCfg* _internal_mutable_supportparams(); + + public: + // .stream.CorrectParamCfg correctParamCfg = 7; + bool has_correctparamcfg() const; + void clear_correctparamcfg() ; + const ::stream::CorrectParamCfg& correctparamcfg() const; + PROTOBUF_NODISCARD ::stream::CorrectParamCfg* release_correctparamcfg(); + ::stream::CorrectParamCfg* mutable_correctparamcfg(); + void set_allocated_correctparamcfg(::stream::CorrectParamCfg* value); + void unsafe_arena_set_allocated_correctparamcfg(::stream::CorrectParamCfg* value); + ::stream::CorrectParamCfg* unsafe_arena_release_correctparamcfg(); + + private: + const ::stream::CorrectParamCfg& _internal_correctparamcfg() const; + ::stream::CorrectParamCfg* _internal_mutable_correctparamcfg(); + + public: + // .stream.ScanTestCfg scanTestCfg = 8; + bool has_scantestcfg() const; + void clear_scantestcfg() ; + const ::stream::ScanTestCfg& scantestcfg() const; + PROTOBUF_NODISCARD ::stream::ScanTestCfg* release_scantestcfg(); + ::stream::ScanTestCfg* mutable_scantestcfg(); + void set_allocated_scantestcfg(::stream::ScanTestCfg* value); + void unsafe_arena_set_allocated_scantestcfg(::stream::ScanTestCfg* value); + ::stream::ScanTestCfg* unsafe_arena_release_scantestcfg(); + + private: + const ::stream::ScanTestCfg& _internal_scantestcfg() const; + ::stream::ScanTestCfg* _internal_mutable_scantestcfg(); + + public: + // .stream.SkyWritingCfg skyWritingCfg = 9; + bool has_skywritingcfg() const; + void clear_skywritingcfg() ; + const ::stream::SkyWritingCfg& skywritingcfg() const; + PROTOBUF_NODISCARD ::stream::SkyWritingCfg* release_skywritingcfg(); + ::stream::SkyWritingCfg* mutable_skywritingcfg(); + void set_allocated_skywritingcfg(::stream::SkyWritingCfg* value); + void unsafe_arena_set_allocated_skywritingcfg(::stream::SkyWritingCfg* value); + ::stream::SkyWritingCfg* unsafe_arena_release_skywritingcfg(); + + private: + const ::stream::SkyWritingCfg& _internal_skywritingcfg() const; + ::stream::SkyWritingCfg* _internal_mutable_skywritingcfg(); + + public: + // int32 seqNo = 1; + void clear_seqno() ; + ::int32_t seqno() const; + void set_seqno(::int32_t value); + + private: + ::int32_t _internal_seqno() const; + void _internal_set_seqno(::int32_t value); + + public: + // int32 controlNo = 12; + void clear_controlno() ; + ::int32_t controlno() const; + void set_controlno(::int32_t value); + + private: + ::int32_t _internal_controlno() const; + void _internal_set_controlno(::int32_t value); + + public: + // int32 serialNo = 13; + void clear_serialno() ; + ::int32_t serialno() const; + void set_serialno(::int32_t value); + + private: + ::int32_t _internal_serialno() const; + void _internal_set_serialno(::int32_t value); + + public: + // int32 controlType = 14; + void clear_controltype() ; + ::int32_t controltype() const; + void set_controltype(::int32_t value); + + private: + ::int32_t _internal_controltype() const; + void _internal_set_controltype(::int32_t value); + + public: + // bool isEnable = 17; + void clear_isenable() ; + bool isenable() const; + void set_isenable(bool value); + + private: + bool _internal_isenable() const; + void _internal_set_isenable(bool value); + + public: + // bool hadAssign = 18; + void clear_hadassign() ; + bool hadassign() const; + void set_hadassign(bool value); + + private: + bool _internal_hadassign() const; + void _internal_set_hadassign(bool value); + + public: + // bool hadMatch = 19; + void clear_hadmatch() ; + bool hadmatch() const; + void set_hadmatch(bool value); + + private: + bool _internal_hadmatch() const; + void _internal_set_hadmatch(bool value); + + public: + // @@protoc_insertion_point(class_scope:stream.ScannerCrtlCfgData) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 19, 10, 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::RepeatedPtrField< ::stream::FixPointData > fixpointdata_; + ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate > powercompensate_; + ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate > tpowercompensate_; + ::google::protobuf::internal::ArenaStringPtr cardname_; + ::google::protobuf::internal::ArenaStringPtr cardip_; + ::stream::ScanParamCfg* scanparamcfg_; + ::stream::ScanParamCfg* hatchingparams_; + ::stream::ScanParamCfg* borderparams_; + ::stream::ScanParamCfg* supportparams_; + ::stream::CorrectParamCfg* correctparamcfg_; + ::stream::ScanTestCfg* scantestcfg_; + ::stream::SkyWritingCfg* skywritingcfg_; + ::int32_t seqno_; + ::int32_t controlno_; + ::int32_t serialno_; + ::int32_t controltype_; + bool isenable_; + bool hadassign_; + bool hadmatch_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class FixPointData final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.FixPointData) */ { + public: + inline FixPointData() : FixPointData(nullptr) {} + ~FixPointData() override; + template + explicit PROTOBUF_CONSTEXPR FixPointData(::google::protobuf::internal::ConstantInitialized); + + FixPointData(const FixPointData& from); + FixPointData(FixPointData&& from) noexcept + : FixPointData() { + *this = ::std::move(from); + } + + inline FixPointData& operator=(const FixPointData& from) { + CopyFrom(from); + return *this; + } + inline FixPointData& operator=(FixPointData&& 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 FixPointData& default_instance() { + return *internal_default_instance(); + } + static inline const FixPointData* internal_default_instance() { + return reinterpret_cast( + &_FixPointData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(FixPointData& a, FixPointData& b) { + a.Swap(&b); + } + inline void Swap(FixPointData* 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(FixPointData* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FixPointData* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const FixPointData& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const FixPointData& from) { + FixPointData::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(FixPointData* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.FixPointData"; + } + protected: + explicit FixPointData(::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 { + kIdFieldNumber = 1, + kCnoFieldNumber = 2, + kPointXFieldNumber = 3, + kPointYFieldNumber = 4, + kDurationFieldNumber = 5, + }; + // int32 id = 1; + void clear_id() ; + ::int32_t id() const; + void set_id(::int32_t value); + + private: + ::int32_t _internal_id() const; + void _internal_set_id(::int32_t value); + + public: + // int32 cno = 2; + void clear_cno() ; + ::int32_t cno() const; + void set_cno(::int32_t value); + + private: + ::int32_t _internal_cno() const; + void _internal_set_cno(::int32_t value); + + public: + // float pointX = 3; + void clear_pointx() ; + float pointx() const; + void set_pointx(float value); + + private: + float _internal_pointx() const; + void _internal_set_pointx(float value); + + public: + // float pointY = 4; + void clear_pointy() ; + float pointy() const; + void set_pointy(float value); + + private: + float _internal_pointy() const; + void _internal_set_pointy(float value); + + public: + // uint32 duration = 5; + void clear_duration() ; + ::uint32_t duration() const; + void set_duration(::uint32_t value); + + private: + ::uint32_t _internal_duration() const; + void _internal_set_duration(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:stream.FixPointData) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t id_; + ::int32_t cno_; + float pointx_; + float pointy_; + ::uint32_t duration_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ScanParamCfg final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScanParamCfg) */ { + public: + inline ScanParamCfg() : ScanParamCfg(nullptr) {} + ~ScanParamCfg() override; + template + explicit PROTOBUF_CONSTEXPR ScanParamCfg(::google::protobuf::internal::ConstantInitialized); + + ScanParamCfg(const ScanParamCfg& from); + ScanParamCfg(ScanParamCfg&& from) noexcept + : ScanParamCfg() { + *this = ::std::move(from); + } + + inline ScanParamCfg& operator=(const ScanParamCfg& from) { + CopyFrom(from); + return *this; + } + inline ScanParamCfg& operator=(ScanParamCfg&& 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 ScanParamCfg& default_instance() { + return *internal_default_instance(); + } + static inline const ScanParamCfg* internal_default_instance() { + return reinterpret_cast( + &_ScanParamCfg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(ScanParamCfg& a, ScanParamCfg& b) { + a.Swap(&b); + } + inline void Swap(ScanParamCfg* 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(ScanParamCfg* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScanParamCfg* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ScanParamCfg& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ScanParamCfg& from) { + ScanParamCfg::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(ScanParamCfg* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ScanParamCfg"; + } + protected: + explicit ScanParamCfg(::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 { + kEdgeLevelFieldNumber = 1, + kEdgeLevelMinFieldNumber = 2, + kEdgeLevelMaxFieldNumber = 3, + kJumpDelayFieldNumber = 4, + kJumpDelayMinFieldNumber = 5, + kJumpDelayMaxFieldNumber = 6, + kScanDelayFieldNumber = 7, + kScanDelayMinFieldNumber = 8, + kScanDelayMaxFieldNumber = 9, + kPolygonDelayFieldNumber = 10, + kPolygonDelayMinFieldNumber = 11, + kPolygonDelayMaxFieldNumber = 12, + kLaseroffDelayFieldNumber = 13, + kLaseroffDelayMinFieldNumber = 14, + kLaseroffDelayMaxFieldNumber = 15, + kLaseronDelayFieldNumber = 16, + kLaseronDelayMinFieldNumber = 17, + kLaseronDelayMaxFieldNumber = 18, + kMinJumpDelayFieldNumber = 19, + kMinJumpDelayMinFieldNumber = 20, + kMinJumpDelayMaxFieldNumber = 21, + kJumpLengthLimitFieldNumber = 22, + kJumpLengthLimitMinFieldNumber = 23, + kJumpLengthLimitMaxFieldNumber = 24, + kJumpSpeedFieldNumber = 25, + kJumpSpeedMinFieldNumber = 26, + kJumpSpeedMaxFieldNumber = 27, + kMarkSpeedFieldNumber = 28, + kMarkSpeedMinFieldNumber = 29, + kMarkSpeedMaxFieldNumber = 30, + }; + // int32 edgeLevel = 1; + void clear_edgelevel() ; + ::int32_t edgelevel() const; + void set_edgelevel(::int32_t value); + + private: + ::int32_t _internal_edgelevel() const; + void _internal_set_edgelevel(::int32_t value); + + public: + // int32 edgeLevelMin = 2; + void clear_edgelevelmin() ; + ::int32_t edgelevelmin() const; + void set_edgelevelmin(::int32_t value); + + private: + ::int32_t _internal_edgelevelmin() const; + void _internal_set_edgelevelmin(::int32_t value); + + public: + // int32 edgeLevelMax = 3; + void clear_edgelevelmax() ; + ::int32_t edgelevelmax() const; + void set_edgelevelmax(::int32_t value); + + private: + ::int32_t _internal_edgelevelmax() const; + void _internal_set_edgelevelmax(::int32_t value); + + public: + // uint32 jumpDelay = 4; + void clear_jumpdelay() ; + ::uint32_t jumpdelay() const; + void set_jumpdelay(::uint32_t value); + + private: + ::uint32_t _internal_jumpdelay() const; + void _internal_set_jumpdelay(::uint32_t value); + + public: + // uint32 jumpDelayMin = 5; + void clear_jumpdelaymin() ; + ::uint32_t jumpdelaymin() const; + void set_jumpdelaymin(::uint32_t value); + + private: + ::uint32_t _internal_jumpdelaymin() const; + void _internal_set_jumpdelaymin(::uint32_t value); + + public: + // uint32 jumpDelayMax = 6; + void clear_jumpdelaymax() ; + ::uint32_t jumpdelaymax() const; + void set_jumpdelaymax(::uint32_t value); + + private: + ::uint32_t _internal_jumpdelaymax() const; + void _internal_set_jumpdelaymax(::uint32_t value); + + public: + // uint32 scanDelay = 7; + void clear_scandelay() ; + ::uint32_t scandelay() const; + void set_scandelay(::uint32_t value); + + private: + ::uint32_t _internal_scandelay() const; + void _internal_set_scandelay(::uint32_t value); + + public: + // uint32 scanDelayMin = 8; + void clear_scandelaymin() ; + ::uint32_t scandelaymin() const; + void set_scandelaymin(::uint32_t value); + + private: + ::uint32_t _internal_scandelaymin() const; + void _internal_set_scandelaymin(::uint32_t value); + + public: + // uint32 scanDelayMax = 9; + void clear_scandelaymax() ; + ::uint32_t scandelaymax() const; + void set_scandelaymax(::uint32_t value); + + private: + ::uint32_t _internal_scandelaymax() const; + void _internal_set_scandelaymax(::uint32_t value); + + public: + // uint32 polygonDelay = 10; + void clear_polygondelay() ; + ::uint32_t polygondelay() const; + void set_polygondelay(::uint32_t value); + + private: + ::uint32_t _internal_polygondelay() const; + void _internal_set_polygondelay(::uint32_t value); + + public: + // uint32 polygonDelayMin = 11; + void clear_polygondelaymin() ; + ::uint32_t polygondelaymin() const; + void set_polygondelaymin(::uint32_t value); + + private: + ::uint32_t _internal_polygondelaymin() const; + void _internal_set_polygondelaymin(::uint32_t value); + + public: + // uint32 polygonDelayMax = 12; + void clear_polygondelaymax() ; + ::uint32_t polygondelaymax() const; + void set_polygondelaymax(::uint32_t value); + + private: + ::uint32_t _internal_polygondelaymax() const; + void _internal_set_polygondelaymax(::uint32_t value); + + public: + // int64 laseroffDelay = 13; + void clear_laseroffdelay() ; + ::int64_t laseroffdelay() const; + void set_laseroffdelay(::int64_t value); + + private: + ::int64_t _internal_laseroffdelay() const; + void _internal_set_laseroffdelay(::int64_t value); + + public: + // int64 laseroffDelayMin = 14; + void clear_laseroffdelaymin() ; + ::int64_t laseroffdelaymin() const; + void set_laseroffdelaymin(::int64_t value); + + private: + ::int64_t _internal_laseroffdelaymin() const; + void _internal_set_laseroffdelaymin(::int64_t value); + + public: + // int64 laseroffDelayMax = 15; + void clear_laseroffdelaymax() ; + ::int64_t laseroffdelaymax() const; + void set_laseroffdelaymax(::int64_t value); + + private: + ::int64_t _internal_laseroffdelaymax() const; + void _internal_set_laseroffdelaymax(::int64_t value); + + public: + // int64 laseronDelay = 16; + void clear_laserondelay() ; + ::int64_t laserondelay() const; + void set_laserondelay(::int64_t value); + + private: + ::int64_t _internal_laserondelay() const; + void _internal_set_laserondelay(::int64_t value); + + public: + // int64 laseronDelayMin = 17; + void clear_laserondelaymin() ; + ::int64_t laserondelaymin() const; + void set_laserondelaymin(::int64_t value); + + private: + ::int64_t _internal_laserondelaymin() const; + void _internal_set_laserondelaymin(::int64_t value); + + public: + // int64 laseronDelayMax = 18; + void clear_laserondelaymax() ; + ::int64_t laserondelaymax() const; + void set_laserondelaymax(::int64_t value); + + private: + ::int64_t _internal_laserondelaymax() const; + void _internal_set_laserondelaymax(::int64_t value); + + public: + // uint32 minJumpDelay = 19; + void clear_minjumpdelay() ; + ::uint32_t minjumpdelay() const; + void set_minjumpdelay(::uint32_t value); + + private: + ::uint32_t _internal_minjumpdelay() const; + void _internal_set_minjumpdelay(::uint32_t value); + + public: + // uint32 minJumpDelayMin = 20; + void clear_minjumpdelaymin() ; + ::uint32_t minjumpdelaymin() const; + void set_minjumpdelaymin(::uint32_t value); + + private: + ::uint32_t _internal_minjumpdelaymin() const; + void _internal_set_minjumpdelaymin(::uint32_t value); + + public: + // uint32 minJumpDelayMax = 21; + void clear_minjumpdelaymax() ; + ::uint32_t minjumpdelaymax() const; + void set_minjumpdelaymax(::uint32_t value); + + private: + ::uint32_t _internal_minjumpdelaymax() const; + void _internal_set_minjumpdelaymax(::uint32_t value); + + public: + // uint32 jumpLengthLimit = 22; + void clear_jumplengthlimit() ; + ::uint32_t jumplengthlimit() const; + void set_jumplengthlimit(::uint32_t value); + + private: + ::uint32_t _internal_jumplengthlimit() const; + void _internal_set_jumplengthlimit(::uint32_t value); + + public: + // uint32 jumpLengthLimitMin = 23; + void clear_jumplengthlimitmin() ; + ::uint32_t jumplengthlimitmin() const; + void set_jumplengthlimitmin(::uint32_t value); + + private: + ::uint32_t _internal_jumplengthlimitmin() const; + void _internal_set_jumplengthlimitmin(::uint32_t value); + + public: + // uint32 jumpLengthLimitMax = 24; + void clear_jumplengthlimitmax() ; + ::uint32_t jumplengthlimitmax() const; + void set_jumplengthlimitmax(::uint32_t value); + + private: + ::uint32_t _internal_jumplengthlimitmax() const; + void _internal_set_jumplengthlimitmax(::uint32_t value); + + public: + // double jumpSpeed = 25; + void clear_jumpspeed() ; + double jumpspeed() const; + void set_jumpspeed(double value); + + private: + double _internal_jumpspeed() const; + void _internal_set_jumpspeed(double value); + + public: + // double jumpSpeedMin = 26; + void clear_jumpspeedmin() ; + double jumpspeedmin() const; + void set_jumpspeedmin(double value); + + private: + double _internal_jumpspeedmin() const; + void _internal_set_jumpspeedmin(double value); + + public: + // double jumpSpeedMax = 27; + void clear_jumpspeedmax() ; + double jumpspeedmax() const; + void set_jumpspeedmax(double value); + + private: + double _internal_jumpspeedmax() const; + void _internal_set_jumpspeedmax(double value); + + public: + // double markSpeed = 28; + void clear_markspeed() ; + double markspeed() const; + void set_markspeed(double value); + + private: + double _internal_markspeed() const; + void _internal_set_markspeed(double value); + + public: + // double markSpeedMin = 29; + void clear_markspeedmin() ; + double markspeedmin() const; + void set_markspeedmin(double value); + + private: + double _internal_markspeedmin() const; + void _internal_set_markspeedmin(double value); + + public: + // double markSpeedMax = 30; + void clear_markspeedmax() ; + double markspeedmax() const; + void set_markspeedmax(double value); + + private: + double _internal_markspeedmax() const; + void _internal_set_markspeedmax(double value); + + public: + // @@protoc_insertion_point(class_scope:stream.ScanParamCfg) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 30, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t edgelevel_; + ::int32_t edgelevelmin_; + ::int32_t edgelevelmax_; + ::uint32_t jumpdelay_; + ::uint32_t jumpdelaymin_; + ::uint32_t jumpdelaymax_; + ::uint32_t scandelay_; + ::uint32_t scandelaymin_; + ::uint32_t scandelaymax_; + ::uint32_t polygondelay_; + ::uint32_t polygondelaymin_; + ::uint32_t polygondelaymax_; + ::int64_t laseroffdelay_; + ::int64_t laseroffdelaymin_; + ::int64_t laseroffdelaymax_; + ::int64_t laserondelay_; + ::int64_t laserondelaymin_; + ::int64_t laserondelaymax_; + ::uint32_t minjumpdelay_; + ::uint32_t minjumpdelaymin_; + ::uint32_t minjumpdelaymax_; + ::uint32_t jumplengthlimit_; + ::uint32_t jumplengthlimitmin_; + ::uint32_t jumplengthlimitmax_; + double jumpspeed_; + double jumpspeedmin_; + double jumpspeedmax_; + double markspeed_; + double markspeedmin_; + double markspeedmax_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class CorrectParamCfg final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.CorrectParamCfg) */ { + public: + inline CorrectParamCfg() : CorrectParamCfg(nullptr) {} + ~CorrectParamCfg() override; + template + explicit PROTOBUF_CONSTEXPR CorrectParamCfg(::google::protobuf::internal::ConstantInitialized); + + CorrectParamCfg(const CorrectParamCfg& from); + CorrectParamCfg(CorrectParamCfg&& from) noexcept + : CorrectParamCfg() { + *this = ::std::move(from); + } + + inline CorrectParamCfg& operator=(const CorrectParamCfg& from) { + CopyFrom(from); + return *this; + } + inline CorrectParamCfg& operator=(CorrectParamCfg&& 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 CorrectParamCfg& default_instance() { + return *internal_default_instance(); + } + static inline const CorrectParamCfg* internal_default_instance() { + return reinterpret_cast( + &_CorrectParamCfg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(CorrectParamCfg& a, CorrectParamCfg& b) { + a.Swap(&b); + } + inline void Swap(CorrectParamCfg* 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(CorrectParamCfg* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CorrectParamCfg* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const CorrectParamCfg& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const CorrectParamCfg& from) { + CorrectParamCfg::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(CorrectParamCfg* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.CorrectParamCfg"; + } + protected: + explicit CorrectParamCfg(::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 { + kXmeasureMinFieldNumber = 1, + kXmeasureMaxFieldNumber = 2, + kYmeasureMinFieldNumber = 3, + kYmeasureMaxFieldNumber = 4, + kXposfixFieldNumber = 5, + kYposfixFieldNumber = 6, + kScanAngleFieldNumber = 7, + kScanAngleMinFieldNumber = 8, + kScanAngleMaxFieldNumber = 9, + kFixAngleFieldNumber = 10, + kFixAngleMinFieldNumber = 11, + kFixAngleMaxFieldNumber = 12, + kXcorrectFieldNumber = 13, + kYcorrectFieldNumber = 14, + kXcorrectMinFieldNumber = 15, + kXcorrectMaxFieldNumber = 16, + kYcorrectMinFieldNumber = 17, + kYcorrectMaxFieldNumber = 18, + kRealXOffsetFieldNumber = 19, + kRealYOffsetFieldNumber = 20, + kFactorKFieldNumber = 21, + kDefocusRatioFieldNumber = 24, + kDefocusRatioMinFieldNumber = 25, + kDefocusRatioMaxFieldNumber = 26, + kIsCorrectFile3DFieldNumber = 22, + kIsDynamicFocusFieldNumber = 23, + }; + // double xmeasureMin = 1; + void clear_xmeasuremin() ; + double xmeasuremin() const; + void set_xmeasuremin(double value); + + private: + double _internal_xmeasuremin() const; + void _internal_set_xmeasuremin(double value); + + public: + // double xmeasureMax = 2; + void clear_xmeasuremax() ; + double xmeasuremax() const; + void set_xmeasuremax(double value); + + private: + double _internal_xmeasuremax() const; + void _internal_set_xmeasuremax(double value); + + public: + // double ymeasureMin = 3; + void clear_ymeasuremin() ; + double ymeasuremin() const; + void set_ymeasuremin(double value); + + private: + double _internal_ymeasuremin() const; + void _internal_set_ymeasuremin(double value); + + public: + // double ymeasureMax = 4; + void clear_ymeasuremax() ; + double ymeasuremax() const; + void set_ymeasuremax(double value); + + private: + double _internal_ymeasuremax() const; + void _internal_set_ymeasuremax(double value); + + public: + // double xposfix = 5; + void clear_xposfix() ; + double xposfix() const; + void set_xposfix(double value); + + private: + double _internal_xposfix() const; + void _internal_set_xposfix(double value); + + public: + // double yposfix = 6; + void clear_yposfix() ; + double yposfix() const; + void set_yposfix(double value); + + private: + double _internal_yposfix() const; + void _internal_set_yposfix(double value); + + public: + // double scanAngle = 7; + void clear_scanangle() ; + double scanangle() const; + void set_scanangle(double value); + + private: + double _internal_scanangle() const; + void _internal_set_scanangle(double value); + + public: + // double scanAngleMin = 8; + void clear_scananglemin() ; + double scananglemin() const; + void set_scananglemin(double value); + + private: + double _internal_scananglemin() const; + void _internal_set_scananglemin(double value); + + public: + // double scanAngleMax = 9; + void clear_scananglemax() ; + double scananglemax() const; + void set_scananglemax(double value); + + private: + double _internal_scananglemax() const; + void _internal_set_scananglemax(double value); + + public: + // double fixAngle = 10; + void clear_fixangle() ; + double fixangle() const; + void set_fixangle(double value); + + private: + double _internal_fixangle() const; + void _internal_set_fixangle(double value); + + public: + // double fixAngleMin = 11; + void clear_fixanglemin() ; + double fixanglemin() const; + void set_fixanglemin(double value); + + private: + double _internal_fixanglemin() const; + void _internal_set_fixanglemin(double value); + + public: + // double fixAngleMax = 12; + void clear_fixanglemax() ; + double fixanglemax() const; + void set_fixanglemax(double value); + + private: + double _internal_fixanglemax() const; + void _internal_set_fixanglemax(double value); + + public: + // double xcorrect = 13; + void clear_xcorrect() ; + double xcorrect() const; + void set_xcorrect(double value); + + private: + double _internal_xcorrect() const; + void _internal_set_xcorrect(double value); + + public: + // double ycorrect = 14; + void clear_ycorrect() ; + double ycorrect() const; + void set_ycorrect(double value); + + private: + double _internal_ycorrect() const; + void _internal_set_ycorrect(double value); + + public: + // double xcorrectMin = 15; + void clear_xcorrectmin() ; + double xcorrectmin() const; + void set_xcorrectmin(double value); + + private: + double _internal_xcorrectmin() const; + void _internal_set_xcorrectmin(double value); + + public: + // double xcorrectMax = 16; + void clear_xcorrectmax() ; + double xcorrectmax() const; + void set_xcorrectmax(double value); + + private: + double _internal_xcorrectmax() const; + void _internal_set_xcorrectmax(double value); + + public: + // double ycorrectMin = 17; + void clear_ycorrectmin() ; + double ycorrectmin() const; + void set_ycorrectmin(double value); + + private: + double _internal_ycorrectmin() const; + void _internal_set_ycorrectmin(double value); + + public: + // double ycorrectMax = 18; + void clear_ycorrectmax() ; + double ycorrectmax() const; + void set_ycorrectmax(double value); + + private: + double _internal_ycorrectmax() const; + void _internal_set_ycorrectmax(double value); + + public: + // double realXOffset = 19; + void clear_realxoffset() ; + double realxoffset() const; + void set_realxoffset(double value); + + private: + double _internal_realxoffset() const; + void _internal_set_realxoffset(double value); + + public: + // double realYOffset = 20; + void clear_realyoffset() ; + double realyoffset() const; + void set_realyoffset(double value); + + private: + double _internal_realyoffset() const; + void _internal_set_realyoffset(double value); + + public: + // double factorK = 21; + void clear_factork() ; + double factork() const; + void set_factork(double value); + + private: + double _internal_factork() const; + void _internal_set_factork(double value); + + public: + // double defocusRatio = 24; + void clear_defocusratio() ; + double defocusratio() const; + void set_defocusratio(double value); + + private: + double _internal_defocusratio() const; + void _internal_set_defocusratio(double value); + + public: + // double defocusRatioMin = 25; + void clear_defocusratiomin() ; + double defocusratiomin() const; + void set_defocusratiomin(double value); + + private: + double _internal_defocusratiomin() const; + void _internal_set_defocusratiomin(double value); + + public: + // double defocusRatioMax = 26; + void clear_defocusratiomax() ; + double defocusratiomax() const; + void set_defocusratiomax(double value); + + private: + double _internal_defocusratiomax() const; + void _internal_set_defocusratiomax(double value); + + public: + // bool isCorrectFile3D = 22; + void clear_iscorrectfile3d() ; + bool iscorrectfile3d() const; + void set_iscorrectfile3d(bool value); + + private: + bool _internal_iscorrectfile3d() const; + void _internal_set_iscorrectfile3d(bool value); + + public: + // bool isDynamicFocus = 23; + void clear_isdynamicfocus() ; + bool isdynamicfocus() const; + void set_isdynamicfocus(bool value); + + private: + bool _internal_isdynamicfocus() const; + void _internal_set_isdynamicfocus(bool value); + + public: + // @@protoc_insertion_point(class_scope:stream.CorrectParamCfg) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 26, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + double xmeasuremin_; + double xmeasuremax_; + double ymeasuremin_; + double ymeasuremax_; + double xposfix_; + double yposfix_; + double scanangle_; + double scananglemin_; + double scananglemax_; + double fixangle_; + double fixanglemin_; + double fixanglemax_; + double xcorrect_; + double ycorrect_; + double xcorrectmin_; + double xcorrectmax_; + double ycorrectmin_; + double ycorrectmax_; + double realxoffset_; + double realyoffset_; + double factork_; + double defocusratio_; + double defocusratiomin_; + double defocusratiomax_; + bool iscorrectfile3d_; + bool isdynamicfocus_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class ScanTestCfg final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScanTestCfg) */ { + public: + inline ScanTestCfg() : ScanTestCfg(nullptr) {} + ~ScanTestCfg() override; + template + explicit PROTOBUF_CONSTEXPR ScanTestCfg(::google::protobuf::internal::ConstantInitialized); + + ScanTestCfg(const ScanTestCfg& from); + ScanTestCfg(ScanTestCfg&& from) noexcept + : ScanTestCfg() { + *this = ::std::move(from); + } + + inline ScanTestCfg& operator=(const ScanTestCfg& from) { + CopyFrom(from); + return *this; + } + inline ScanTestCfg& operator=(ScanTestCfg&& 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 ScanTestCfg& default_instance() { + return *internal_default_instance(); + } + static inline const ScanTestCfg* internal_default_instance() { + return reinterpret_cast( + &_ScanTestCfg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(ScanTestCfg& a, ScanTestCfg& b) { + a.Swap(&b); + } + inline void Swap(ScanTestCfg* 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(ScanTestCfg* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ScanTestCfg* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ScanTestCfg& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const ScanTestCfg& from) { + ScanTestCfg::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(ScanTestCfg* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.ScanTestCfg"; + } + protected: + explicit ScanTestCfg(::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 { + kDebugShapeFieldNumber = 1, + kShapeSizeFieldNumber = 2, + kShapeSizeMinFieldNumber = 3, + kShapeSizeMaxFieldNumber = 4, + kLaserPowerFieldNumber = 5, + kLaserPowerMinFieldNumber = 6, + kDefocusFieldNumber = 8, + kDefocusMinFieldNumber = 9, + kDefocusMaxFieldNumber = 10, + kLaserPowerMaxFieldNumber = 7, + kIsCycleFieldNumber = 11, + kIsAutoHeatingScannerFieldNumber = 15, + kCrossXFieldNumber = 12, + kCrossYFieldNumber = 13, + kZDistanceFieldNumber = 14, + kAutoHeatingScannerMinutesFieldNumber = 16, + kAutoHeatingScannerSizeFieldNumber = 17, + kAutoHeatingScannerSpeedFieldNumber = 18, + kMarkTestStartXFieldNumber = 19, + kMarkTestStartYFieldNumber = 20, + kMarkTestEndXFieldNumber = 21, + kMarkTestEndYFieldNumber = 22, + }; + // int32 debugShape = 1; + void clear_debugshape() ; + ::int32_t debugshape() const; + void set_debugshape(::int32_t value); + + private: + ::int32_t _internal_debugshape() const; + void _internal_set_debugshape(::int32_t value); + + public: + // int32 shapeSize = 2; + void clear_shapesize() ; + ::int32_t shapesize() const; + void set_shapesize(::int32_t value); + + private: + ::int32_t _internal_shapesize() const; + void _internal_set_shapesize(::int32_t value); + + public: + // int32 shapeSizeMin = 3; + void clear_shapesizemin() ; + ::int32_t shapesizemin() const; + void set_shapesizemin(::int32_t value); + + private: + ::int32_t _internal_shapesizemin() const; + void _internal_set_shapesizemin(::int32_t value); + + public: + // int32 shape_size_max = 4; + void clear_shape_size_max() ; + ::int32_t shape_size_max() const; + void set_shape_size_max(::int32_t value); + + private: + ::int32_t _internal_shape_size_max() const; + void _internal_set_shape_size_max(::int32_t value); + + public: + // int32 laser_power = 5; + void clear_laser_power() ; + ::int32_t laser_power() const; + void set_laser_power(::int32_t value); + + private: + ::int32_t _internal_laser_power() const; + void _internal_set_laser_power(::int32_t value); + + public: + // int32 laser_power_min = 6; + void clear_laser_power_min() ; + ::int32_t laser_power_min() const; + void set_laser_power_min(::int32_t value); + + private: + ::int32_t _internal_laser_power_min() const; + void _internal_set_laser_power_min(::int32_t value); + + public: + // double defocus = 8; + void clear_defocus() ; + double defocus() const; + void set_defocus(double value); + + private: + double _internal_defocus() const; + void _internal_set_defocus(double value); + + public: + // double defocus_min = 9; + void clear_defocus_min() ; + double defocus_min() const; + void set_defocus_min(double value); + + private: + double _internal_defocus_min() const; + void _internal_set_defocus_min(double value); + + public: + // double defocus_max = 10; + void clear_defocus_max() ; + double defocus_max() const; + void set_defocus_max(double value); + + private: + double _internal_defocus_max() const; + void _internal_set_defocus_max(double value); + + public: + // int32 laser_power_max = 7; + void clear_laser_power_max() ; + ::int32_t laser_power_max() const; + void set_laser_power_max(::int32_t value); + + private: + ::int32_t _internal_laser_power_max() const; + void _internal_set_laser_power_max(::int32_t value); + + public: + // bool is_cycle = 11; + void clear_is_cycle() ; + bool is_cycle() const; + void set_is_cycle(bool value); + + private: + bool _internal_is_cycle() const; + void _internal_set_is_cycle(bool value); + + public: + // bool isAutoHeatingScanner = 15; + void clear_isautoheatingscanner() ; + bool isautoheatingscanner() const; + void set_isautoheatingscanner(bool value); + + private: + bool _internal_isautoheatingscanner() const; + void _internal_set_isautoheatingscanner(bool value); + + public: + // double cross_x = 12; + void clear_cross_x() ; + double cross_x() const; + void set_cross_x(double value); + + private: + double _internal_cross_x() const; + void _internal_set_cross_x(double value); + + public: + // double cross_y = 13; + void clear_cross_y() ; + double cross_y() const; + void set_cross_y(double value); + + private: + double _internal_cross_y() const; + void _internal_set_cross_y(double value); + + public: + // double z_distance = 14; + void clear_z_distance() ; + double z_distance() const; + void set_z_distance(double value); + + private: + double _internal_z_distance() const; + void _internal_set_z_distance(double value); + + public: + // uint32 autoHeatingScannerMinutes = 16; + void clear_autoheatingscannerminutes() ; + ::uint32_t autoheatingscannerminutes() const; + void set_autoheatingscannerminutes(::uint32_t value); + + private: + ::uint32_t _internal_autoheatingscannerminutes() const; + void _internal_set_autoheatingscannerminutes(::uint32_t value); + + public: + // uint32 autoHeatingScannerSize = 17; + void clear_autoheatingscannersize() ; + ::uint32_t autoheatingscannersize() const; + void set_autoheatingscannersize(::uint32_t value); + + private: + ::uint32_t _internal_autoheatingscannersize() const; + void _internal_set_autoheatingscannersize(::uint32_t value); + + public: + // double autoHeatingScannerSpeed = 18; + void clear_autoheatingscannerspeed() ; + double autoheatingscannerspeed() const; + void set_autoheatingscannerspeed(double value); + + private: + double _internal_autoheatingscannerspeed() const; + void _internal_set_autoheatingscannerspeed(double value); + + public: + // double mark_test_start_x = 19; + void clear_mark_test_start_x() ; + double mark_test_start_x() const; + void set_mark_test_start_x(double value); + + private: + double _internal_mark_test_start_x() const; + void _internal_set_mark_test_start_x(double value); + + public: + // double mark_test_start_y = 20; + void clear_mark_test_start_y() ; + double mark_test_start_y() const; + void set_mark_test_start_y(double value); + + private: + double _internal_mark_test_start_y() const; + void _internal_set_mark_test_start_y(double value); + + public: + // double mark_test_end_x = 21; + void clear_mark_test_end_x() ; + double mark_test_end_x() const; + void set_mark_test_end_x(double value); + + private: + double _internal_mark_test_end_x() const; + void _internal_set_mark_test_end_x(double value); + + public: + // double mark_test_end_y = 22; + void clear_mark_test_end_y() ; + double mark_test_end_y() const; + void set_mark_test_end_y(double value); + + private: + double _internal_mark_test_end_y() const; + void _internal_set_mark_test_end_y(double value); + + public: + // @@protoc_insertion_point(class_scope:stream.ScanTestCfg) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 22, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t debugshape_; + ::int32_t shapesize_; + ::int32_t shapesizemin_; + ::int32_t shape_size_max_; + ::int32_t laser_power_; + ::int32_t laser_power_min_; + double defocus_; + double defocus_min_; + double defocus_max_; + ::int32_t laser_power_max_; + bool is_cycle_; + bool isautoheatingscanner_; + double cross_x_; + double cross_y_; + double z_distance_; + ::uint32_t autoheatingscannerminutes_; + ::uint32_t autoheatingscannersize_; + double autoheatingscannerspeed_; + double mark_test_start_x_; + double mark_test_start_y_; + double mark_test_end_x_; + double mark_test_end_y_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class SkyWritingCfg final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.SkyWritingCfg) */ { + public: + inline SkyWritingCfg() : SkyWritingCfg(nullptr) {} + ~SkyWritingCfg() override; + template + explicit PROTOBUF_CONSTEXPR SkyWritingCfg(::google::protobuf::internal::ConstantInitialized); + + SkyWritingCfg(const SkyWritingCfg& from); + SkyWritingCfg(SkyWritingCfg&& from) noexcept + : SkyWritingCfg() { + *this = ::std::move(from); + } + + inline SkyWritingCfg& operator=(const SkyWritingCfg& from) { + CopyFrom(from); + return *this; + } + inline SkyWritingCfg& operator=(SkyWritingCfg&& 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 SkyWritingCfg& default_instance() { + return *internal_default_instance(); + } + static inline const SkyWritingCfg* internal_default_instance() { + return reinterpret_cast( + &_SkyWritingCfg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(SkyWritingCfg& a, SkyWritingCfg& b) { + a.Swap(&b); + } + inline void Swap(SkyWritingCfg* 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(SkyWritingCfg* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SkyWritingCfg* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SkyWritingCfg& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const SkyWritingCfg& from) { + SkyWritingCfg::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(SkyWritingCfg* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.SkyWritingCfg"; + } + protected: + explicit SkyWritingCfg(::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 { + kTimelagFieldNumber = 2, + kTimelagMinFieldNumber = 3, + kTimelagMaxFieldNumber = 4, + kIsEnableFieldNumber = 1, + kNprevFieldNumber = 8, + kLaserOnShiftFieldNumber = 5, + kLaserOnShiftMinFieldNumber = 6, + kLaserOnShiftMaxFieldNumber = 7, + kNprevMinFieldNumber = 9, + kNprevMaxFieldNumber = 10, + kNpostFieldNumber = 11, + kNpostMinFieldNumber = 12, + kNpostMaxFieldNumber = 13, + kModeFieldNumber = 14, + kLimiteFieldNumber = 15, + kLimiteMinFieldNumber = 16, + kLimiteMaxFieldNumber = 17, + }; + // double timelag = 2; + void clear_timelag() ; + double timelag() const; + void set_timelag(double value); + + private: + double _internal_timelag() const; + void _internal_set_timelag(double value); + + public: + // double timelagMin = 3; + void clear_timelagmin() ; + double timelagmin() const; + void set_timelagmin(double value); + + private: + double _internal_timelagmin() const; + void _internal_set_timelagmin(double value); + + public: + // double timelagMax = 4; + void clear_timelagmax() ; + double timelagmax() const; + void set_timelagmax(double value); + + private: + double _internal_timelagmax() const; + void _internal_set_timelagmax(double value); + + public: + // bool isEnable = 1; + void clear_isenable() ; + bool isenable() const; + void set_isenable(bool value); + + private: + bool _internal_isenable() const; + void _internal_set_isenable(bool value); + + public: + // uint32 nprev = 8; + void clear_nprev() ; + ::uint32_t nprev() const; + void set_nprev(::uint32_t value); + + private: + ::uint32_t _internal_nprev() const; + void _internal_set_nprev(::uint32_t value); + + public: + // int64 laserOnShift = 5; + void clear_laseronshift() ; + ::int64_t laseronshift() const; + void set_laseronshift(::int64_t value); + + private: + ::int64_t _internal_laseronshift() const; + void _internal_set_laseronshift(::int64_t value); + + public: + // int64 laserOnShiftMin = 6; + void clear_laseronshiftmin() ; + ::int64_t laseronshiftmin() const; + void set_laseronshiftmin(::int64_t value); + + private: + ::int64_t _internal_laseronshiftmin() const; + void _internal_set_laseronshiftmin(::int64_t value); + + public: + // int64 laserOnShiftMax = 7; + void clear_laseronshiftmax() ; + ::int64_t laseronshiftmax() const; + void set_laseronshiftmax(::int64_t value); + + private: + ::int64_t _internal_laseronshiftmax() const; + void _internal_set_laseronshiftmax(::int64_t value); + + public: + // uint32 nprevMin = 9; + void clear_nprevmin() ; + ::uint32_t nprevmin() const; + void set_nprevmin(::uint32_t value); + + private: + ::uint32_t _internal_nprevmin() const; + void _internal_set_nprevmin(::uint32_t value); + + public: + // uint32 nprevMax = 10; + void clear_nprevmax() ; + ::uint32_t nprevmax() const; + void set_nprevmax(::uint32_t value); + + private: + ::uint32_t _internal_nprevmax() const; + void _internal_set_nprevmax(::uint32_t value); + + public: + // uint32 npost = 11; + void clear_npost() ; + ::uint32_t npost() const; + void set_npost(::uint32_t value); + + private: + ::uint32_t _internal_npost() const; + void _internal_set_npost(::uint32_t value); + + public: + // uint32 npostMin = 12; + void clear_npostmin() ; + ::uint32_t npostmin() const; + void set_npostmin(::uint32_t value); + + private: + ::uint32_t _internal_npostmin() const; + void _internal_set_npostmin(::uint32_t value); + + public: + // uint32 npostMax = 13; + void clear_npostmax() ; + ::uint32_t npostmax() const; + void set_npostmax(::uint32_t value); + + private: + ::uint32_t _internal_npostmax() const; + void _internal_set_npostmax(::uint32_t value); + + public: + // int32 mode = 14; + void clear_mode() ; + ::int32_t mode() const; + void set_mode(::int32_t value); + + private: + ::int32_t _internal_mode() const; + void _internal_set_mode(::int32_t value); + + public: + // double limite = 15; + void clear_limite() ; + double limite() const; + void set_limite(double value); + + private: + double _internal_limite() const; + void _internal_set_limite(double value); + + public: + // double limiteMin = 16; + void clear_limitemin() ; + double limitemin() const; + void set_limitemin(double value); + + private: + double _internal_limitemin() const; + void _internal_set_limitemin(double value); + + public: + // double limiteMax = 17; + void clear_limitemax() ; + double limitemax() const; + void set_limitemax(double value); + + private: + double _internal_limitemax() const; + void _internal_set_limitemax(double value); + + public: + // @@protoc_insertion_point(class_scope:stream.SkyWritingCfg) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<5, 17, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + double timelag_; + double timelagmin_; + double timelagmax_; + bool isenable_; + ::uint32_t nprev_; + ::int64_t laseronshift_; + ::int64_t laseronshiftmin_; + ::int64_t laseronshiftmax_; + ::uint32_t nprevmin_; + ::uint32_t nprevmax_; + ::uint32_t npost_; + ::uint32_t npostmin_; + ::uint32_t npostmax_; + ::int32_t mode_; + double limite_; + double limitemin_; + double limitemax_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class PowerCompensate final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.PowerCompensate) */ { + public: + inline PowerCompensate() : PowerCompensate(nullptr) {} + ~PowerCompensate() override; + template + explicit PROTOBUF_CONSTEXPR PowerCompensate(::google::protobuf::internal::ConstantInitialized); + + PowerCompensate(const PowerCompensate& from); + PowerCompensate(PowerCompensate&& from) noexcept + : PowerCompensate() { + *this = ::std::move(from); + } + + inline PowerCompensate& operator=(const PowerCompensate& from) { + CopyFrom(from); + return *this; + } + inline PowerCompensate& operator=(PowerCompensate&& 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 PowerCompensate& default_instance() { + return *internal_default_instance(); + } + static inline const PowerCompensate* internal_default_instance() { + return reinterpret_cast( + &_PowerCompensate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(PowerCompensate& a, PowerCompensate& b) { + a.Swap(&b); + } + inline void Swap(PowerCompensate* 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(PowerCompensate* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PowerCompensate* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const PowerCompensate& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const PowerCompensate& from) { + PowerCompensate::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(PowerCompensate* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.PowerCompensate"; + } + protected: + explicit PowerCompensate(::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 { + kCnoFieldNumber = 1, + kPercentFieldNumber = 2, + kValueFieldNumber = 3, + kValueMinFieldNumber = 4, + kValueMaxFieldNumber = 5, + }; + // int32 cno = 1; + void clear_cno() ; + ::int32_t cno() const; + void set_cno(::int32_t value); + + private: + ::int32_t _internal_cno() const; + void _internal_set_cno(::int32_t value); + + public: + // int32 percent = 2; + void clear_percent() ; + ::int32_t percent() const; + void set_percent(::int32_t value); + + private: + ::int32_t _internal_percent() const; + void _internal_set_percent(::int32_t value); + + public: + // float value = 3; + void clear_value() ; + float value() const; + void set_value(float value); + + private: + float _internal_value() const; + void _internal_set_value(float value); + + public: + // float value_min = 4; + void clear_value_min() ; + float value_min() const; + void set_value_min(float value); + + private: + float _internal_value_min() const; + void _internal_set_value_min(float value); + + public: + // float value_max = 5; + void clear_value_max() ; + float value_max() const; + void set_value_max(float value); + + private: + float _internal_value_max() const; + void _internal_set_value_max(float value); + + public: + // @@protoc_insertion_point(class_scope:stream.PowerCompensate) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t cno_; + ::int32_t percent_; + float value_; + float value_min_; + float value_max_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; +};// ------------------------------------------------------------------- + +class TimePowerCompensate final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.TimePowerCompensate) */ { + public: + inline TimePowerCompensate() : TimePowerCompensate(nullptr) {} + ~TimePowerCompensate() override; + template + explicit PROTOBUF_CONSTEXPR TimePowerCompensate(::google::protobuf::internal::ConstantInitialized); + + TimePowerCompensate(const TimePowerCompensate& from); + TimePowerCompensate(TimePowerCompensate&& from) noexcept + : TimePowerCompensate() { + *this = ::std::move(from); + } + + inline TimePowerCompensate& operator=(const TimePowerCompensate& from) { + CopyFrom(from); + return *this; + } + inline TimePowerCompensate& operator=(TimePowerCompensate&& 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 TimePowerCompensate& default_instance() { + return *internal_default_instance(); + } + static inline const TimePowerCompensate* internal_default_instance() { + return reinterpret_cast( + &_TimePowerCompensate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(TimePowerCompensate& a, TimePowerCompensate& b) { + a.Swap(&b); + } + inline void Swap(TimePowerCompensate* 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(TimePowerCompensate* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TimePowerCompensate* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const TimePowerCompensate& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const TimePowerCompensate& from) { + TimePowerCompensate::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(TimePowerCompensate* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "stream.TimePowerCompensate"; + } + protected: + explicit TimePowerCompensate(::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 { + kIdFieldNumber = 1, + kCnoFieldNumber = 2, + kStartMinuteFieldNumber = 3, + kEndMinuteFieldNumber = 4, + kCompensateFieldNumber = 5, + }; + // int32 id = 1; + void clear_id() ; + ::int32_t id() const; + void set_id(::int32_t value); + + private: + ::int32_t _internal_id() const; + void _internal_set_id(::int32_t value); + + public: + // int32 cno = 2; + void clear_cno() ; + ::int32_t cno() const; + void set_cno(::int32_t value); + + private: + ::int32_t _internal_cno() const; + void _internal_set_cno(::int32_t value); + + public: + // uint32 startMinute = 3; + void clear_startminute() ; + ::uint32_t startminute() const; + void set_startminute(::uint32_t value); + + private: + ::uint32_t _internal_startminute() const; + void _internal_set_startminute(::uint32_t value); + + public: + // uint32 endMinute = 4; + void clear_endminute() ; + ::uint32_t endminute() const; + void set_endminute(::uint32_t value); + + private: + ::uint32_t _internal_endminute() const; + void _internal_set_endminute(::uint32_t value); + + public: + // float compensate = 5; + void clear_compensate() ; + float compensate() const; + void set_compensate(float value); + + private: + float _internal_compensate() const; + void _internal_set_compensate(float value); + + public: + // @@protoc_insertion_point(class_scope:stream.TimePowerCompensate) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_; + template friend class ::google::protobuf::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t id_; + ::int32_t cno_; + ::uint32_t startminute_; + ::uint32_t endminute_; + float compensate_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_stream_2eproto; }; // =================================================================== @@ -2873,6 +5962,240 @@ inline void ParamInfo::_internal_set_powder(float value) { _impl_.powder_ = value; } +// int32 seqNo = 11; +inline void ParamInfo::clear_seqno() { + _impl_.seqno_ = 0; +} +inline ::int32_t ParamInfo::seqno() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.seqNo) + return _internal_seqno(); +} +inline void ParamInfo::set_seqno(::int32_t value) { + _internal_set_seqno(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.seqNo) +} +inline ::int32_t ParamInfo::_internal_seqno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.seqno_; +} +inline void ParamInfo::_internal_set_seqno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.seqno_ = value; +} + +// int32 controlNo = 12; +inline void ParamInfo::clear_controlno() { + _impl_.controlno_ = 0; +} +inline ::int32_t ParamInfo::controlno() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.controlNo) + return _internal_controlno(); +} +inline void ParamInfo::set_controlno(::int32_t value) { + _internal_set_controlno(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.controlNo) +} +inline ::int32_t ParamInfo::_internal_controlno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.controlno_; +} +inline void ParamInfo::_internal_set_controlno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.controlno_ = value; +} + +// int32 serialNo = 13; +inline void ParamInfo::clear_serialno() { + _impl_.serialno_ = 0; +} +inline ::int32_t ParamInfo::serialno() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.serialNo) + return _internal_serialno(); +} +inline void ParamInfo::set_serialno(::int32_t value) { + _internal_set_serialno(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.serialNo) +} +inline ::int32_t ParamInfo::_internal_serialno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.serialno_; +} +inline void ParamInfo::_internal_set_serialno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.serialno_ = value; +} + +// int32 controlType = 14; +inline void ParamInfo::clear_controltype() { + _impl_.controltype_ = 0; +} +inline ::int32_t ParamInfo::controltype() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.controlType) + return _internal_controltype(); +} +inline void ParamInfo::set_controltype(::int32_t value) { + _internal_set_controltype(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.controlType) +} +inline ::int32_t ParamInfo::_internal_controltype() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.controltype_; +} +inline void ParamInfo::_internal_set_controltype(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.controltype_ = value; +} + +// bytes cardName = 15; +inline void ParamInfo::clear_cardname() { + _impl_.cardname_.ClearToEmpty(); +} +inline const std::string& ParamInfo::cardname() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.cardName) + return _internal_cardname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ParamInfo::set_cardname(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardname_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:stream.ParamInfo.cardName) +} +inline std::string* ParamInfo::mutable_cardname() { + std::string* _s = _internal_mutable_cardname(); + // @@protoc_insertion_point(field_mutable:stream.ParamInfo.cardName) + return _s; +} +inline const std::string& ParamInfo::_internal_cardname() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cardname_.Get(); +} +inline void ParamInfo::_internal_set_cardname(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardname_.Set(value, GetArenaForAllocation()); +} +inline std::string* ParamInfo::_internal_mutable_cardname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.cardname_.Mutable( GetArenaForAllocation()); +} +inline std::string* ParamInfo::release_cardname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ParamInfo.cardName) + return _impl_.cardname_.Release(); +} +inline void ParamInfo::set_allocated_cardname(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.cardname_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.cardname_.IsDefault()) { + _impl_.cardname_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:stream.ParamInfo.cardName) +} + +// bytes cardIP = 16; +inline void ParamInfo::clear_cardip() { + _impl_.cardip_.ClearToEmpty(); +} +inline const std::string& ParamInfo::cardip() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.cardIP) + return _internal_cardip(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ParamInfo::set_cardip(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardip_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:stream.ParamInfo.cardIP) +} +inline std::string* ParamInfo::mutable_cardip() { + std::string* _s = _internal_mutable_cardip(); + // @@protoc_insertion_point(field_mutable:stream.ParamInfo.cardIP) + return _s; +} +inline const std::string& ParamInfo::_internal_cardip() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cardip_.Get(); +} +inline void ParamInfo::_internal_set_cardip(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardip_.Set(value, GetArenaForAllocation()); +} +inline std::string* ParamInfo::_internal_mutable_cardip() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.cardip_.Mutable( GetArenaForAllocation()); +} +inline std::string* ParamInfo::release_cardip() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ParamInfo.cardIP) + return _impl_.cardip_.Release(); +} +inline void ParamInfo::set_allocated_cardip(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.cardip_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.cardip_.IsDefault()) { + _impl_.cardip_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:stream.ParamInfo.cardIP) +} + +// bool hadAssign = 17; +inline void ParamInfo::clear_hadassign() { + _impl_.hadassign_ = false; +} +inline bool ParamInfo::hadassign() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.hadAssign) + return _internal_hadassign(); +} +inline void ParamInfo::set_hadassign(bool value) { + _internal_set_hadassign(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.hadAssign) +} +inline bool ParamInfo::_internal_hadassign() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.hadassign_; +} +inline void ParamInfo::_internal_set_hadassign(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.hadassign_ = value; +} + +// bool hadMatch = 18; +inline void ParamInfo::clear_hadmatch() { + _impl_.hadmatch_ = false; +} +inline bool ParamInfo::hadmatch() const { + // @@protoc_insertion_point(field_get:stream.ParamInfo.hadMatch) + return _internal_hadmatch(); +} +inline void ParamInfo::set_hadmatch(bool value) { + _internal_set_hadmatch(value); + // @@protoc_insertion_point(field_set:stream.ParamInfo.hadMatch) +} +inline bool ParamInfo::_internal_hadmatch() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.hadmatch_; +} +inline void ParamInfo::_internal_set_hadmatch(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.hadmatch_ = value; +} + // ------------------------------------------------------------------- // RequestInfo @@ -3966,6 +7289,3574 @@ inline void ComResponce::set_allocated_data(std::string* value) { // @@protoc_insertion_point(field_set_allocated:stream.ComResponce.data) } +// ------------------------------------------------------------------- + +// ScannerCrtlCfgResp + +// repeated .stream.ScannerCrtlCfgData scannerCfg = 1; +inline int ScannerCrtlCfgResp::_internal_scannercfg_size() const { + return _internal_scannercfg().size(); +} +inline int ScannerCrtlCfgResp::scannercfg_size() const { + return _internal_scannercfg_size(); +} +inline void ScannerCrtlCfgResp::clear_scannercfg() { + _internal_mutable_scannercfg()->Clear(); +} +inline ::stream::ScannerCrtlCfgData* ScannerCrtlCfgResp::mutable_scannercfg(int index) { + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgResp.scannerCfg) + return _internal_mutable_scannercfg()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >* +ScannerCrtlCfgResp::mutable_scannercfg() { + // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgResp.scannerCfg) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_scannercfg(); +} +inline const ::stream::ScannerCrtlCfgData& ScannerCrtlCfgResp::scannercfg(int index) const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgResp.scannerCfg) + return _internal_scannercfg().Get(index); +} +inline ::stream::ScannerCrtlCfgData* ScannerCrtlCfgResp::add_scannercfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::ScannerCrtlCfgData* _add = _internal_mutable_scannercfg()->Add(); + // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgResp.scannerCfg) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >& +ScannerCrtlCfgResp::scannercfg() const { + // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgResp.scannerCfg) + return _internal_scannercfg(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>& +ScannerCrtlCfgResp::_internal_scannercfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scannercfg_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>* +ScannerCrtlCfgResp::_internal_mutable_scannercfg() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.scannercfg_; +} + +// ------------------------------------------------------------------- + +// ScannerCrtlCfgData + +// int32 seqNo = 1; +inline void ScannerCrtlCfgData::clear_seqno() { + _impl_.seqno_ = 0; +} +inline ::int32_t ScannerCrtlCfgData::seqno() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.seqNo) + return _internal_seqno(); +} +inline void ScannerCrtlCfgData::set_seqno(::int32_t value) { + _internal_set_seqno(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.seqNo) +} +inline ::int32_t ScannerCrtlCfgData::_internal_seqno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.seqno_; +} +inline void ScannerCrtlCfgData::_internal_set_seqno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.seqno_ = value; +} + +// repeated .stream.FixPointData fixPointData = 2; +inline int ScannerCrtlCfgData::_internal_fixpointdata_size() const { + return _internal_fixpointdata().size(); +} +inline int ScannerCrtlCfgData::fixpointdata_size() const { + return _internal_fixpointdata_size(); +} +inline void ScannerCrtlCfgData::clear_fixpointdata() { + _internal_mutable_fixpointdata()->Clear(); +} +inline ::stream::FixPointData* ScannerCrtlCfgData::mutable_fixpointdata(int index) { + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.fixPointData) + return _internal_mutable_fixpointdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >* +ScannerCrtlCfgData::mutable_fixpointdata() { + // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.fixPointData) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_fixpointdata(); +} +inline const ::stream::FixPointData& ScannerCrtlCfgData::fixpointdata(int index) const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.fixPointData) + return _internal_fixpointdata().Get(index); +} +inline ::stream::FixPointData* ScannerCrtlCfgData::add_fixpointdata() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::FixPointData* _add = _internal_mutable_fixpointdata()->Add(); + // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.fixPointData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >& +ScannerCrtlCfgData::fixpointdata() const { + // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.fixPointData) + return _internal_fixpointdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::FixPointData>& +ScannerCrtlCfgData::_internal_fixpointdata() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.fixpointdata_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::FixPointData>* +ScannerCrtlCfgData::_internal_mutable_fixpointdata() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.fixpointdata_; +} + +// .stream.ScanParamCfg scanParamCfg = 3; +inline bool ScannerCrtlCfgData::has_scanparamcfg() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.scanparamcfg_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_scanparamcfg() { + if (_impl_.scanparamcfg_ != nullptr) _impl_.scanparamcfg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_scanparamcfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanParamCfg* p = _impl_.scanparamcfg_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanParamCfg_default_instance_); +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::scanparamcfg() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.scanParamCfg) + return _internal_scanparamcfg(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_scanparamcfg(::stream::ScanParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scanparamcfg_); + } + _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.scanParamCfg) +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_scanparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::stream::ScanParamCfg* released = _impl_.scanparamcfg_; + _impl_.scanparamcfg_ = 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 ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_scanparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.scanParamCfg) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::stream::ScanParamCfg* temp = _impl_.scanparamcfg_; + _impl_.scanparamcfg_ = nullptr; + return temp; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_scanparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.scanparamcfg_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation()); + _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(p); + } + return _impl_.scanparamcfg_; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_scanparamcfg() { + ::stream::ScanParamCfg* _msg = _internal_mutable_scanparamcfg(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.scanParamCfg) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_scanparamcfg(::stream::ScanParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.scanparamcfg_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(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_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.scanParamCfg) +} + +// .stream.ScanParamCfg hatchingParams = 4; +inline bool ScannerCrtlCfgData::has_hatchingparams() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.hatchingparams_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_hatchingparams() { + if (_impl_.hatchingparams_ != nullptr) _impl_.hatchingparams_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_hatchingparams() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanParamCfg* p = _impl_.hatchingparams_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanParamCfg_default_instance_); +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::hatchingparams() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hatchingParams) + return _internal_hatchingparams(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_hatchingparams(::stream::ScanParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hatchingparams_); + } + _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.hatchingParams) +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_hatchingparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000002u; + ::stream::ScanParamCfg* released = _impl_.hatchingparams_; + _impl_.hatchingparams_ = 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 ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_hatchingparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.hatchingParams) + + _impl_._has_bits_[0] &= ~0x00000002u; + ::stream::ScanParamCfg* temp = _impl_.hatchingparams_; + _impl_.hatchingparams_ = nullptr; + return temp; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_hatchingparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.hatchingparams_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation()); + _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p); + } + return _impl_.hatchingparams_; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_hatchingparams() { + ::stream::ScanParamCfg* _msg = _internal_mutable_hatchingparams(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.hatchingParams) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_hatchingparams(::stream::ScanParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.hatchingparams_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + + _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.hatchingParams) +} + +// .stream.ScanParamCfg borderParams = 5; +inline bool ScannerCrtlCfgData::has_borderparams() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.borderparams_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_borderparams() { + if (_impl_.borderparams_ != nullptr) _impl_.borderparams_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_borderparams() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanParamCfg* p = _impl_.borderparams_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanParamCfg_default_instance_); +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::borderparams() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.borderParams) + return _internal_borderparams(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_borderparams(::stream::ScanParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.borderparams_); + } + _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.borderParams) +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_borderparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000004u; + ::stream::ScanParamCfg* released = _impl_.borderparams_; + _impl_.borderparams_ = 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 ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_borderparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.borderParams) + + _impl_._has_bits_[0] &= ~0x00000004u; + ::stream::ScanParamCfg* temp = _impl_.borderparams_; + _impl_.borderparams_ = nullptr; + return temp; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_borderparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.borderparams_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation()); + _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p); + } + return _impl_.borderparams_; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_borderparams() { + ::stream::ScanParamCfg* _msg = _internal_mutable_borderparams(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.borderParams) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_borderparams(::stream::ScanParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.borderparams_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + + _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.borderParams) +} + +// .stream.ScanParamCfg supportParams = 6; +inline bool ScannerCrtlCfgData::has_supportparams() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.supportparams_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_supportparams() { + if (_impl_.supportparams_ != nullptr) _impl_.supportparams_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_supportparams() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanParamCfg* p = _impl_.supportparams_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanParamCfg_default_instance_); +} +inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::supportparams() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.supportParams) + return _internal_supportparams(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_supportparams(::stream::ScanParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.supportparams_); + } + _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.supportParams) +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_supportparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000008u; + ::stream::ScanParamCfg* released = _impl_.supportparams_; + _impl_.supportparams_ = 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 ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_supportparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.supportParams) + + _impl_._has_bits_[0] &= ~0x00000008u; + ::stream::ScanParamCfg* temp = _impl_.supportparams_; + _impl_.supportparams_ = nullptr; + return temp; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_supportparams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.supportparams_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation()); + _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p); + } + return _impl_.supportparams_; +} +inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_supportparams() { + ::stream::ScanParamCfg* _msg = _internal_mutable_supportparams(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.supportParams) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_supportparams(::stream::ScanParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.supportparams_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + + _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.supportParams) +} + +// .stream.CorrectParamCfg correctParamCfg = 7; +inline bool ScannerCrtlCfgData::has_correctparamcfg() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.correctparamcfg_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_correctparamcfg() { + if (_impl_.correctparamcfg_ != nullptr) _impl_.correctparamcfg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::stream::CorrectParamCfg& ScannerCrtlCfgData::_internal_correctparamcfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::CorrectParamCfg* p = _impl_.correctparamcfg_; + return p != nullptr ? *p : reinterpret_cast(::stream::_CorrectParamCfg_default_instance_); +} +inline const ::stream::CorrectParamCfg& ScannerCrtlCfgData::correctparamcfg() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.correctParamCfg) + return _internal_correctparamcfg(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_correctparamcfg(::stream::CorrectParamCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.correctparamcfg_); + } + _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.correctParamCfg) +} +inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::release_correctparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000010u; + ::stream::CorrectParamCfg* released = _impl_.correctparamcfg_; + _impl_.correctparamcfg_ = 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 ::stream::CorrectParamCfg* ScannerCrtlCfgData::unsafe_arena_release_correctparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.correctParamCfg) + + _impl_._has_bits_[0] &= ~0x00000010u; + ::stream::CorrectParamCfg* temp = _impl_.correctparamcfg_; + _impl_.correctparamcfg_ = nullptr; + return temp; +} +inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::_internal_mutable_correctparamcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.correctparamcfg_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::CorrectParamCfg>(GetArenaForAllocation()); + _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(p); + } + return _impl_.correctparamcfg_; +} +inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::mutable_correctparamcfg() { + ::stream::CorrectParamCfg* _msg = _internal_mutable_correctparamcfg(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.correctParamCfg) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_correctparamcfg(::stream::CorrectParamCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::CorrectParamCfg*>(_impl_.correctparamcfg_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::CorrectParamCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + + _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.correctParamCfg) +} + +// .stream.ScanTestCfg scanTestCfg = 8; +inline bool ScannerCrtlCfgData::has_scantestcfg() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.scantestcfg_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_scantestcfg() { + if (_impl_.scantestcfg_ != nullptr) _impl_.scantestcfg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::stream::ScanTestCfg& ScannerCrtlCfgData::_internal_scantestcfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::ScanTestCfg* p = _impl_.scantestcfg_; + return p != nullptr ? *p : reinterpret_cast(::stream::_ScanTestCfg_default_instance_); +} +inline const ::stream::ScanTestCfg& ScannerCrtlCfgData::scantestcfg() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.scanTestCfg) + return _internal_scantestcfg(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_scantestcfg(::stream::ScanTestCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scantestcfg_); + } + _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.scanTestCfg) +} +inline ::stream::ScanTestCfg* ScannerCrtlCfgData::release_scantestcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000020u; + ::stream::ScanTestCfg* released = _impl_.scantestcfg_; + _impl_.scantestcfg_ = 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 ::stream::ScanTestCfg* ScannerCrtlCfgData::unsafe_arena_release_scantestcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.scanTestCfg) + + _impl_._has_bits_[0] &= ~0x00000020u; + ::stream::ScanTestCfg* temp = _impl_.scantestcfg_; + _impl_.scantestcfg_ = nullptr; + return temp; +} +inline ::stream::ScanTestCfg* ScannerCrtlCfgData::_internal_mutable_scantestcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.scantestcfg_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::ScanTestCfg>(GetArenaForAllocation()); + _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(p); + } + return _impl_.scantestcfg_; +} +inline ::stream::ScanTestCfg* ScannerCrtlCfgData::mutable_scantestcfg() { + ::stream::ScanTestCfg* _msg = _internal_mutable_scantestcfg(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.scanTestCfg) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_scantestcfg(::stream::ScanTestCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::ScanTestCfg*>(_impl_.scantestcfg_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanTestCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + + _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.scanTestCfg) +} + +// .stream.SkyWritingCfg skyWritingCfg = 9; +inline bool ScannerCrtlCfgData::has_skywritingcfg() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.skywritingcfg_ != nullptr); + return value; +} +inline void ScannerCrtlCfgData::clear_skywritingcfg() { + if (_impl_.skywritingcfg_ != nullptr) _impl_.skywritingcfg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const ::stream::SkyWritingCfg& ScannerCrtlCfgData::_internal_skywritingcfg() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::stream::SkyWritingCfg* p = _impl_.skywritingcfg_; + return p != nullptr ? *p : reinterpret_cast(::stream::_SkyWritingCfg_default_instance_); +} +inline const ::stream::SkyWritingCfg& ScannerCrtlCfgData::skywritingcfg() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.skyWritingCfg) + return _internal_skywritingcfg(); +} +inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_skywritingcfg(::stream::SkyWritingCfg* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.skywritingcfg_); + } + _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.skyWritingCfg) +} +inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::release_skywritingcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000040u; + ::stream::SkyWritingCfg* released = _impl_.skywritingcfg_; + _impl_.skywritingcfg_ = 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 ::stream::SkyWritingCfg* ScannerCrtlCfgData::unsafe_arena_release_skywritingcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.skyWritingCfg) + + _impl_._has_bits_[0] &= ~0x00000040u; + ::stream::SkyWritingCfg* temp = _impl_.skywritingcfg_; + _impl_.skywritingcfg_ = nullptr; + return temp; +} +inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::_internal_mutable_skywritingcfg() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000040u; + if (_impl_.skywritingcfg_ == nullptr) { + auto* p = CreateMaybeMessage<::stream::SkyWritingCfg>(GetArenaForAllocation()); + _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(p); + } + return _impl_.skywritingcfg_; +} +inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::mutable_skywritingcfg() { + ::stream::SkyWritingCfg* _msg = _internal_mutable_skywritingcfg(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.skyWritingCfg) + return _msg; +} +inline void ScannerCrtlCfgData::set_allocated_skywritingcfg(::stream::SkyWritingCfg* value) { + ::google::protobuf::Arena* message_arena = GetArenaForAllocation(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::stream::SkyWritingCfg*>(_impl_.skywritingcfg_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = + ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::SkyWritingCfg*>(value)); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + + _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(value); + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.skyWritingCfg) +} + +// repeated .stream.PowerCompensate powerCompensate = 10; +inline int ScannerCrtlCfgData::_internal_powercompensate_size() const { + return _internal_powercompensate().size(); +} +inline int ScannerCrtlCfgData::powercompensate_size() const { + return _internal_powercompensate_size(); +} +inline void ScannerCrtlCfgData::clear_powercompensate() { + _internal_mutable_powercompensate()->Clear(); +} +inline ::stream::PowerCompensate* ScannerCrtlCfgData::mutable_powercompensate(int index) { + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.powerCompensate) + return _internal_mutable_powercompensate()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >* +ScannerCrtlCfgData::mutable_powercompensate() { + // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.powerCompensate) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_powercompensate(); +} +inline const ::stream::PowerCompensate& ScannerCrtlCfgData::powercompensate(int index) const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.powerCompensate) + return _internal_powercompensate().Get(index); +} +inline ::stream::PowerCompensate* ScannerCrtlCfgData::add_powercompensate() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::PowerCompensate* _add = _internal_mutable_powercompensate()->Add(); + // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.powerCompensate) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >& +ScannerCrtlCfgData::powercompensate() const { + // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.powerCompensate) + return _internal_powercompensate(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>& +ScannerCrtlCfgData::_internal_powercompensate() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.powercompensate_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>* +ScannerCrtlCfgData::_internal_mutable_powercompensate() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.powercompensate_; +} + +// repeated .stream.TimePowerCompensate tPowerCompensate = 11; +inline int ScannerCrtlCfgData::_internal_tpowercompensate_size() const { + return _internal_tpowercompensate().size(); +} +inline int ScannerCrtlCfgData::tpowercompensate_size() const { + return _internal_tpowercompensate_size(); +} +inline void ScannerCrtlCfgData::clear_tpowercompensate() { + _internal_mutable_tpowercompensate()->Clear(); +} +inline ::stream::TimePowerCompensate* ScannerCrtlCfgData::mutable_tpowercompensate(int index) { + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.tPowerCompensate) + return _internal_mutable_tpowercompensate()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >* +ScannerCrtlCfgData::mutable_tpowercompensate() { + // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.tPowerCompensate) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_tpowercompensate(); +} +inline const ::stream::TimePowerCompensate& ScannerCrtlCfgData::tpowercompensate(int index) const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.tPowerCompensate) + return _internal_tpowercompensate().Get(index); +} +inline ::stream::TimePowerCompensate* ScannerCrtlCfgData::add_tpowercompensate() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::stream::TimePowerCompensate* _add = _internal_mutable_tpowercompensate()->Add(); + // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.tPowerCompensate) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >& +ScannerCrtlCfgData::tpowercompensate() const { + // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.tPowerCompensate) + return _internal_tpowercompensate(); +} +inline const ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>& +ScannerCrtlCfgData::_internal_tpowercompensate() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.tpowercompensate_; +} +inline ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>* +ScannerCrtlCfgData::_internal_mutable_tpowercompensate() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.tpowercompensate_; +} + +// int32 controlNo = 12; +inline void ScannerCrtlCfgData::clear_controlno() { + _impl_.controlno_ = 0; +} +inline ::int32_t ScannerCrtlCfgData::controlno() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.controlNo) + return _internal_controlno(); +} +inline void ScannerCrtlCfgData::set_controlno(::int32_t value) { + _internal_set_controlno(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.controlNo) +} +inline ::int32_t ScannerCrtlCfgData::_internal_controlno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.controlno_; +} +inline void ScannerCrtlCfgData::_internal_set_controlno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.controlno_ = value; +} + +// int32 serialNo = 13; +inline void ScannerCrtlCfgData::clear_serialno() { + _impl_.serialno_ = 0; +} +inline ::int32_t ScannerCrtlCfgData::serialno() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.serialNo) + return _internal_serialno(); +} +inline void ScannerCrtlCfgData::set_serialno(::int32_t value) { + _internal_set_serialno(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.serialNo) +} +inline ::int32_t ScannerCrtlCfgData::_internal_serialno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.serialno_; +} +inline void ScannerCrtlCfgData::_internal_set_serialno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.serialno_ = value; +} + +// int32 controlType = 14; +inline void ScannerCrtlCfgData::clear_controltype() { + _impl_.controltype_ = 0; +} +inline ::int32_t ScannerCrtlCfgData::controltype() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.controlType) + return _internal_controltype(); +} +inline void ScannerCrtlCfgData::set_controltype(::int32_t value) { + _internal_set_controltype(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.controlType) +} +inline ::int32_t ScannerCrtlCfgData::_internal_controltype() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.controltype_; +} +inline void ScannerCrtlCfgData::_internal_set_controltype(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.controltype_ = value; +} + +// bytes cardName = 15; +inline void ScannerCrtlCfgData::clear_cardname() { + _impl_.cardname_.ClearToEmpty(); +} +inline const std::string& ScannerCrtlCfgData::cardname() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.cardName) + return _internal_cardname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ScannerCrtlCfgData::set_cardname(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardname_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.cardName) +} +inline std::string* ScannerCrtlCfgData::mutable_cardname() { + std::string* _s = _internal_mutable_cardname(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.cardName) + return _s; +} +inline const std::string& ScannerCrtlCfgData::_internal_cardname() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cardname_.Get(); +} +inline void ScannerCrtlCfgData::_internal_set_cardname(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardname_.Set(value, GetArenaForAllocation()); +} +inline std::string* ScannerCrtlCfgData::_internal_mutable_cardname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.cardname_.Mutable( GetArenaForAllocation()); +} +inline std::string* ScannerCrtlCfgData::release_cardname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.cardName) + return _impl_.cardname_.Release(); +} +inline void ScannerCrtlCfgData::set_allocated_cardname(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.cardname_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.cardname_.IsDefault()) { + _impl_.cardname_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.cardName) +} + +// bytes cardIP = 16; +inline void ScannerCrtlCfgData::clear_cardip() { + _impl_.cardip_.ClearToEmpty(); +} +inline const std::string& ScannerCrtlCfgData::cardip() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.cardIP) + return _internal_cardip(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ScannerCrtlCfgData::set_cardip(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardip_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.cardIP) +} +inline std::string* ScannerCrtlCfgData::mutable_cardip() { + std::string* _s = _internal_mutable_cardip(); + // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.cardIP) + return _s; +} +inline const std::string& ScannerCrtlCfgData::_internal_cardip() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cardip_.Get(); +} +inline void ScannerCrtlCfgData::_internal_set_cardip(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cardip_.Set(value, GetArenaForAllocation()); +} +inline std::string* ScannerCrtlCfgData::_internal_mutable_cardip() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.cardip_.Mutable( GetArenaForAllocation()); +} +inline std::string* ScannerCrtlCfgData::release_cardip() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.cardIP) + return _impl_.cardip_.Release(); +} +inline void ScannerCrtlCfgData::set_allocated_cardip(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.cardip_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.cardip_.IsDefault()) { + _impl_.cardip_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.cardIP) +} + +// bool isEnable = 17; +inline void ScannerCrtlCfgData::clear_isenable() { + _impl_.isenable_ = false; +} +inline bool ScannerCrtlCfgData::isenable() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.isEnable) + return _internal_isenable(); +} +inline void ScannerCrtlCfgData::set_isenable(bool value) { + _internal_set_isenable(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.isEnable) +} +inline bool ScannerCrtlCfgData::_internal_isenable() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.isenable_; +} +inline void ScannerCrtlCfgData::_internal_set_isenable(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.isenable_ = value; +} + +// bool hadAssign = 18; +inline void ScannerCrtlCfgData::clear_hadassign() { + _impl_.hadassign_ = false; +} +inline bool ScannerCrtlCfgData::hadassign() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hadAssign) + return _internal_hadassign(); +} +inline void ScannerCrtlCfgData::set_hadassign(bool value) { + _internal_set_hadassign(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.hadAssign) +} +inline bool ScannerCrtlCfgData::_internal_hadassign() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.hadassign_; +} +inline void ScannerCrtlCfgData::_internal_set_hadassign(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.hadassign_ = value; +} + +// bool hadMatch = 19; +inline void ScannerCrtlCfgData::clear_hadmatch() { + _impl_.hadmatch_ = false; +} +inline bool ScannerCrtlCfgData::hadmatch() const { + // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hadMatch) + return _internal_hadmatch(); +} +inline void ScannerCrtlCfgData::set_hadmatch(bool value) { + _internal_set_hadmatch(value); + // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.hadMatch) +} +inline bool ScannerCrtlCfgData::_internal_hadmatch() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.hadmatch_; +} +inline void ScannerCrtlCfgData::_internal_set_hadmatch(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.hadmatch_ = value; +} + +// ------------------------------------------------------------------- + +// FixPointData + +// int32 id = 1; +inline void FixPointData::clear_id() { + _impl_.id_ = 0; +} +inline ::int32_t FixPointData::id() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.id) + return _internal_id(); +} +inline void FixPointData::set_id(::int32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.id) +} +inline ::int32_t FixPointData::_internal_id() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.id_; +} +inline void FixPointData::_internal_set_id(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.id_ = value; +} + +// int32 cno = 2; +inline void FixPointData::clear_cno() { + _impl_.cno_ = 0; +} +inline ::int32_t FixPointData::cno() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.cno) + return _internal_cno(); +} +inline void FixPointData::set_cno(::int32_t value) { + _internal_set_cno(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.cno) +} +inline ::int32_t FixPointData::_internal_cno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cno_; +} +inline void FixPointData::_internal_set_cno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cno_ = value; +} + +// float pointX = 3; +inline void FixPointData::clear_pointx() { + _impl_.pointx_ = 0; +} +inline float FixPointData::pointx() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.pointX) + return _internal_pointx(); +} +inline void FixPointData::set_pointx(float value) { + _internal_set_pointx(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.pointX) +} +inline float FixPointData::_internal_pointx() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.pointx_; +} +inline void FixPointData::_internal_set_pointx(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.pointx_ = value; +} + +// float pointY = 4; +inline void FixPointData::clear_pointy() { + _impl_.pointy_ = 0; +} +inline float FixPointData::pointy() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.pointY) + return _internal_pointy(); +} +inline void FixPointData::set_pointy(float value) { + _internal_set_pointy(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.pointY) +} +inline float FixPointData::_internal_pointy() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.pointy_; +} +inline void FixPointData::_internal_set_pointy(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.pointy_ = value; +} + +// uint32 duration = 5; +inline void FixPointData::clear_duration() { + _impl_.duration_ = 0u; +} +inline ::uint32_t FixPointData::duration() const { + // @@protoc_insertion_point(field_get:stream.FixPointData.duration) + return _internal_duration(); +} +inline void FixPointData::set_duration(::uint32_t value) { + _internal_set_duration(value); + // @@protoc_insertion_point(field_set:stream.FixPointData.duration) +} +inline ::uint32_t FixPointData::_internal_duration() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.duration_; +} +inline void FixPointData::_internal_set_duration(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.duration_ = value; +} + +// ------------------------------------------------------------------- + +// ScanParamCfg + +// int32 edgeLevel = 1; +inline void ScanParamCfg::clear_edgelevel() { + _impl_.edgelevel_ = 0; +} +inline ::int32_t ScanParamCfg::edgelevel() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevel) + return _internal_edgelevel(); +} +inline void ScanParamCfg::set_edgelevel(::int32_t value) { + _internal_set_edgelevel(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevel) +} +inline ::int32_t ScanParamCfg::_internal_edgelevel() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.edgelevel_; +} +inline void ScanParamCfg::_internal_set_edgelevel(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.edgelevel_ = value; +} + +// int32 edgeLevelMin = 2; +inline void ScanParamCfg::clear_edgelevelmin() { + _impl_.edgelevelmin_ = 0; +} +inline ::int32_t ScanParamCfg::edgelevelmin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevelMin) + return _internal_edgelevelmin(); +} +inline void ScanParamCfg::set_edgelevelmin(::int32_t value) { + _internal_set_edgelevelmin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevelMin) +} +inline ::int32_t ScanParamCfg::_internal_edgelevelmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.edgelevelmin_; +} +inline void ScanParamCfg::_internal_set_edgelevelmin(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.edgelevelmin_ = value; +} + +// int32 edgeLevelMax = 3; +inline void ScanParamCfg::clear_edgelevelmax() { + _impl_.edgelevelmax_ = 0; +} +inline ::int32_t ScanParamCfg::edgelevelmax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevelMax) + return _internal_edgelevelmax(); +} +inline void ScanParamCfg::set_edgelevelmax(::int32_t value) { + _internal_set_edgelevelmax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevelMax) +} +inline ::int32_t ScanParamCfg::_internal_edgelevelmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.edgelevelmax_; +} +inline void ScanParamCfg::_internal_set_edgelevelmax(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.edgelevelmax_ = value; +} + +// uint32 jumpDelay = 4; +inline void ScanParamCfg::clear_jumpdelay() { + _impl_.jumpdelay_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumpdelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelay) + return _internal_jumpdelay(); +} +inline void ScanParamCfg::set_jumpdelay(::uint32_t value) { + _internal_set_jumpdelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelay) +} +inline ::uint32_t ScanParamCfg::_internal_jumpdelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpdelay_; +} +inline void ScanParamCfg::_internal_set_jumpdelay(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpdelay_ = value; +} + +// uint32 jumpDelayMin = 5; +inline void ScanParamCfg::clear_jumpdelaymin() { + _impl_.jumpdelaymin_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumpdelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelayMin) + return _internal_jumpdelaymin(); +} +inline void ScanParamCfg::set_jumpdelaymin(::uint32_t value) { + _internal_set_jumpdelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelayMin) +} +inline ::uint32_t ScanParamCfg::_internal_jumpdelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpdelaymin_; +} +inline void ScanParamCfg::_internal_set_jumpdelaymin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpdelaymin_ = value; +} + +// uint32 jumpDelayMax = 6; +inline void ScanParamCfg::clear_jumpdelaymax() { + _impl_.jumpdelaymax_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumpdelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelayMax) + return _internal_jumpdelaymax(); +} +inline void ScanParamCfg::set_jumpdelaymax(::uint32_t value) { + _internal_set_jumpdelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelayMax) +} +inline ::uint32_t ScanParamCfg::_internal_jumpdelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpdelaymax_; +} +inline void ScanParamCfg::_internal_set_jumpdelaymax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpdelaymax_ = value; +} + +// uint32 scanDelay = 7; +inline void ScanParamCfg::clear_scandelay() { + _impl_.scandelay_ = 0u; +} +inline ::uint32_t ScanParamCfg::scandelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelay) + return _internal_scandelay(); +} +inline void ScanParamCfg::set_scandelay(::uint32_t value) { + _internal_set_scandelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelay) +} +inline ::uint32_t ScanParamCfg::_internal_scandelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scandelay_; +} +inline void ScanParamCfg::_internal_set_scandelay(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scandelay_ = value; +} + +// uint32 scanDelayMin = 8; +inline void ScanParamCfg::clear_scandelaymin() { + _impl_.scandelaymin_ = 0u; +} +inline ::uint32_t ScanParamCfg::scandelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelayMin) + return _internal_scandelaymin(); +} +inline void ScanParamCfg::set_scandelaymin(::uint32_t value) { + _internal_set_scandelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelayMin) +} +inline ::uint32_t ScanParamCfg::_internal_scandelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scandelaymin_; +} +inline void ScanParamCfg::_internal_set_scandelaymin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scandelaymin_ = value; +} + +// uint32 scanDelayMax = 9; +inline void ScanParamCfg::clear_scandelaymax() { + _impl_.scandelaymax_ = 0u; +} +inline ::uint32_t ScanParamCfg::scandelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelayMax) + return _internal_scandelaymax(); +} +inline void ScanParamCfg::set_scandelaymax(::uint32_t value) { + _internal_set_scandelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelayMax) +} +inline ::uint32_t ScanParamCfg::_internal_scandelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scandelaymax_; +} +inline void ScanParamCfg::_internal_set_scandelaymax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scandelaymax_ = value; +} + +// uint32 polygonDelay = 10; +inline void ScanParamCfg::clear_polygondelay() { + _impl_.polygondelay_ = 0u; +} +inline ::uint32_t ScanParamCfg::polygondelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelay) + return _internal_polygondelay(); +} +inline void ScanParamCfg::set_polygondelay(::uint32_t value) { + _internal_set_polygondelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelay) +} +inline ::uint32_t ScanParamCfg::_internal_polygondelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.polygondelay_; +} +inline void ScanParamCfg::_internal_set_polygondelay(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.polygondelay_ = value; +} + +// uint32 polygonDelayMin = 11; +inline void ScanParamCfg::clear_polygondelaymin() { + _impl_.polygondelaymin_ = 0u; +} +inline ::uint32_t ScanParamCfg::polygondelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelayMin) + return _internal_polygondelaymin(); +} +inline void ScanParamCfg::set_polygondelaymin(::uint32_t value) { + _internal_set_polygondelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelayMin) +} +inline ::uint32_t ScanParamCfg::_internal_polygondelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.polygondelaymin_; +} +inline void ScanParamCfg::_internal_set_polygondelaymin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.polygondelaymin_ = value; +} + +// uint32 polygonDelayMax = 12; +inline void ScanParamCfg::clear_polygondelaymax() { + _impl_.polygondelaymax_ = 0u; +} +inline ::uint32_t ScanParamCfg::polygondelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelayMax) + return _internal_polygondelaymax(); +} +inline void ScanParamCfg::set_polygondelaymax(::uint32_t value) { + _internal_set_polygondelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelayMax) +} +inline ::uint32_t ScanParamCfg::_internal_polygondelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.polygondelaymax_; +} +inline void ScanParamCfg::_internal_set_polygondelaymax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.polygondelaymax_ = value; +} + +// int64 laseroffDelay = 13; +inline void ScanParamCfg::clear_laseroffdelay() { + _impl_.laseroffdelay_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laseroffdelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelay) + return _internal_laseroffdelay(); +} +inline void ScanParamCfg::set_laseroffdelay(::int64_t value) { + _internal_set_laseroffdelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelay) +} +inline ::int64_t ScanParamCfg::_internal_laseroffdelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseroffdelay_; +} +inline void ScanParamCfg::_internal_set_laseroffdelay(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseroffdelay_ = value; +} + +// int64 laseroffDelayMin = 14; +inline void ScanParamCfg::clear_laseroffdelaymin() { + _impl_.laseroffdelaymin_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laseroffdelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelayMin) + return _internal_laseroffdelaymin(); +} +inline void ScanParamCfg::set_laseroffdelaymin(::int64_t value) { + _internal_set_laseroffdelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelayMin) +} +inline ::int64_t ScanParamCfg::_internal_laseroffdelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseroffdelaymin_; +} +inline void ScanParamCfg::_internal_set_laseroffdelaymin(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseroffdelaymin_ = value; +} + +// int64 laseroffDelayMax = 15; +inline void ScanParamCfg::clear_laseroffdelaymax() { + _impl_.laseroffdelaymax_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laseroffdelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelayMax) + return _internal_laseroffdelaymax(); +} +inline void ScanParamCfg::set_laseroffdelaymax(::int64_t value) { + _internal_set_laseroffdelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelayMax) +} +inline ::int64_t ScanParamCfg::_internal_laseroffdelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseroffdelaymax_; +} +inline void ScanParamCfg::_internal_set_laseroffdelaymax(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseroffdelaymax_ = value; +} + +// int64 laseronDelay = 16; +inline void ScanParamCfg::clear_laserondelay() { + _impl_.laserondelay_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laserondelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelay) + return _internal_laserondelay(); +} +inline void ScanParamCfg::set_laserondelay(::int64_t value) { + _internal_set_laserondelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelay) +} +inline ::int64_t ScanParamCfg::_internal_laserondelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laserondelay_; +} +inline void ScanParamCfg::_internal_set_laserondelay(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laserondelay_ = value; +} + +// int64 laseronDelayMin = 17; +inline void ScanParamCfg::clear_laserondelaymin() { + _impl_.laserondelaymin_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laserondelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelayMin) + return _internal_laserondelaymin(); +} +inline void ScanParamCfg::set_laserondelaymin(::int64_t value) { + _internal_set_laserondelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelayMin) +} +inline ::int64_t ScanParamCfg::_internal_laserondelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laserondelaymin_; +} +inline void ScanParamCfg::_internal_set_laserondelaymin(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laserondelaymin_ = value; +} + +// int64 laseronDelayMax = 18; +inline void ScanParamCfg::clear_laserondelaymax() { + _impl_.laserondelaymax_ = ::int64_t{0}; +} +inline ::int64_t ScanParamCfg::laserondelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelayMax) + return _internal_laserondelaymax(); +} +inline void ScanParamCfg::set_laserondelaymax(::int64_t value) { + _internal_set_laserondelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelayMax) +} +inline ::int64_t ScanParamCfg::_internal_laserondelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laserondelaymax_; +} +inline void ScanParamCfg::_internal_set_laserondelaymax(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laserondelaymax_ = value; +} + +// uint32 minJumpDelay = 19; +inline void ScanParamCfg::clear_minjumpdelay() { + _impl_.minjumpdelay_ = 0u; +} +inline ::uint32_t ScanParamCfg::minjumpdelay() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelay) + return _internal_minjumpdelay(); +} +inline void ScanParamCfg::set_minjumpdelay(::uint32_t value) { + _internal_set_minjumpdelay(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelay) +} +inline ::uint32_t ScanParamCfg::_internal_minjumpdelay() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.minjumpdelay_; +} +inline void ScanParamCfg::_internal_set_minjumpdelay(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.minjumpdelay_ = value; +} + +// uint32 minJumpDelayMin = 20; +inline void ScanParamCfg::clear_minjumpdelaymin() { + _impl_.minjumpdelaymin_ = 0u; +} +inline ::uint32_t ScanParamCfg::minjumpdelaymin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelayMin) + return _internal_minjumpdelaymin(); +} +inline void ScanParamCfg::set_minjumpdelaymin(::uint32_t value) { + _internal_set_minjumpdelaymin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelayMin) +} +inline ::uint32_t ScanParamCfg::_internal_minjumpdelaymin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.minjumpdelaymin_; +} +inline void ScanParamCfg::_internal_set_minjumpdelaymin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.minjumpdelaymin_ = value; +} + +// uint32 minJumpDelayMax = 21; +inline void ScanParamCfg::clear_minjumpdelaymax() { + _impl_.minjumpdelaymax_ = 0u; +} +inline ::uint32_t ScanParamCfg::minjumpdelaymax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelayMax) + return _internal_minjumpdelaymax(); +} +inline void ScanParamCfg::set_minjumpdelaymax(::uint32_t value) { + _internal_set_minjumpdelaymax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelayMax) +} +inline ::uint32_t ScanParamCfg::_internal_minjumpdelaymax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.minjumpdelaymax_; +} +inline void ScanParamCfg::_internal_set_minjumpdelaymax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.minjumpdelaymax_ = value; +} + +// uint32 jumpLengthLimit = 22; +inline void ScanParamCfg::clear_jumplengthlimit() { + _impl_.jumplengthlimit_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumplengthlimit() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimit) + return _internal_jumplengthlimit(); +} +inline void ScanParamCfg::set_jumplengthlimit(::uint32_t value) { + _internal_set_jumplengthlimit(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimit) +} +inline ::uint32_t ScanParamCfg::_internal_jumplengthlimit() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumplengthlimit_; +} +inline void ScanParamCfg::_internal_set_jumplengthlimit(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumplengthlimit_ = value; +} + +// uint32 jumpLengthLimitMin = 23; +inline void ScanParamCfg::clear_jumplengthlimitmin() { + _impl_.jumplengthlimitmin_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumplengthlimitmin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimitMin) + return _internal_jumplengthlimitmin(); +} +inline void ScanParamCfg::set_jumplengthlimitmin(::uint32_t value) { + _internal_set_jumplengthlimitmin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimitMin) +} +inline ::uint32_t ScanParamCfg::_internal_jumplengthlimitmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumplengthlimitmin_; +} +inline void ScanParamCfg::_internal_set_jumplengthlimitmin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumplengthlimitmin_ = value; +} + +// uint32 jumpLengthLimitMax = 24; +inline void ScanParamCfg::clear_jumplengthlimitmax() { + _impl_.jumplengthlimitmax_ = 0u; +} +inline ::uint32_t ScanParamCfg::jumplengthlimitmax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimitMax) + return _internal_jumplengthlimitmax(); +} +inline void ScanParamCfg::set_jumplengthlimitmax(::uint32_t value) { + _internal_set_jumplengthlimitmax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimitMax) +} +inline ::uint32_t ScanParamCfg::_internal_jumplengthlimitmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumplengthlimitmax_; +} +inline void ScanParamCfg::_internal_set_jumplengthlimitmax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumplengthlimitmax_ = value; +} + +// double jumpSpeed = 25; +inline void ScanParamCfg::clear_jumpspeed() { + _impl_.jumpspeed_ = 0; +} +inline double ScanParamCfg::jumpspeed() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeed) + return _internal_jumpspeed(); +} +inline void ScanParamCfg::set_jumpspeed(double value) { + _internal_set_jumpspeed(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeed) +} +inline double ScanParamCfg::_internal_jumpspeed() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpspeed_; +} +inline void ScanParamCfg::_internal_set_jumpspeed(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpspeed_ = value; +} + +// double jumpSpeedMin = 26; +inline void ScanParamCfg::clear_jumpspeedmin() { + _impl_.jumpspeedmin_ = 0; +} +inline double ScanParamCfg::jumpspeedmin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeedMin) + return _internal_jumpspeedmin(); +} +inline void ScanParamCfg::set_jumpspeedmin(double value) { + _internal_set_jumpspeedmin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeedMin) +} +inline double ScanParamCfg::_internal_jumpspeedmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpspeedmin_; +} +inline void ScanParamCfg::_internal_set_jumpspeedmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpspeedmin_ = value; +} + +// double jumpSpeedMax = 27; +inline void ScanParamCfg::clear_jumpspeedmax() { + _impl_.jumpspeedmax_ = 0; +} +inline double ScanParamCfg::jumpspeedmax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeedMax) + return _internal_jumpspeedmax(); +} +inline void ScanParamCfg::set_jumpspeedmax(double value) { + _internal_set_jumpspeedmax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeedMax) +} +inline double ScanParamCfg::_internal_jumpspeedmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.jumpspeedmax_; +} +inline void ScanParamCfg::_internal_set_jumpspeedmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.jumpspeedmax_ = value; +} + +// double markSpeed = 28; +inline void ScanParamCfg::clear_markspeed() { + _impl_.markspeed_ = 0; +} +inline double ScanParamCfg::markspeed() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeed) + return _internal_markspeed(); +} +inline void ScanParamCfg::set_markspeed(double value) { + _internal_set_markspeed(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeed) +} +inline double ScanParamCfg::_internal_markspeed() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.markspeed_; +} +inline void ScanParamCfg::_internal_set_markspeed(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.markspeed_ = value; +} + +// double markSpeedMin = 29; +inline void ScanParamCfg::clear_markspeedmin() { + _impl_.markspeedmin_ = 0; +} +inline double ScanParamCfg::markspeedmin() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeedMin) + return _internal_markspeedmin(); +} +inline void ScanParamCfg::set_markspeedmin(double value) { + _internal_set_markspeedmin(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeedMin) +} +inline double ScanParamCfg::_internal_markspeedmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.markspeedmin_; +} +inline void ScanParamCfg::_internal_set_markspeedmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.markspeedmin_ = value; +} + +// double markSpeedMax = 30; +inline void ScanParamCfg::clear_markspeedmax() { + _impl_.markspeedmax_ = 0; +} +inline double ScanParamCfg::markspeedmax() const { + // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeedMax) + return _internal_markspeedmax(); +} +inline void ScanParamCfg::set_markspeedmax(double value) { + _internal_set_markspeedmax(value); + // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeedMax) +} +inline double ScanParamCfg::_internal_markspeedmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.markspeedmax_; +} +inline void ScanParamCfg::_internal_set_markspeedmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.markspeedmax_ = value; +} + +// ------------------------------------------------------------------- + +// CorrectParamCfg + +// double xmeasureMin = 1; +inline void CorrectParamCfg::clear_xmeasuremin() { + _impl_.xmeasuremin_ = 0; +} +inline double CorrectParamCfg::xmeasuremin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xmeasureMin) + return _internal_xmeasuremin(); +} +inline void CorrectParamCfg::set_xmeasuremin(double value) { + _internal_set_xmeasuremin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xmeasureMin) +} +inline double CorrectParamCfg::_internal_xmeasuremin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xmeasuremin_; +} +inline void CorrectParamCfg::_internal_set_xmeasuremin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xmeasuremin_ = value; +} + +// double xmeasureMax = 2; +inline void CorrectParamCfg::clear_xmeasuremax() { + _impl_.xmeasuremax_ = 0; +} +inline double CorrectParamCfg::xmeasuremax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xmeasureMax) + return _internal_xmeasuremax(); +} +inline void CorrectParamCfg::set_xmeasuremax(double value) { + _internal_set_xmeasuremax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xmeasureMax) +} +inline double CorrectParamCfg::_internal_xmeasuremax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xmeasuremax_; +} +inline void CorrectParamCfg::_internal_set_xmeasuremax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xmeasuremax_ = value; +} + +// double ymeasureMin = 3; +inline void CorrectParamCfg::clear_ymeasuremin() { + _impl_.ymeasuremin_ = 0; +} +inline double CorrectParamCfg::ymeasuremin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ymeasureMin) + return _internal_ymeasuremin(); +} +inline void CorrectParamCfg::set_ymeasuremin(double value) { + _internal_set_ymeasuremin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ymeasureMin) +} +inline double CorrectParamCfg::_internal_ymeasuremin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ymeasuremin_; +} +inline void CorrectParamCfg::_internal_set_ymeasuremin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ymeasuremin_ = value; +} + +// double ymeasureMax = 4; +inline void CorrectParamCfg::clear_ymeasuremax() { + _impl_.ymeasuremax_ = 0; +} +inline double CorrectParamCfg::ymeasuremax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ymeasureMax) + return _internal_ymeasuremax(); +} +inline void CorrectParamCfg::set_ymeasuremax(double value) { + _internal_set_ymeasuremax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ymeasureMax) +} +inline double CorrectParamCfg::_internal_ymeasuremax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ymeasuremax_; +} +inline void CorrectParamCfg::_internal_set_ymeasuremax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ymeasuremax_ = value; +} + +// double xposfix = 5; +inline void CorrectParamCfg::clear_xposfix() { + _impl_.xposfix_ = 0; +} +inline double CorrectParamCfg::xposfix() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xposfix) + return _internal_xposfix(); +} +inline void CorrectParamCfg::set_xposfix(double value) { + _internal_set_xposfix(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xposfix) +} +inline double CorrectParamCfg::_internal_xposfix() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xposfix_; +} +inline void CorrectParamCfg::_internal_set_xposfix(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xposfix_ = value; +} + +// double yposfix = 6; +inline void CorrectParamCfg::clear_yposfix() { + _impl_.yposfix_ = 0; +} +inline double CorrectParamCfg::yposfix() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.yposfix) + return _internal_yposfix(); +} +inline void CorrectParamCfg::set_yposfix(double value) { + _internal_set_yposfix(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.yposfix) +} +inline double CorrectParamCfg::_internal_yposfix() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.yposfix_; +} +inline void CorrectParamCfg::_internal_set_yposfix(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.yposfix_ = value; +} + +// double scanAngle = 7; +inline void CorrectParamCfg::clear_scanangle() { + _impl_.scanangle_ = 0; +} +inline double CorrectParamCfg::scanangle() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngle) + return _internal_scanangle(); +} +inline void CorrectParamCfg::set_scanangle(double value) { + _internal_set_scanangle(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngle) +} +inline double CorrectParamCfg::_internal_scanangle() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scanangle_; +} +inline void CorrectParamCfg::_internal_set_scanangle(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scanangle_ = value; +} + +// double scanAngleMin = 8; +inline void CorrectParamCfg::clear_scananglemin() { + _impl_.scananglemin_ = 0; +} +inline double CorrectParamCfg::scananglemin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngleMin) + return _internal_scananglemin(); +} +inline void CorrectParamCfg::set_scananglemin(double value) { + _internal_set_scananglemin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngleMin) +} +inline double CorrectParamCfg::_internal_scananglemin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scananglemin_; +} +inline void CorrectParamCfg::_internal_set_scananglemin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scananglemin_ = value; +} + +// double scanAngleMax = 9; +inline void CorrectParamCfg::clear_scananglemax() { + _impl_.scananglemax_ = 0; +} +inline double CorrectParamCfg::scananglemax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngleMax) + return _internal_scananglemax(); +} +inline void CorrectParamCfg::set_scananglemax(double value) { + _internal_set_scananglemax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngleMax) +} +inline double CorrectParamCfg::_internal_scananglemax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.scananglemax_; +} +inline void CorrectParamCfg::_internal_set_scananglemax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.scananglemax_ = value; +} + +// double fixAngle = 10; +inline void CorrectParamCfg::clear_fixangle() { + _impl_.fixangle_ = 0; +} +inline double CorrectParamCfg::fixangle() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngle) + return _internal_fixangle(); +} +inline void CorrectParamCfg::set_fixangle(double value) { + _internal_set_fixangle(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngle) +} +inline double CorrectParamCfg::_internal_fixangle() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.fixangle_; +} +inline void CorrectParamCfg::_internal_set_fixangle(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.fixangle_ = value; +} + +// double fixAngleMin = 11; +inline void CorrectParamCfg::clear_fixanglemin() { + _impl_.fixanglemin_ = 0; +} +inline double CorrectParamCfg::fixanglemin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngleMin) + return _internal_fixanglemin(); +} +inline void CorrectParamCfg::set_fixanglemin(double value) { + _internal_set_fixanglemin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngleMin) +} +inline double CorrectParamCfg::_internal_fixanglemin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.fixanglemin_; +} +inline void CorrectParamCfg::_internal_set_fixanglemin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.fixanglemin_ = value; +} + +// double fixAngleMax = 12; +inline void CorrectParamCfg::clear_fixanglemax() { + _impl_.fixanglemax_ = 0; +} +inline double CorrectParamCfg::fixanglemax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngleMax) + return _internal_fixanglemax(); +} +inline void CorrectParamCfg::set_fixanglemax(double value) { + _internal_set_fixanglemax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngleMax) +} +inline double CorrectParamCfg::_internal_fixanglemax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.fixanglemax_; +} +inline void CorrectParamCfg::_internal_set_fixanglemax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.fixanglemax_ = value; +} + +// double xcorrect = 13; +inline void CorrectParamCfg::clear_xcorrect() { + _impl_.xcorrect_ = 0; +} +inline double CorrectParamCfg::xcorrect() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrect) + return _internal_xcorrect(); +} +inline void CorrectParamCfg::set_xcorrect(double value) { + _internal_set_xcorrect(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrect) +} +inline double CorrectParamCfg::_internal_xcorrect() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xcorrect_; +} +inline void CorrectParamCfg::_internal_set_xcorrect(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xcorrect_ = value; +} + +// double ycorrect = 14; +inline void CorrectParamCfg::clear_ycorrect() { + _impl_.ycorrect_ = 0; +} +inline double CorrectParamCfg::ycorrect() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrect) + return _internal_ycorrect(); +} +inline void CorrectParamCfg::set_ycorrect(double value) { + _internal_set_ycorrect(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrect) +} +inline double CorrectParamCfg::_internal_ycorrect() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ycorrect_; +} +inline void CorrectParamCfg::_internal_set_ycorrect(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ycorrect_ = value; +} + +// double xcorrectMin = 15; +inline void CorrectParamCfg::clear_xcorrectmin() { + _impl_.xcorrectmin_ = 0; +} +inline double CorrectParamCfg::xcorrectmin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrectMin) + return _internal_xcorrectmin(); +} +inline void CorrectParamCfg::set_xcorrectmin(double value) { + _internal_set_xcorrectmin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrectMin) +} +inline double CorrectParamCfg::_internal_xcorrectmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xcorrectmin_; +} +inline void CorrectParamCfg::_internal_set_xcorrectmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xcorrectmin_ = value; +} + +// double xcorrectMax = 16; +inline void CorrectParamCfg::clear_xcorrectmax() { + _impl_.xcorrectmax_ = 0; +} +inline double CorrectParamCfg::xcorrectmax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrectMax) + return _internal_xcorrectmax(); +} +inline void CorrectParamCfg::set_xcorrectmax(double value) { + _internal_set_xcorrectmax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrectMax) +} +inline double CorrectParamCfg::_internal_xcorrectmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.xcorrectmax_; +} +inline void CorrectParamCfg::_internal_set_xcorrectmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.xcorrectmax_ = value; +} + +// double ycorrectMin = 17; +inline void CorrectParamCfg::clear_ycorrectmin() { + _impl_.ycorrectmin_ = 0; +} +inline double CorrectParamCfg::ycorrectmin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrectMin) + return _internal_ycorrectmin(); +} +inline void CorrectParamCfg::set_ycorrectmin(double value) { + _internal_set_ycorrectmin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrectMin) +} +inline double CorrectParamCfg::_internal_ycorrectmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ycorrectmin_; +} +inline void CorrectParamCfg::_internal_set_ycorrectmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ycorrectmin_ = value; +} + +// double ycorrectMax = 18; +inline void CorrectParamCfg::clear_ycorrectmax() { + _impl_.ycorrectmax_ = 0; +} +inline double CorrectParamCfg::ycorrectmax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrectMax) + return _internal_ycorrectmax(); +} +inline void CorrectParamCfg::set_ycorrectmax(double value) { + _internal_set_ycorrectmax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrectMax) +} +inline double CorrectParamCfg::_internal_ycorrectmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.ycorrectmax_; +} +inline void CorrectParamCfg::_internal_set_ycorrectmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.ycorrectmax_ = value; +} + +// double realXOffset = 19; +inline void CorrectParamCfg::clear_realxoffset() { + _impl_.realxoffset_ = 0; +} +inline double CorrectParamCfg::realxoffset() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.realXOffset) + return _internal_realxoffset(); +} +inline void CorrectParamCfg::set_realxoffset(double value) { + _internal_set_realxoffset(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.realXOffset) +} +inline double CorrectParamCfg::_internal_realxoffset() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.realxoffset_; +} +inline void CorrectParamCfg::_internal_set_realxoffset(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.realxoffset_ = value; +} + +// double realYOffset = 20; +inline void CorrectParamCfg::clear_realyoffset() { + _impl_.realyoffset_ = 0; +} +inline double CorrectParamCfg::realyoffset() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.realYOffset) + return _internal_realyoffset(); +} +inline void CorrectParamCfg::set_realyoffset(double value) { + _internal_set_realyoffset(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.realYOffset) +} +inline double CorrectParamCfg::_internal_realyoffset() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.realyoffset_; +} +inline void CorrectParamCfg::_internal_set_realyoffset(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.realyoffset_ = value; +} + +// double factorK = 21; +inline void CorrectParamCfg::clear_factork() { + _impl_.factork_ = 0; +} +inline double CorrectParamCfg::factork() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.factorK) + return _internal_factork(); +} +inline void CorrectParamCfg::set_factork(double value) { + _internal_set_factork(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.factorK) +} +inline double CorrectParamCfg::_internal_factork() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.factork_; +} +inline void CorrectParamCfg::_internal_set_factork(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.factork_ = value; +} + +// bool isCorrectFile3D = 22; +inline void CorrectParamCfg::clear_iscorrectfile3d() { + _impl_.iscorrectfile3d_ = false; +} +inline bool CorrectParamCfg::iscorrectfile3d() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.isCorrectFile3D) + return _internal_iscorrectfile3d(); +} +inline void CorrectParamCfg::set_iscorrectfile3d(bool value) { + _internal_set_iscorrectfile3d(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.isCorrectFile3D) +} +inline bool CorrectParamCfg::_internal_iscorrectfile3d() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.iscorrectfile3d_; +} +inline void CorrectParamCfg::_internal_set_iscorrectfile3d(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.iscorrectfile3d_ = value; +} + +// bool isDynamicFocus = 23; +inline void CorrectParamCfg::clear_isdynamicfocus() { + _impl_.isdynamicfocus_ = false; +} +inline bool CorrectParamCfg::isdynamicfocus() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.isDynamicFocus) + return _internal_isdynamicfocus(); +} +inline void CorrectParamCfg::set_isdynamicfocus(bool value) { + _internal_set_isdynamicfocus(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.isDynamicFocus) +} +inline bool CorrectParamCfg::_internal_isdynamicfocus() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.isdynamicfocus_; +} +inline void CorrectParamCfg::_internal_set_isdynamicfocus(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.isdynamicfocus_ = value; +} + +// double defocusRatio = 24; +inline void CorrectParamCfg::clear_defocusratio() { + _impl_.defocusratio_ = 0; +} +inline double CorrectParamCfg::defocusratio() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatio) + return _internal_defocusratio(); +} +inline void CorrectParamCfg::set_defocusratio(double value) { + _internal_set_defocusratio(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatio) +} +inline double CorrectParamCfg::_internal_defocusratio() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocusratio_; +} +inline void CorrectParamCfg::_internal_set_defocusratio(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocusratio_ = value; +} + +// double defocusRatioMin = 25; +inline void CorrectParamCfg::clear_defocusratiomin() { + _impl_.defocusratiomin_ = 0; +} +inline double CorrectParamCfg::defocusratiomin() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatioMin) + return _internal_defocusratiomin(); +} +inline void CorrectParamCfg::set_defocusratiomin(double value) { + _internal_set_defocusratiomin(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatioMin) +} +inline double CorrectParamCfg::_internal_defocusratiomin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocusratiomin_; +} +inline void CorrectParamCfg::_internal_set_defocusratiomin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocusratiomin_ = value; +} + +// double defocusRatioMax = 26; +inline void CorrectParamCfg::clear_defocusratiomax() { + _impl_.defocusratiomax_ = 0; +} +inline double CorrectParamCfg::defocusratiomax() const { + // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatioMax) + return _internal_defocusratiomax(); +} +inline void CorrectParamCfg::set_defocusratiomax(double value) { + _internal_set_defocusratiomax(value); + // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatioMax) +} +inline double CorrectParamCfg::_internal_defocusratiomax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocusratiomax_; +} +inline void CorrectParamCfg::_internal_set_defocusratiomax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocusratiomax_ = value; +} + +// ------------------------------------------------------------------- + +// ScanTestCfg + +// int32 debugShape = 1; +inline void ScanTestCfg::clear_debugshape() { + _impl_.debugshape_ = 0; +} +inline ::int32_t ScanTestCfg::debugshape() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.debugShape) + return _internal_debugshape(); +} +inline void ScanTestCfg::set_debugshape(::int32_t value) { + _internal_set_debugshape(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.debugShape) +} +inline ::int32_t ScanTestCfg::_internal_debugshape() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.debugshape_; +} +inline void ScanTestCfg::_internal_set_debugshape(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.debugshape_ = value; +} + +// int32 shapeSize = 2; +inline void ScanTestCfg::clear_shapesize() { + _impl_.shapesize_ = 0; +} +inline ::int32_t ScanTestCfg::shapesize() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shapeSize) + return _internal_shapesize(); +} +inline void ScanTestCfg::set_shapesize(::int32_t value) { + _internal_set_shapesize(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shapeSize) +} +inline ::int32_t ScanTestCfg::_internal_shapesize() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.shapesize_; +} +inline void ScanTestCfg::_internal_set_shapesize(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.shapesize_ = value; +} + +// int32 shapeSizeMin = 3; +inline void ScanTestCfg::clear_shapesizemin() { + _impl_.shapesizemin_ = 0; +} +inline ::int32_t ScanTestCfg::shapesizemin() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shapeSizeMin) + return _internal_shapesizemin(); +} +inline void ScanTestCfg::set_shapesizemin(::int32_t value) { + _internal_set_shapesizemin(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shapeSizeMin) +} +inline ::int32_t ScanTestCfg::_internal_shapesizemin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.shapesizemin_; +} +inline void ScanTestCfg::_internal_set_shapesizemin(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.shapesizemin_ = value; +} + +// int32 shape_size_max = 4; +inline void ScanTestCfg::clear_shape_size_max() { + _impl_.shape_size_max_ = 0; +} +inline ::int32_t ScanTestCfg::shape_size_max() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shape_size_max) + return _internal_shape_size_max(); +} +inline void ScanTestCfg::set_shape_size_max(::int32_t value) { + _internal_set_shape_size_max(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shape_size_max) +} +inline ::int32_t ScanTestCfg::_internal_shape_size_max() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.shape_size_max_; +} +inline void ScanTestCfg::_internal_set_shape_size_max(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.shape_size_max_ = value; +} + +// int32 laser_power = 5; +inline void ScanTestCfg::clear_laser_power() { + _impl_.laser_power_ = 0; +} +inline ::int32_t ScanTestCfg::laser_power() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power) + return _internal_laser_power(); +} +inline void ScanTestCfg::set_laser_power(::int32_t value) { + _internal_set_laser_power(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power) +} +inline ::int32_t ScanTestCfg::_internal_laser_power() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laser_power_; +} +inline void ScanTestCfg::_internal_set_laser_power(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laser_power_ = value; +} + +// int32 laser_power_min = 6; +inline void ScanTestCfg::clear_laser_power_min() { + _impl_.laser_power_min_ = 0; +} +inline ::int32_t ScanTestCfg::laser_power_min() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power_min) + return _internal_laser_power_min(); +} +inline void ScanTestCfg::set_laser_power_min(::int32_t value) { + _internal_set_laser_power_min(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power_min) +} +inline ::int32_t ScanTestCfg::_internal_laser_power_min() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laser_power_min_; +} +inline void ScanTestCfg::_internal_set_laser_power_min(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laser_power_min_ = value; +} + +// int32 laser_power_max = 7; +inline void ScanTestCfg::clear_laser_power_max() { + _impl_.laser_power_max_ = 0; +} +inline ::int32_t ScanTestCfg::laser_power_max() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power_max) + return _internal_laser_power_max(); +} +inline void ScanTestCfg::set_laser_power_max(::int32_t value) { + _internal_set_laser_power_max(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power_max) +} +inline ::int32_t ScanTestCfg::_internal_laser_power_max() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laser_power_max_; +} +inline void ScanTestCfg::_internal_set_laser_power_max(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laser_power_max_ = value; +} + +// double defocus = 8; +inline void ScanTestCfg::clear_defocus() { + _impl_.defocus_ = 0; +} +inline double ScanTestCfg::defocus() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus) + return _internal_defocus(); +} +inline void ScanTestCfg::set_defocus(double value) { + _internal_set_defocus(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus) +} +inline double ScanTestCfg::_internal_defocus() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocus_; +} +inline void ScanTestCfg::_internal_set_defocus(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocus_ = value; +} + +// double defocus_min = 9; +inline void ScanTestCfg::clear_defocus_min() { + _impl_.defocus_min_ = 0; +} +inline double ScanTestCfg::defocus_min() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus_min) + return _internal_defocus_min(); +} +inline void ScanTestCfg::set_defocus_min(double value) { + _internal_set_defocus_min(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus_min) +} +inline double ScanTestCfg::_internal_defocus_min() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocus_min_; +} +inline void ScanTestCfg::_internal_set_defocus_min(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocus_min_ = value; +} + +// double defocus_max = 10; +inline void ScanTestCfg::clear_defocus_max() { + _impl_.defocus_max_ = 0; +} +inline double ScanTestCfg::defocus_max() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus_max) + return _internal_defocus_max(); +} +inline void ScanTestCfg::set_defocus_max(double value) { + _internal_set_defocus_max(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus_max) +} +inline double ScanTestCfg::_internal_defocus_max() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.defocus_max_; +} +inline void ScanTestCfg::_internal_set_defocus_max(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.defocus_max_ = value; +} + +// bool is_cycle = 11; +inline void ScanTestCfg::clear_is_cycle() { + _impl_.is_cycle_ = false; +} +inline bool ScanTestCfg::is_cycle() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.is_cycle) + return _internal_is_cycle(); +} +inline void ScanTestCfg::set_is_cycle(bool value) { + _internal_set_is_cycle(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.is_cycle) +} +inline bool ScanTestCfg::_internal_is_cycle() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.is_cycle_; +} +inline void ScanTestCfg::_internal_set_is_cycle(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.is_cycle_ = value; +} + +// double cross_x = 12; +inline void ScanTestCfg::clear_cross_x() { + _impl_.cross_x_ = 0; +} +inline double ScanTestCfg::cross_x() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.cross_x) + return _internal_cross_x(); +} +inline void ScanTestCfg::set_cross_x(double value) { + _internal_set_cross_x(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.cross_x) +} +inline double ScanTestCfg::_internal_cross_x() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cross_x_; +} +inline void ScanTestCfg::_internal_set_cross_x(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cross_x_ = value; +} + +// double cross_y = 13; +inline void ScanTestCfg::clear_cross_y() { + _impl_.cross_y_ = 0; +} +inline double ScanTestCfg::cross_y() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.cross_y) + return _internal_cross_y(); +} +inline void ScanTestCfg::set_cross_y(double value) { + _internal_set_cross_y(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.cross_y) +} +inline double ScanTestCfg::_internal_cross_y() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cross_y_; +} +inline void ScanTestCfg::_internal_set_cross_y(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cross_y_ = value; +} + +// double z_distance = 14; +inline void ScanTestCfg::clear_z_distance() { + _impl_.z_distance_ = 0; +} +inline double ScanTestCfg::z_distance() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.z_distance) + return _internal_z_distance(); +} +inline void ScanTestCfg::set_z_distance(double value) { + _internal_set_z_distance(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.z_distance) +} +inline double ScanTestCfg::_internal_z_distance() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.z_distance_; +} +inline void ScanTestCfg::_internal_set_z_distance(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.z_distance_ = value; +} + +// bool isAutoHeatingScanner = 15; +inline void ScanTestCfg::clear_isautoheatingscanner() { + _impl_.isautoheatingscanner_ = false; +} +inline bool ScanTestCfg::isautoheatingscanner() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.isAutoHeatingScanner) + return _internal_isautoheatingscanner(); +} +inline void ScanTestCfg::set_isautoheatingscanner(bool value) { + _internal_set_isautoheatingscanner(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.isAutoHeatingScanner) +} +inline bool ScanTestCfg::_internal_isautoheatingscanner() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.isautoheatingscanner_; +} +inline void ScanTestCfg::_internal_set_isautoheatingscanner(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.isautoheatingscanner_ = value; +} + +// uint32 autoHeatingScannerMinutes = 16; +inline void ScanTestCfg::clear_autoheatingscannerminutes() { + _impl_.autoheatingscannerminutes_ = 0u; +} +inline ::uint32_t ScanTestCfg::autoheatingscannerminutes() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerMinutes) + return _internal_autoheatingscannerminutes(); +} +inline void ScanTestCfg::set_autoheatingscannerminutes(::uint32_t value) { + _internal_set_autoheatingscannerminutes(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerMinutes) +} +inline ::uint32_t ScanTestCfg::_internal_autoheatingscannerminutes() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.autoheatingscannerminutes_; +} +inline void ScanTestCfg::_internal_set_autoheatingscannerminutes(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.autoheatingscannerminutes_ = value; +} + +// uint32 autoHeatingScannerSize = 17; +inline void ScanTestCfg::clear_autoheatingscannersize() { + _impl_.autoheatingscannersize_ = 0u; +} +inline ::uint32_t ScanTestCfg::autoheatingscannersize() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerSize) + return _internal_autoheatingscannersize(); +} +inline void ScanTestCfg::set_autoheatingscannersize(::uint32_t value) { + _internal_set_autoheatingscannersize(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerSize) +} +inline ::uint32_t ScanTestCfg::_internal_autoheatingscannersize() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.autoheatingscannersize_; +} +inline void ScanTestCfg::_internal_set_autoheatingscannersize(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.autoheatingscannersize_ = value; +} + +// double autoHeatingScannerSpeed = 18; +inline void ScanTestCfg::clear_autoheatingscannerspeed() { + _impl_.autoheatingscannerspeed_ = 0; +} +inline double ScanTestCfg::autoheatingscannerspeed() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerSpeed) + return _internal_autoheatingscannerspeed(); +} +inline void ScanTestCfg::set_autoheatingscannerspeed(double value) { + _internal_set_autoheatingscannerspeed(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerSpeed) +} +inline double ScanTestCfg::_internal_autoheatingscannerspeed() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.autoheatingscannerspeed_; +} +inline void ScanTestCfg::_internal_set_autoheatingscannerspeed(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.autoheatingscannerspeed_ = value; +} + +// double mark_test_start_x = 19; +inline void ScanTestCfg::clear_mark_test_start_x() { + _impl_.mark_test_start_x_ = 0; +} +inline double ScanTestCfg::mark_test_start_x() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_start_x) + return _internal_mark_test_start_x(); +} +inline void ScanTestCfg::set_mark_test_start_x(double value) { + _internal_set_mark_test_start_x(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_start_x) +} +inline double ScanTestCfg::_internal_mark_test_start_x() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mark_test_start_x_; +} +inline void ScanTestCfg::_internal_set_mark_test_start_x(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mark_test_start_x_ = value; +} + +// double mark_test_start_y = 20; +inline void ScanTestCfg::clear_mark_test_start_y() { + _impl_.mark_test_start_y_ = 0; +} +inline double ScanTestCfg::mark_test_start_y() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_start_y) + return _internal_mark_test_start_y(); +} +inline void ScanTestCfg::set_mark_test_start_y(double value) { + _internal_set_mark_test_start_y(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_start_y) +} +inline double ScanTestCfg::_internal_mark_test_start_y() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mark_test_start_y_; +} +inline void ScanTestCfg::_internal_set_mark_test_start_y(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mark_test_start_y_ = value; +} + +// double mark_test_end_x = 21; +inline void ScanTestCfg::clear_mark_test_end_x() { + _impl_.mark_test_end_x_ = 0; +} +inline double ScanTestCfg::mark_test_end_x() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_end_x) + return _internal_mark_test_end_x(); +} +inline void ScanTestCfg::set_mark_test_end_x(double value) { + _internal_set_mark_test_end_x(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_end_x) +} +inline double ScanTestCfg::_internal_mark_test_end_x() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mark_test_end_x_; +} +inline void ScanTestCfg::_internal_set_mark_test_end_x(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mark_test_end_x_ = value; +} + +// double mark_test_end_y = 22; +inline void ScanTestCfg::clear_mark_test_end_y() { + _impl_.mark_test_end_y_ = 0; +} +inline double ScanTestCfg::mark_test_end_y() const { + // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_end_y) + return _internal_mark_test_end_y(); +} +inline void ScanTestCfg::set_mark_test_end_y(double value) { + _internal_set_mark_test_end_y(value); + // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_end_y) +} +inline double ScanTestCfg::_internal_mark_test_end_y() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mark_test_end_y_; +} +inline void ScanTestCfg::_internal_set_mark_test_end_y(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mark_test_end_y_ = value; +} + +// ------------------------------------------------------------------- + +// SkyWritingCfg + +// bool isEnable = 1; +inline void SkyWritingCfg::clear_isenable() { + _impl_.isenable_ = false; +} +inline bool SkyWritingCfg::isenable() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.isEnable) + return _internal_isenable(); +} +inline void SkyWritingCfg::set_isenable(bool value) { + _internal_set_isenable(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.isEnable) +} +inline bool SkyWritingCfg::_internal_isenable() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.isenable_; +} +inline void SkyWritingCfg::_internal_set_isenable(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.isenable_ = value; +} + +// double timelag = 2; +inline void SkyWritingCfg::clear_timelag() { + _impl_.timelag_ = 0; +} +inline double SkyWritingCfg::timelag() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelag) + return _internal_timelag(); +} +inline void SkyWritingCfg::set_timelag(double value) { + _internal_set_timelag(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelag) +} +inline double SkyWritingCfg::_internal_timelag() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.timelag_; +} +inline void SkyWritingCfg::_internal_set_timelag(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.timelag_ = value; +} + +// double timelagMin = 3; +inline void SkyWritingCfg::clear_timelagmin() { + _impl_.timelagmin_ = 0; +} +inline double SkyWritingCfg::timelagmin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelagMin) + return _internal_timelagmin(); +} +inline void SkyWritingCfg::set_timelagmin(double value) { + _internal_set_timelagmin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelagMin) +} +inline double SkyWritingCfg::_internal_timelagmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.timelagmin_; +} +inline void SkyWritingCfg::_internal_set_timelagmin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.timelagmin_ = value; +} + +// double timelagMax = 4; +inline void SkyWritingCfg::clear_timelagmax() { + _impl_.timelagmax_ = 0; +} +inline double SkyWritingCfg::timelagmax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelagMax) + return _internal_timelagmax(); +} +inline void SkyWritingCfg::set_timelagmax(double value) { + _internal_set_timelagmax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelagMax) +} +inline double SkyWritingCfg::_internal_timelagmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.timelagmax_; +} +inline void SkyWritingCfg::_internal_set_timelagmax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.timelagmax_ = value; +} + +// int64 laserOnShift = 5; +inline void SkyWritingCfg::clear_laseronshift() { + _impl_.laseronshift_ = ::int64_t{0}; +} +inline ::int64_t SkyWritingCfg::laseronshift() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShift) + return _internal_laseronshift(); +} +inline void SkyWritingCfg::set_laseronshift(::int64_t value) { + _internal_set_laseronshift(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShift) +} +inline ::int64_t SkyWritingCfg::_internal_laseronshift() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseronshift_; +} +inline void SkyWritingCfg::_internal_set_laseronshift(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseronshift_ = value; +} + +// int64 laserOnShiftMin = 6; +inline void SkyWritingCfg::clear_laseronshiftmin() { + _impl_.laseronshiftmin_ = ::int64_t{0}; +} +inline ::int64_t SkyWritingCfg::laseronshiftmin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShiftMin) + return _internal_laseronshiftmin(); +} +inline void SkyWritingCfg::set_laseronshiftmin(::int64_t value) { + _internal_set_laseronshiftmin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShiftMin) +} +inline ::int64_t SkyWritingCfg::_internal_laseronshiftmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseronshiftmin_; +} +inline void SkyWritingCfg::_internal_set_laseronshiftmin(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseronshiftmin_ = value; +} + +// int64 laserOnShiftMax = 7; +inline void SkyWritingCfg::clear_laseronshiftmax() { + _impl_.laseronshiftmax_ = ::int64_t{0}; +} +inline ::int64_t SkyWritingCfg::laseronshiftmax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShiftMax) + return _internal_laseronshiftmax(); +} +inline void SkyWritingCfg::set_laseronshiftmax(::int64_t value) { + _internal_set_laseronshiftmax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShiftMax) +} +inline ::int64_t SkyWritingCfg::_internal_laseronshiftmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.laseronshiftmax_; +} +inline void SkyWritingCfg::_internal_set_laseronshiftmax(::int64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.laseronshiftmax_ = value; +} + +// uint32 nprev = 8; +inline void SkyWritingCfg::clear_nprev() { + _impl_.nprev_ = 0u; +} +inline ::uint32_t SkyWritingCfg::nprev() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprev) + return _internal_nprev(); +} +inline void SkyWritingCfg::set_nprev(::uint32_t value) { + _internal_set_nprev(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprev) +} +inline ::uint32_t SkyWritingCfg::_internal_nprev() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.nprev_; +} +inline void SkyWritingCfg::_internal_set_nprev(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.nprev_ = value; +} + +// uint32 nprevMin = 9; +inline void SkyWritingCfg::clear_nprevmin() { + _impl_.nprevmin_ = 0u; +} +inline ::uint32_t SkyWritingCfg::nprevmin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprevMin) + return _internal_nprevmin(); +} +inline void SkyWritingCfg::set_nprevmin(::uint32_t value) { + _internal_set_nprevmin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprevMin) +} +inline ::uint32_t SkyWritingCfg::_internal_nprevmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.nprevmin_; +} +inline void SkyWritingCfg::_internal_set_nprevmin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.nprevmin_ = value; +} + +// uint32 nprevMax = 10; +inline void SkyWritingCfg::clear_nprevmax() { + _impl_.nprevmax_ = 0u; +} +inline ::uint32_t SkyWritingCfg::nprevmax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprevMax) + return _internal_nprevmax(); +} +inline void SkyWritingCfg::set_nprevmax(::uint32_t value) { + _internal_set_nprevmax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprevMax) +} +inline ::uint32_t SkyWritingCfg::_internal_nprevmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.nprevmax_; +} +inline void SkyWritingCfg::_internal_set_nprevmax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.nprevmax_ = value; +} + +// uint32 npost = 11; +inline void SkyWritingCfg::clear_npost() { + _impl_.npost_ = 0u; +} +inline ::uint32_t SkyWritingCfg::npost() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npost) + return _internal_npost(); +} +inline void SkyWritingCfg::set_npost(::uint32_t value) { + _internal_set_npost(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npost) +} +inline ::uint32_t SkyWritingCfg::_internal_npost() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.npost_; +} +inline void SkyWritingCfg::_internal_set_npost(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.npost_ = value; +} + +// uint32 npostMin = 12; +inline void SkyWritingCfg::clear_npostmin() { + _impl_.npostmin_ = 0u; +} +inline ::uint32_t SkyWritingCfg::npostmin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npostMin) + return _internal_npostmin(); +} +inline void SkyWritingCfg::set_npostmin(::uint32_t value) { + _internal_set_npostmin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npostMin) +} +inline ::uint32_t SkyWritingCfg::_internal_npostmin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.npostmin_; +} +inline void SkyWritingCfg::_internal_set_npostmin(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.npostmin_ = value; +} + +// uint32 npostMax = 13; +inline void SkyWritingCfg::clear_npostmax() { + _impl_.npostmax_ = 0u; +} +inline ::uint32_t SkyWritingCfg::npostmax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npostMax) + return _internal_npostmax(); +} +inline void SkyWritingCfg::set_npostmax(::uint32_t value) { + _internal_set_npostmax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npostMax) +} +inline ::uint32_t SkyWritingCfg::_internal_npostmax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.npostmax_; +} +inline void SkyWritingCfg::_internal_set_npostmax(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.npostmax_ = value; +} + +// int32 mode = 14; +inline void SkyWritingCfg::clear_mode() { + _impl_.mode_ = 0; +} +inline ::int32_t SkyWritingCfg::mode() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.mode) + return _internal_mode(); +} +inline void SkyWritingCfg::set_mode(::int32_t value) { + _internal_set_mode(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.mode) +} +inline ::int32_t SkyWritingCfg::_internal_mode() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.mode_; +} +inline void SkyWritingCfg::_internal_set_mode(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.mode_ = value; +} + +// double limite = 15; +inline void SkyWritingCfg::clear_limite() { + _impl_.limite_ = 0; +} +inline double SkyWritingCfg::limite() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limite) + return _internal_limite(); +} +inline void SkyWritingCfg::set_limite(double value) { + _internal_set_limite(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limite) +} +inline double SkyWritingCfg::_internal_limite() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.limite_; +} +inline void SkyWritingCfg::_internal_set_limite(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.limite_ = value; +} + +// double limiteMin = 16; +inline void SkyWritingCfg::clear_limitemin() { + _impl_.limitemin_ = 0; +} +inline double SkyWritingCfg::limitemin() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limiteMin) + return _internal_limitemin(); +} +inline void SkyWritingCfg::set_limitemin(double value) { + _internal_set_limitemin(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limiteMin) +} +inline double SkyWritingCfg::_internal_limitemin() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.limitemin_; +} +inline void SkyWritingCfg::_internal_set_limitemin(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.limitemin_ = value; +} + +// double limiteMax = 17; +inline void SkyWritingCfg::clear_limitemax() { + _impl_.limitemax_ = 0; +} +inline double SkyWritingCfg::limitemax() const { + // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limiteMax) + return _internal_limitemax(); +} +inline void SkyWritingCfg::set_limitemax(double value) { + _internal_set_limitemax(value); + // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limiteMax) +} +inline double SkyWritingCfg::_internal_limitemax() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.limitemax_; +} +inline void SkyWritingCfg::_internal_set_limitemax(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.limitemax_ = value; +} + +// ------------------------------------------------------------------- + +// PowerCompensate + +// int32 cno = 1; +inline void PowerCompensate::clear_cno() { + _impl_.cno_ = 0; +} +inline ::int32_t PowerCompensate::cno() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.cno) + return _internal_cno(); +} +inline void PowerCompensate::set_cno(::int32_t value) { + _internal_set_cno(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.cno) +} +inline ::int32_t PowerCompensate::_internal_cno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cno_; +} +inline void PowerCompensate::_internal_set_cno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cno_ = value; +} + +// int32 percent = 2; +inline void PowerCompensate::clear_percent() { + _impl_.percent_ = 0; +} +inline ::int32_t PowerCompensate::percent() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.percent) + return _internal_percent(); +} +inline void PowerCompensate::set_percent(::int32_t value) { + _internal_set_percent(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.percent) +} +inline ::int32_t PowerCompensate::_internal_percent() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.percent_; +} +inline void PowerCompensate::_internal_set_percent(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.percent_ = value; +} + +// float value = 3; +inline void PowerCompensate::clear_value() { + _impl_.value_ = 0; +} +inline float PowerCompensate::value() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.value) + return _internal_value(); +} +inline void PowerCompensate::set_value(float value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.value) +} +inline float PowerCompensate::_internal_value() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.value_; +} +inline void PowerCompensate::_internal_set_value(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.value_ = value; +} + +// float value_min = 4; +inline void PowerCompensate::clear_value_min() { + _impl_.value_min_ = 0; +} +inline float PowerCompensate::value_min() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.value_min) + return _internal_value_min(); +} +inline void PowerCompensate::set_value_min(float value) { + _internal_set_value_min(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.value_min) +} +inline float PowerCompensate::_internal_value_min() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.value_min_; +} +inline void PowerCompensate::_internal_set_value_min(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.value_min_ = value; +} + +// float value_max = 5; +inline void PowerCompensate::clear_value_max() { + _impl_.value_max_ = 0; +} +inline float PowerCompensate::value_max() const { + // @@protoc_insertion_point(field_get:stream.PowerCompensate.value_max) + return _internal_value_max(); +} +inline void PowerCompensate::set_value_max(float value) { + _internal_set_value_max(value); + // @@protoc_insertion_point(field_set:stream.PowerCompensate.value_max) +} +inline float PowerCompensate::_internal_value_max() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.value_max_; +} +inline void PowerCompensate::_internal_set_value_max(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.value_max_ = value; +} + +// ------------------------------------------------------------------- + +// TimePowerCompensate + +// int32 id = 1; +inline void TimePowerCompensate::clear_id() { + _impl_.id_ = 0; +} +inline ::int32_t TimePowerCompensate::id() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.id) + return _internal_id(); +} +inline void TimePowerCompensate::set_id(::int32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.id) +} +inline ::int32_t TimePowerCompensate::_internal_id() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.id_; +} +inline void TimePowerCompensate::_internal_set_id(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.id_ = value; +} + +// int32 cno = 2; +inline void TimePowerCompensate::clear_cno() { + _impl_.cno_ = 0; +} +inline ::int32_t TimePowerCompensate::cno() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.cno) + return _internal_cno(); +} +inline void TimePowerCompensate::set_cno(::int32_t value) { + _internal_set_cno(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.cno) +} +inline ::int32_t TimePowerCompensate::_internal_cno() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.cno_; +} +inline void TimePowerCompensate::_internal_set_cno(::int32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.cno_ = value; +} + +// uint32 startMinute = 3; +inline void TimePowerCompensate::clear_startminute() { + _impl_.startminute_ = 0u; +} +inline ::uint32_t TimePowerCompensate::startminute() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.startMinute) + return _internal_startminute(); +} +inline void TimePowerCompensate::set_startminute(::uint32_t value) { + _internal_set_startminute(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.startMinute) +} +inline ::uint32_t TimePowerCompensate::_internal_startminute() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.startminute_; +} +inline void TimePowerCompensate::_internal_set_startminute(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.startminute_ = value; +} + +// uint32 endMinute = 4; +inline void TimePowerCompensate::clear_endminute() { + _impl_.endminute_ = 0u; +} +inline ::uint32_t TimePowerCompensate::endminute() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.endMinute) + return _internal_endminute(); +} +inline void TimePowerCompensate::set_endminute(::uint32_t value) { + _internal_set_endminute(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.endMinute) +} +inline ::uint32_t TimePowerCompensate::_internal_endminute() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.endminute_; +} +inline void TimePowerCompensate::_internal_set_endminute(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.endminute_ = value; +} + +// float compensate = 5; +inline void TimePowerCompensate::clear_compensate() { + _impl_.compensate_ = 0; +} +inline float TimePowerCompensate::compensate() const { + // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.compensate) + return _internal_compensate(); +} +inline void TimePowerCompensate::set_compensate(float value) { + _internal_set_compensate(value); + // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.compensate) +} +inline float TimePowerCompensate::_internal_compensate() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.compensate_; +} +inline void TimePowerCompensate::_internal_set_compensate(float value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.compensate_ = value; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ diff --git a/TestClient/protobuf/stream.proto b/TestClient/protobuf/stream.proto index f9108a4..a1514b9 100644 --- a/TestClient/protobuf/stream.proto +++ b/TestClient/protobuf/stream.proto @@ -37,7 +37,7 @@ enum DATAHANDLE { message ParamInfo{ bytes nameKey = 1; //参数key - bytes strValue = 2; //value + bytes strValue = 2; //value TYPE valueType = 3; //数据类型 bytes context = 4; //alarmcfg 使用 @@ -48,6 +48,15 @@ message ParamInfo{ int32 startLayer = 8; //层供粉量配置使用 struct PowderSet int32 endLayer = 9; float powder = 10; + + int32 seqNo = 11; //ScannerControlCfg使用 + int32 controlNo = 12; + int32 serialNo = 13; + int32 controlType = 14; + bytes cardName = 15; + bytes cardIP = 16; + bool hadAssign = 17; + bool hadMatch = 18; //isEnable公用 } message RequestInfo { //读 @@ -135,6 +144,168 @@ message ComResponce{ bytes data = 1; } +//ScannerCrtlCfg结构体 +message ScannerCrtlCfgResp{ + repeated ScannerCrtlCfgData scannerCfg = 1; +} + +message ScannerCrtlCfgData{ + int32 seqNo = 1; + repeated FixPointData fixPointData = 2; + ScanParamCfg scanParamCfg = 3; + ScanParamCfg hatchingParams = 4; + ScanParamCfg borderParams = 5; + ScanParamCfg supportParams = 6; + CorrectParamCfg correctParamCfg = 7; + ScanTestCfg scanTestCfg = 8; + SkyWritingCfg skyWritingCfg = 9; + repeated PowerCompensate powerCompensate = 10; + repeated TimePowerCompensate tPowerCompensate = 11; + + int32 controlNo = 12; + int32 serialNo = 13; + int32 controlType = 14; + bytes cardName = 15; + bytes cardIP = 16; + bool isEnable = 17; //是否启动 + bool hadAssign = 18; + bool hadMatch = 19; +} + +message FixPointData{ + int32 id = 1; + int32 cno = 2; + float pointX = 3; + float pointY = 4; + uint32 duration = 5; +} + + + +message ScanParamCfg{ + int32 edgeLevel = 1; + int32 edgeLevelMin = 2; + int32 edgeLevelMax = 3; + uint32 jumpDelay = 4; + uint32 jumpDelayMin = 5; + uint32 jumpDelayMax = 6; + uint32 scanDelay = 7; + uint32 scanDelayMin = 8; + uint32 scanDelayMax = 9; + uint32 polygonDelay = 10; + uint32 polygonDelayMin = 11; + uint32 polygonDelayMax = 12; + int64 laseroffDelay = 13; + int64 laseroffDelayMin = 14; + int64 laseroffDelayMax = 15; + int64 laseronDelay = 16; + int64 laseronDelayMin = 17; + int64 laseronDelayMax = 18; + uint32 minJumpDelay = 19; + uint32 minJumpDelayMin = 20; + uint32 minJumpDelayMax = 21; + uint32 jumpLengthLimit = 22; + uint32 jumpLengthLimitMin = 23; + uint32 jumpLengthLimitMax = 24; + double jumpSpeed = 25; + double jumpSpeedMin = 26; + double jumpSpeedMax = 27; + double markSpeed = 28; + double markSpeedMin = 29; + double markSpeedMax = 30; +} + +message CorrectParamCfg{ + double xmeasureMin = 1; //x可打印最小位置 + double xmeasureMax = 2; //x可打印最大位置 + double ymeasureMin = 3; //y可打印最小位置 + double ymeasureMax = 4; //y可打印最大位置 + double xposfix = 5; //x位置修正 + double yposfix = 6; //y位置修正 + double scanAngle = 7; //旋转角度 逆时针 + double scanAngleMin = 8; + double scanAngleMax = 9; + double fixAngle = 10; //旋转角度 逆时针 + double fixAngleMin = 11; + double fixAngleMax = 12; + double xcorrect = 13; //x尺寸修正 + double ycorrect = 14; //y尺寸修正 + double xcorrectMin = 15; + double xcorrectMax = 16; + double ycorrectMin = 17; + double ycorrectMax = 18; + double realXOffset = 19; + double realYOffset = 20; + double factorK = 21; + bool isCorrectFile3D = 22; + bool isDynamicFocus = 23; //是否动态聚焦 + double defocusRatio = 24; //离焦比 + double defocusRatioMin = 25; + double defocusRatioMax = 26; +} + +message ScanTestCfg{ + int32 debugShape = 1; + int32 shapeSize = 2; + int32 shapeSizeMin = 3; + int32 shape_size_max = 4; + int32 laser_power = 5; + int32 laser_power_min = 6; + int32 laser_power_max = 7; + double defocus = 8; + double defocus_min = 9; + double defocus_max = 10; + bool is_cycle = 11; + double cross_x = 12; + double cross_y = 13; + double z_distance = 14; + bool isAutoHeatingScanner = 15; //开启暂停开始时预热振镜 + uint32 autoHeatingScannerMinutes = 16; + uint32 autoHeatingScannerSize = 17; + double autoHeatingScannerSpeed = 18; + double mark_test_start_x = 19; + double mark_test_start_y = 20; + double mark_test_end_x = 21; + double mark_test_end_y = 22; +} + +message SkyWritingCfg{ + bool isEnable = 1; + double timelag = 2; + double timelagMin = 3; + double timelagMax = 4; + int64 laserOnShift = 5; + int64 laserOnShiftMin = 6; + int64 laserOnShiftMax = 7; + uint32 nprev = 8; + uint32 nprevMin =9; + uint32 nprevMax = 10; + uint32 npost = 11; + uint32 npostMin = 12; + uint32 npostMax = 13; + int32 mode = 14; + double limite = 15; + double limiteMin = 16; + double limiteMax = 17; +} + + +message PowerCompensate{ + int32 cno = 1; + int32 percent = 2; + float value = 3; + float value_min = 4; + float value_max = 5; +} + +message TimePowerCompensate{ + int32 id = 1; + int32 cno = 2; + uint32 startMinute = 3; + uint32 endMinute = 4; + float compensate = 5; +} + service Stream { rpc Simple(RequestInfo) returns (ResponseAny) {} // 简单模式 rpc ServerStream (RequestInfo) returns (stream ResponseInfo) {} // 服务端数据流模式