2119 lines
62 KiB
C++
2119 lines
62 KiB
C++
#include "XmlSerialization.h"
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include "PathUtil.h"
|
|
#include <QFile>
|
|
|
|
//XmlSerialization *XmlSerialization::m_pXmlSerialization = nullptr;
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
std::string XmlSerialization::saveSerializationXMLFile(QString xmlfile_path)
|
|
{
|
|
// std::ofstream ofs(xmlfile_path);
|
|
// ::xml_schema::namespace_infomap ns_map;
|
|
// ns_map[""].name = "http://tempuri.org/ModelDS.xsd";
|
|
|
|
// // 使用全局命名空间下的 flags
|
|
// model_ds::ModelDS_(ofs, m_ModelDS, ns_map, "UTF-8", ::xml_schema::flags::keep_dom); // format_pretty);
|
|
|
|
// xercesc::XMLPlatformUtils::Terminate();
|
|
|
|
|
|
|
|
|
|
xercesc::XMLPlatformUtils::Initialize();
|
|
|
|
std::ostringstream ofs;
|
|
::xml_schema::namespace_infomap ns_map;
|
|
ns_map[""].name = "http://tempuri.org/ModelDS.xsd";
|
|
|
|
// 使用全局命名空间下的 flags
|
|
model_ds::ModelDS_(ofs, *m_ModelDS, ns_map, "UTF-8", ::xml_schema::flags::no_xml_declaration); // format_pretty);
|
|
|
|
|
|
QFile file(xmlfile_path);
|
|
|
|
// 检查文件是否成功打开
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
|
|
qCritical() << "Failed to open file for writing:" << file.errorString();
|
|
throw std::runtime_error("Failed to open file for writing.");
|
|
}
|
|
|
|
QString content = QString::fromStdString(ofs.str());
|
|
// 使用QTextStream将内容写入文件
|
|
QTextStream out(&file);
|
|
out << content;
|
|
|
|
// 关闭文件
|
|
file.close();
|
|
|
|
|
|
|
|
xercesc::XMLPlatformUtils::Terminate();
|
|
|
|
|
|
|
|
return ofs.str();
|
|
}
|
|
|
|
void XmlSerialization::loadStabModelDS(const std::string& xml_str)
|
|
{
|
|
if (xml_str.empty())
|
|
{
|
|
return;
|
|
}
|
|
xercesc::XMLPlatformUtils::Initialize();
|
|
|
|
::xml_schema::properties props;
|
|
|
|
try
|
|
{
|
|
ModelDSClear();
|
|
// 从文件解析
|
|
// auto store = model_ds::ModelDS_("output.xml", ::xml_schema::flags::dont_validate, props);
|
|
// 从字符串流解析
|
|
std::istringstream iss(xml_str);
|
|
|
|
|
|
|
|
//std::ofstream ofsFile("D:/COMPASS-I-F/trunk/doc/calcData/12.Stab");
|
|
|
|
// 检查文件是否成功打开
|
|
//if (!ofsFile.is_open()) {
|
|
// throw std::runtime_error("Failed to open file for writing.");
|
|
// }
|
|
|
|
// 将ostringstream 的内容写入文件
|
|
//ofsFile << iss.str();
|
|
|
|
// 关闭文件
|
|
// ofsFile.close();
|
|
|
|
|
|
|
|
// string path = "D:/COMPASS-I-F/trunk/doc/calcData/11.Stab";
|
|
m_ModelDS = model_ds::ModelDS_(iss, ::xml_schema::flags::dont_validate, props);
|
|
|
|
int a = 0;
|
|
}
|
|
catch (const xsd::cxx::tree::error<char>& e)
|
|
{
|
|
std::cerr << "错误行号: " << e.line() << std::endl; // 注意是 line() 不是 line
|
|
}
|
|
|
|
xercesc::XMLPlatformUtils::Terminate();
|
|
}
|
|
|
|
BInf_Table* XmlSerialization::getBInf_table()
|
|
{
|
|
return &m_ModelDS->BInf();
|
|
}
|
|
|
|
Shell_Table* XmlSerialization::getShell_table()
|
|
{
|
|
return &m_ModelDS->Shell();
|
|
}
|
|
FloodPoint_Table* XmlSerialization::getFloodPoint_table()
|
|
{
|
|
return &m_ModelDS->FloodPoint();
|
|
}
|
|
LimitStaticPoint_Table* XmlSerialization::getLimitStaticPoint_table()
|
|
{
|
|
return &m_ModelDS->LimitStaticPoint();
|
|
}
|
|
ImmersionPoint_Table* XmlSerialization::getImmersionPoint_table()
|
|
{
|
|
return &m_ModelDS->ImmersionPoint();
|
|
}
|
|
Deckline_Table* XmlSerialization::getDeckline_table()
|
|
{
|
|
return &m_ModelDS->Deckline();
|
|
}
|
|
Compartment_Table* XmlSerialization::getCompartment_table()
|
|
{
|
|
return &m_ModelDS->Compartment();
|
|
}
|
|
LWT_Table* XmlSerialization::getLwt_table()
|
|
{
|
|
return &m_ModelDS->LWT();
|
|
}
|
|
PartialLoad_Table* XmlSerialization::getPartialLoad_table()
|
|
{
|
|
return &m_ModelDS->PartialLoad();
|
|
}
|
|
PartialLoadWeight_Table* XmlSerialization::getPartialLoadWeight_table()
|
|
{
|
|
return &m_ModelDS->PartialLoadWeight();
|
|
}
|
|
PartialLoadFreeSurf_Table* XmlSerialization::getPartialLoadFreeSurf_table()
|
|
{
|
|
return &m_ModelDS->PartialLoadFreeSurf();
|
|
}
|
|
PartialLoadBulk_Table* XmlSerialization::getPartialLoadBulk_table()
|
|
{
|
|
return &m_ModelDS->PartialLoadBulk();
|
|
}
|
|
PartialLoadPerson_Table* XmlSerialization::getPartialLoadPerson_table()
|
|
{
|
|
return &m_ModelDS->PartialLoadPerson();
|
|
}
|
|
PartialLoadIce_Table* XmlSerialization::getPartialLoadIce_table()
|
|
{
|
|
return &m_ModelDS->PartialLoadIce();
|
|
}
|
|
WindFixed_Table* XmlSerialization::getWindFixed_table()
|
|
{
|
|
return &m_ModelDS->WindFixed();
|
|
}
|
|
WindNonFixed_Table* XmlSerialization::getWindNonFixed_table()
|
|
{
|
|
return &m_ModelDS->WindNonFixed();
|
|
}
|
|
Case_Table* XmlSerialization::getCase_table()
|
|
{
|
|
return &m_ModelDS->Case();
|
|
}
|
|
AllowNM_Table* XmlSerialization::getAllowNM_table()
|
|
{
|
|
return &m_ModelDS->AllowNM();
|
|
}
|
|
DamCase_Table* XmlSerialization::getDamCase_table()
|
|
{
|
|
return &m_ModelDS->DamCase();
|
|
}
|
|
DamCompartment_Table* XmlSerialization::getDamCompartment_table()
|
|
{
|
|
return &m_ModelDS->DamCompartment();
|
|
}
|
|
DamCaseProb_Table* XmlSerialization::getDamCaseProb_table()
|
|
{
|
|
return &m_ModelDS->DamCaseProb();
|
|
}
|
|
DamRegion_Table* XmlSerialization::getDamRegion_table()
|
|
{
|
|
return &m_ModelDS->DamRegion();
|
|
}
|
|
CompExtent_Table* XmlSerialization::getCompExtent_table()
|
|
{
|
|
return &m_ModelDS->CompExtent();
|
|
}
|
|
DamCompartmentProb_Table* XmlSerialization::getDamCompartmentProb_table()
|
|
{
|
|
return &m_ModelDS->DamCompartmentProb();
|
|
}
|
|
IncliningDraft_Table* XmlSerialization::getIncliningDraft_table()
|
|
{
|
|
return &m_ModelDS->IncliningDraft();
|
|
}
|
|
IncliningStatus_Table* XmlSerialization::getIncliningStatus_table()
|
|
{
|
|
return &m_ModelDS->IncliningStatus();
|
|
}
|
|
IncliningExtraWeight_Table* XmlSerialization::getIncliningExtraWeight_table()
|
|
{
|
|
return &m_ModelDS->IncliningExtraWeight();
|
|
}
|
|
IncliningRelocateWeight_Table* XmlSerialization::getIncliningRelocateWeight_table()
|
|
{
|
|
return &m_ModelDS->IncliningRelocateWeight();
|
|
}
|
|
IncliningAbsentWeight_Table* XmlSerialization::getIncliningAbsentWeight_table()
|
|
{
|
|
return &m_ModelDS->IncliningAbsentWeight();
|
|
}
|
|
IncliningTank_Table* XmlSerialization::getIncliningTank_table()
|
|
{
|
|
return &m_ModelDS->IncliningTank();
|
|
}
|
|
IncliningMobileWeight_Table* XmlSerialization::getIncliningMobileWeight_table()
|
|
{
|
|
return &m_ModelDS->IncliningMobileWeight();
|
|
}
|
|
IncliningDevice_Table* XmlSerialization::getIncliningDevice_table()
|
|
{
|
|
return &m_ModelDS->IncliningDevice();
|
|
}
|
|
IncliningCase_Table* XmlSerialization::getIncliningCase_table()
|
|
{
|
|
return &m_ModelDS->IncliningCase();
|
|
}
|
|
IncliningRecord_Table* XmlSerialization::getIncliningRecord_table()
|
|
{
|
|
return &m_ModelDS->IncliningRecord();
|
|
}
|
|
|
|
|
|
// 插入一行到 BInf 表
|
|
void XmlSerialization::BInf_insertRow(BInf_Row& data)
|
|
{
|
|
m_ModelDS->BInf().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 Shell 表
|
|
void XmlSerialization::Shell_insertRow(Shell_Row& data)
|
|
{
|
|
m_ModelDS->Shell().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 FloodPoint 表
|
|
void XmlSerialization::FloodPoint_insertRow(FloodPoint_Row& data)
|
|
{
|
|
m_ModelDS->FloodPoint().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 LimitStaticPoint 表
|
|
void XmlSerialization::LimitStaticPoint_insertRow(LimitStaticPoint_Row& data)
|
|
{
|
|
m_ModelDS->LimitStaticPoint().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 ImmersionPoint 表
|
|
void XmlSerialization::ImmersionPoint_insertRow(ImmersionPoint_Row& data)
|
|
{
|
|
m_ModelDS->ImmersionPoint().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 Deckline 表
|
|
void XmlSerialization::Deckline_insertRow(Deckline_Row& data)
|
|
{
|
|
m_ModelDS->Deckline().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 Compartment 表
|
|
void XmlSerialization::Compartment_insertRow(Compartment_Row& data)
|
|
{
|
|
m_ModelDS->Compartment().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 LWT 表
|
|
void XmlSerialization::LWT_insertRow(LWT_Row& data)
|
|
{
|
|
m_ModelDS->LWT().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 PartialLoad 表
|
|
void XmlSerialization::PartialLoad_insertRow(PartialLoad_Row& data)
|
|
{
|
|
m_ModelDS->PartialLoad().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 PartialLoadWeight 表
|
|
void XmlSerialization::PartialLoadWeight_insertRow(PartialLoadWeight_Row& data)
|
|
{
|
|
m_ModelDS->PartialLoadWeight().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 PartialLoadFreeSurf 表
|
|
void XmlSerialization::PartialLoadFreeSurf_insertRow(PartialLoadFreeSurf_Row& data)
|
|
{
|
|
m_ModelDS->PartialLoadFreeSurf().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 PartialLoadBulk 表
|
|
void XmlSerialization::PartialLoadBulk_insertRow(PartialLoadBulk_Row& data)
|
|
{
|
|
m_ModelDS->PartialLoadBulk().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 PartialLoadPerson 表
|
|
void XmlSerialization::PartialLoadPerson_insertRow(PartialLoadPerson_Row& data)
|
|
{
|
|
m_ModelDS->PartialLoadPerson().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 PartialLoadIce 表
|
|
void XmlSerialization::PartialLoadIce_insertRow(PartialLoadIce_Row& data)
|
|
{
|
|
m_ModelDS->PartialLoadIce().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 WindFixed 表
|
|
void XmlSerialization::WindFixed_insertRow(WindFixed_Row& data)
|
|
{
|
|
m_ModelDS->WindFixed().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 WindNonFixed 表
|
|
void XmlSerialization::WindNonFixed_insertRow(WindNonFixed_Row& data)
|
|
{
|
|
m_ModelDS->WindNonFixed().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 Case 表
|
|
void XmlSerialization::Case_insertRow(Case_Row& data)
|
|
{
|
|
m_ModelDS->Case().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 AllowNM 表
|
|
void XmlSerialization::AllowNM_insertRow(AllowNM_Row& data)
|
|
{
|
|
m_ModelDS->AllowNM().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 DamCase 表
|
|
void XmlSerialization::DamCase_insertRow(DamCase_Row& data)
|
|
{
|
|
m_ModelDS->DamCase().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 DamCompartment 表
|
|
void XmlSerialization::DamCompartment_insertRow(DamCompartment_Row& data)
|
|
{
|
|
m_ModelDS->DamCompartment().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 DamCaseProb 表
|
|
void XmlSerialization::DamCaseProb_insertRow(DamCaseProb_Row& data)
|
|
{
|
|
m_ModelDS->DamCaseProb().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 DamRegion 表
|
|
void XmlSerialization::DamRegion_insertRow(DamRegion_Row& data)
|
|
{
|
|
m_ModelDS->DamRegion().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 CompExtent 表
|
|
void XmlSerialization::CompExtent_insertRow(CompExtent_Row& data)
|
|
{
|
|
m_ModelDS->CompExtent().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 DamCompartmentProb 表
|
|
void XmlSerialization::DamCompartmentProb_insertRow(DamCompartmentProb_Row& data)
|
|
{
|
|
m_ModelDS->DamCompartmentProb().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningDraft 表
|
|
void XmlSerialization::IncliningDraft_insertRow(IncliningDraft_Row& data)
|
|
{
|
|
m_ModelDS->IncliningDraft().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningStatus 表
|
|
void XmlSerialization::IncliningStatus_insertRow(IncliningStatus_Row& data)
|
|
{
|
|
m_ModelDS->IncliningStatus().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningExtraWeight 表
|
|
void XmlSerialization::IncliningExtraWeight_insertRow(IncliningExtraWeight_Row& data)
|
|
{
|
|
m_ModelDS->IncliningExtraWeight().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningRelocateWeight 表
|
|
void XmlSerialization::IncliningRelocateWeight_insertRow(IncliningRelocateWeight_Row& data)
|
|
{
|
|
m_ModelDS->IncliningRelocateWeight().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningAbsentWeight 表
|
|
void XmlSerialization::IncliningAbsentWeight_insertRow(IncliningAbsentWeight_Row& data)
|
|
{
|
|
m_ModelDS->IncliningAbsentWeight().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningTank 表
|
|
void XmlSerialization::IncliningTank_insertRow(IncliningTank_Row& data)
|
|
{
|
|
m_ModelDS->IncliningTank().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningMobileWeight 表
|
|
void XmlSerialization::IncliningMobileWeight_insertRow(IncliningMobileWeight_Row& data)
|
|
{
|
|
m_ModelDS->IncliningMobileWeight().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningDevice 表
|
|
void XmlSerialization::IncliningDevice_insertRow(IncliningDevice_Row& data)
|
|
{
|
|
m_ModelDS->IncliningDevice().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningCase 表
|
|
void XmlSerialization::IncliningCase_insertRow(IncliningCase_Row& data)
|
|
{
|
|
m_ModelDS->IncliningCase().push_back(data);
|
|
}
|
|
|
|
// 插入一行到 IncliningRecord 表
|
|
void XmlSerialization::IncliningRecord_insertRow(IncliningRecord_Row& data)
|
|
{
|
|
m_ModelDS->IncliningRecord().push_back(data);
|
|
}
|
|
|
|
|
|
void XmlSerialization::ModelDSClear()
|
|
{
|
|
BInfTableClear();
|
|
|
|
ShellTableClear();
|
|
|
|
FloodPointTableClear();
|
|
|
|
LimitStaticPointTableClear();
|
|
|
|
ImmersionPointTableClear();
|
|
|
|
DecklineTableClear();
|
|
|
|
CompartmentTableClear();
|
|
|
|
LwtTableClear();
|
|
|
|
PartialLoadTableClear();
|
|
|
|
PartialLoadWeightTableClear();
|
|
|
|
PartialLoadFreeSurfTableClear();
|
|
|
|
PartialLoadBulkTableClear();
|
|
|
|
PartialLoadPersonTableClear();
|
|
|
|
PartialLoadIceTableClear();
|
|
|
|
WindFixedTableClear();
|
|
|
|
WindNonFixedTableClear();
|
|
|
|
CaseTableClear();
|
|
|
|
AllowNMTableClear();
|
|
|
|
DamCaseTableClear();
|
|
|
|
DamCompartmentTableClear();
|
|
|
|
DamCaseProbTableClear();
|
|
|
|
DamRegionTableClear();
|
|
|
|
CompExtentTableClear();
|
|
|
|
DamCompartmentProbTableClear();
|
|
|
|
IncliningDraftTableClear();
|
|
|
|
IncliningStatusTableClear();
|
|
|
|
IncliningExtraWeightTableClear();
|
|
|
|
IncliningRelocateWeightTableClear();
|
|
|
|
IncliningAbsentWeightTableClear();
|
|
|
|
IncliningTankTableClear();
|
|
|
|
IncliningMobileWeightTableClear();
|
|
|
|
IncliningDeviceTableClear();
|
|
|
|
IncliningCaseTableClear();
|
|
|
|
IncliningRecordTableClear();
|
|
}
|
|
|
|
void XmlSerialization::BInfTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->BInf().clear();
|
|
|
|
}
|
|
|
|
void XmlSerialization::ShellTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->Shell().clear();
|
|
}
|
|
|
|
void XmlSerialization::FloodPointTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->FloodPoint().clear();
|
|
}
|
|
|
|
void XmlSerialization::LimitStaticPointTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->LimitStaticPoint().clear();
|
|
}
|
|
|
|
void XmlSerialization::ImmersionPointTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->ImmersionPoint().clear();
|
|
}
|
|
|
|
void XmlSerialization::DecklineTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->Deckline().clear();
|
|
}
|
|
|
|
void XmlSerialization::CompartmentTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->Compartment().clear();
|
|
}
|
|
|
|
void XmlSerialization::LwtTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->LWT().clear();
|
|
}
|
|
|
|
void XmlSerialization::PartialLoadTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->PartialLoad().clear();
|
|
}
|
|
|
|
void XmlSerialization::PartialLoadWeightTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->PartialLoadWeight().clear();
|
|
}
|
|
|
|
void XmlSerialization::PartialLoadFreeSurfTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->PartialLoadFreeSurf().clear();
|
|
}
|
|
|
|
void XmlSerialization::PartialLoadBulkTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->PartialLoadBulk().clear();
|
|
}
|
|
|
|
void XmlSerialization::PartialLoadPersonTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->PartialLoadPerson().clear();
|
|
}
|
|
|
|
void XmlSerialization::PartialLoadIceTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->PartialLoadIce().clear();
|
|
}
|
|
|
|
void XmlSerialization::WindFixedTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->WindFixed().clear();
|
|
}
|
|
|
|
void XmlSerialization::WindNonFixedTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->WindNonFixed().clear();
|
|
}
|
|
|
|
void XmlSerialization::CaseTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->Case().clear();
|
|
}
|
|
|
|
void XmlSerialization::AllowNMTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->AllowNM().clear();
|
|
}
|
|
|
|
void XmlSerialization::DamCaseTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->DamCase().clear();
|
|
}
|
|
|
|
void XmlSerialization::DamCompartmentTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->DamCompartment().clear();
|
|
}
|
|
|
|
void XmlSerialization::DamCaseProbTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->DamCaseProb().clear();
|
|
}
|
|
|
|
void XmlSerialization::DamRegionTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->DamRegion().clear();
|
|
}
|
|
|
|
void XmlSerialization::CompExtentTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->CompExtent().clear();
|
|
}
|
|
|
|
void XmlSerialization::DamCompartmentProbTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->DamCompartmentProb().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningDraftTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningDraft().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningStatusTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningStatus().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningExtraWeightTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningExtraWeight().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningRelocateWeightTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningRelocateWeight().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningAbsentWeightTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningAbsentWeight().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningTankTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningTank().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningMobileWeightTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningMobileWeight().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningDeviceTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningDevice().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningCaseTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningCase().clear();
|
|
}
|
|
|
|
void XmlSerialization::IncliningRecordTableClear()
|
|
{
|
|
if (!m_ModelDS)
|
|
{
|
|
return;
|
|
}
|
|
m_ModelDS->IncliningRecord().clear();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void XmlSerialization::getStationLabelTableData(vector<StationLabel>& data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
for (const auto& item : m_ModelDS->StationLabel())
|
|
{
|
|
StationLabel obj;
|
|
obj.id = item.ID();
|
|
obj.pos = item.Pos().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
|
|
void XmlSerialization::getWaterlineLabelTableData(vector<WaterlineLabel>& data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
for (const auto& item : m_ModelDS->WaterlineLabel())
|
|
{
|
|
WaterlineLabel obj;
|
|
obj.id = item.ID();
|
|
obj.pos = item.Pos().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getButtocklineLabelTableData(vector<ButtocklineLabel>& data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
for (const auto& item : m_ModelDS->ButtocklineLabel())
|
|
{
|
|
ButtocklineLabel obj;
|
|
obj.id = item.ID();
|
|
obj.pos = item.Pos().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
|
|
void XmlSerialization::getXLabelTableData(vector<XLabel>& data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
for (const auto& item : m_ModelDS->XLabel())
|
|
{
|
|
XLabel obj;
|
|
obj.id = item.ID();
|
|
obj.x = item.X().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
void XmlSerialization::getBInfTableData(vector<BInf> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->BInf())
|
|
{
|
|
BInf obj;
|
|
obj.paramid = item.ParamID();
|
|
obj.unit = item.Unit().get();
|
|
obj.caption = item.Caption().get();
|
|
obj.value_type = item.ValueType().get();
|
|
obj.value = item.Value().get();
|
|
obj.remark = item.Remark().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getShellTableData(vector<Shell> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->Shell())
|
|
{
|
|
Shell obj;
|
|
obj.id = item.ID();
|
|
obj.shell_id = item.ShellID();
|
|
obj.type = item.Type().get();
|
|
obj.shell_affect = item.ShellAffect().get();
|
|
obj.affect_coef = item.AffectCoef().get();
|
|
obj.remark = item.Remark().get();
|
|
obj.sid = item.SID().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getFloodPointTableData(vector<FloodPoint> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->FloodPoint())
|
|
{
|
|
FloodPoint obj;
|
|
obj.id = item.ID();
|
|
obj.xsymbol = item.Xsymbol().get();
|
|
obj.x = item.X().get();
|
|
obj.y = item.Y().get();
|
|
obj.z = item.Z().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getLimitStaticPointTableData(vector<LimitStaticPoint> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->LimitStaticPoint())
|
|
{
|
|
LimitStaticPoint obj;
|
|
obj.id = item.ID();
|
|
obj.xsymbol = item.Xsymbol().get();
|
|
obj.x1 = item.X1().get();
|
|
obj.y1 = item.Y1().get();
|
|
obj.z1 = item.Z1().get();
|
|
obj.x2 = item.X2().get();
|
|
obj.y2 = std::isnan(item.Y2().get()) ? 0 : item.Y2().get();
|
|
obj.z2 = std::isnan(item.Z2().get()) ? 0 : item.Y2().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getImmersionPointTableData(vector<ImmersionPoint> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->ImmersionPoint())
|
|
{
|
|
ImmersionPoint obj;
|
|
obj.id = item.ID();
|
|
obj.xsymbol = item.Xsymbol().get();
|
|
obj.x = item.X().get();
|
|
obj.y = item.Y().get();
|
|
obj.z = item.Z().get();
|
|
obj.compartment = item.Compartment().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getDecklineTableData(vector<Deckline> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->Deckline())
|
|
{
|
|
Deckline obj;
|
|
obj.id = item.ID();
|
|
obj.xsymbol = item.Xsymbol().get();
|
|
obj.x = item.X().get();
|
|
obj.y = item.Y().get();
|
|
obj.z = item.Z().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getCompartmentTableData(vector<Compartment> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->Compartment())
|
|
{
|
|
Compartment obj;
|
|
obj.id = item.ID();
|
|
obj.space_id = item.SpaceID().get();
|
|
obj.flood_points = item.FloodPoints().get();
|
|
obj.type = item.Type().get();
|
|
obj.coef = item.Coef().get();
|
|
obj.permeability = item.Permeability().get();
|
|
obj.density = item.Density().get();
|
|
obj.remark = item.Remark().get();
|
|
obj.sid = item.SID().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getLwtTableData(vector<LWT> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->LWT())
|
|
{
|
|
LWT obj;
|
|
obj.id = item.ID();
|
|
obj.type = item.Type().get();
|
|
obj.g = item.G().get();
|
|
obj.xg_symbol = item.Xg_symbol().get();
|
|
obj.xg = item.Xg().get();
|
|
obj.yg = item.Yg().get();
|
|
obj.zg = item.Zg().get();
|
|
obj.xa_symbol = item.Xa_symbol().get();
|
|
obj.xf_symbol = item.Xf_symbol().get();
|
|
obj.xa = item.Xa().get();
|
|
obj.xf = item.Xf().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getPartialLoadTableData(vector<PartialLoad> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->PartialLoad())
|
|
{
|
|
PartialLoad obj;
|
|
obj.id = item.ID();
|
|
obj.remark = item.Remark().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getPartialLoadWeightTableData(vector<PartialLoadWeight> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->PartialLoadWeight())
|
|
{
|
|
PartialLoadWeight obj;
|
|
obj.partial_load_id = item.PartialLoadID();
|
|
obj.id = item.ID();
|
|
obj.wt_type = item.WtType().get();
|
|
obj.compartment = item.Compartment().get();
|
|
|
|
obj.compartment_type = item.CompartType().get()== -842150451 ? 0 : item.CompartType().get();
|
|
obj.free_surf_type = item.FreeSurfType().get()== -842150451 ? 0 : item.FreeSurfType().get();
|
|
obj.g = item.G().get();
|
|
obj.ratio = item.Ratio().get();
|
|
obj.density = item.Density().get();
|
|
obj.xg_symbol = item.Xg_symbol().get();
|
|
obj.xg = item.Xg().get();
|
|
obj.yg = item.Yg().get();
|
|
obj.zg = item.Zg().get();
|
|
obj.xa_symbol = item.Xa_symbol().get();
|
|
obj.xf_symbol = item.Xf_symbol().get();
|
|
obj.xa = item.Xa().get();
|
|
obj.xf = item.Xf().get();
|
|
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getPartialLoadFreeSurfTableData(vector<PartialLoadFreeSurf> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->PartialLoadFreeSurf())
|
|
{
|
|
PartialLoadFreeSurf obj;
|
|
obj.partial_load_id = item.PartialLoadID();
|
|
obj.id = item.ID();
|
|
obj.freesurftype = item.FreeSurfType().get();
|
|
obj.compartment = item.Compartment().get();
|
|
obj.g = item.G().get();
|
|
obj.ratio = item.Ratio().get();
|
|
obj.density = item.Density().get();
|
|
obj.v = item.V().get();
|
|
obj.l = item.l().get();
|
|
obj.b = item.b().get();
|
|
obj.h = item.h().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getPartialLoadBulkTableData(vector<PartialLoadBulk> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->PartialLoadBulk())
|
|
{
|
|
PartialLoadBulk obj;
|
|
obj.partial_load_id = item.PartialLoadID();
|
|
obj.id = item.ID();
|
|
obj.gbulk = item.Gbulk().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getPartialLoadPersonTableData(vector<PartialLoadPerson> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->PartialLoadPerson())
|
|
{
|
|
PartialLoadPerson obj;
|
|
obj.partial_load_id = item.PartialLoadID();
|
|
obj.id = item.ID();
|
|
obj.person_type = item.PersonType().get();
|
|
obj.np = item.Np().get();
|
|
obj.bp = item.bp().get();
|
|
obj.lp = item.lp().get();
|
|
obj.mpy = item.Mpy().get();
|
|
obj.mpz = item.Mpz().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getPartialLoadIceTableData(vector<PartialLoadIce> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->PartialLoadIce())
|
|
{
|
|
PartialLoadIce obj;
|
|
obj.partial_load_id = item.PartialLoadID();
|
|
obj.id = item.ID();
|
|
obj.type = item.Type().get();
|
|
obj.as = item.As().get();
|
|
obj.wi = item.Wi().get();
|
|
obj.xg_symbol = item.Xg_symbol().get();
|
|
obj.yg = item.Yg().get();
|
|
obj.zg = item.Zg().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getWindFixedTableData(vector<WindFixed> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->WindFixed())
|
|
{
|
|
WindFixed obj;
|
|
obj.id = item.ID();
|
|
obj.type = item.Type().get();
|
|
obj.as = item.As().get();
|
|
obj.zf = item.Zf().get();
|
|
obj.full_coef = item.FullCoef().get();
|
|
obj.stream_line_coef = item.StreamlineCoef().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getWindNonFixedTableData(vector<WindNonFixed> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->WindNonFixed())
|
|
{
|
|
WindNonFixed obj;
|
|
obj.id = item.ID();
|
|
obj.type = item.Type().get();
|
|
obj.as = item.As().get();
|
|
obj.zf = item.Zf().get();
|
|
obj.full_coef = item.FullCoef().get();
|
|
obj.stream_line_coef = item.StreamlineCoef().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getCaseTableData(vector<Case> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->Case())
|
|
{
|
|
Case obj;
|
|
obj.id = item.ID();
|
|
obj.ship_type = item.ShipType().get();
|
|
obj.child_type = item.ChildType().get();
|
|
obj.criterial_factor = item.CriteriaFactor().get();
|
|
obj.check_state = item.CheckState().get();
|
|
obj.partial_load = item.PartialLoad().get();
|
|
obj.wind = item.Wind().get();
|
|
obj.remark = item.Remark().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getAllowNMTableData(vector<AllowNM> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->AllowNM())
|
|
{
|
|
AllowNM obj;
|
|
obj.x = item.X();
|
|
obj.nz = item.Nz().get();
|
|
obj.nf = item.Nf().get();
|
|
obj.mz = item.Mz().get();
|
|
obj.mf = item.Mf().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getDamCaseTableData(vector<DamCase> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->DamCase())
|
|
{
|
|
DamCase obj;
|
|
obj.id = item.ID();
|
|
obj.remark = item.Remark().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getDamCompartmentTableData(vector<DamCompartment> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->DamCompartment())
|
|
{
|
|
DamCompartment obj;
|
|
obj.id = item.ID();
|
|
obj.compartment_ids = item.CompartmentIDs();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getDamCaseProbTableData(vector<DamCaseProb> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->DamCaseProb())
|
|
{
|
|
DamCaseProb obj;
|
|
obj.id = item.ID();
|
|
obj.type = item.Type().get();
|
|
obj.d = item.d().get();
|
|
obj.at = item.AT().get();
|
|
obj.gm = item.GM().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getDamRegionTableData(vector<DamRegion> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->DamRegion())
|
|
{
|
|
DamRegion obj;
|
|
obj.id = item.ID();
|
|
obj.type = item.Type();
|
|
obj.xa_symbol = (item.Xa_symbol() == nullptr) ? "" : (item.Xa_symbol().get());
|
|
obj.xa = item.Xa().get();
|
|
obj.xf_symbol = (item.Xf_symbol() == nullptr) ? "" : (item.Xf_symbol().get());
|
|
obj.xf = item.Xf().get();
|
|
obj.yp = item.Yp().get();
|
|
obj.zp = item.Zp().get();
|
|
obj.ymax = item.Ymax().get();
|
|
obj.hmax = item.Hmax().get();
|
|
obj.myp = item.Myp().get();
|
|
obj.mzp = item.Mzp().get();
|
|
obj.isnew = item.isNew().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getCompExtentTableData(vector<CompExtent> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->CompExtent())
|
|
{
|
|
CompExtent obj;
|
|
obj.id = item.ID();
|
|
obj.space_id = item.SpaceID().get();
|
|
obj.xmin = item.Xmin().get();
|
|
obj.xmax = item.Xmax().get();
|
|
obj.ymin = item.Ymin().get();
|
|
obj.ymax = item.Ymax().get();
|
|
obj.zmin = item.Zmin().get();
|
|
obj.zmax = item.Zmax().get();
|
|
obj.xregionid = item.XRegionID().get();
|
|
obj.yregionid = item.YRegionID().get();
|
|
obj.zregionid = item.ZRegionID().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getDamCompartmentProbTableData(vector<DamCompartmentProb> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->DamCompartmentProb())
|
|
{
|
|
DamCompartmentProb obj;
|
|
obj.id = item.ID();
|
|
obj.compartment_ids = item.CompartmentIDs();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningDraftTableData(vector<IncliningDraft> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->IncliningDraft())
|
|
{
|
|
IncliningDraft obj;
|
|
obj.id = item.ID();
|
|
obj.aft = item.Aft().get();
|
|
obj.mid = item.Mid().get();
|
|
obj.bow = item.Bow().get();
|
|
obj.remark = (item.Remark() == nullptr) ? "" : item.Remark().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningStatusTableData(vector<IncliningStatus> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->IncliningStatus())
|
|
{
|
|
IncliningStatus obj;
|
|
obj.paramid = item.ParamID();
|
|
obj.unit = item.Unit().get();
|
|
obj.caption = item.Caption().get();
|
|
obj.value_type = item.ValueType().get();
|
|
obj.value = item.Value().get();
|
|
obj.remark = item.Remark().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningExtraWeightTableData(vector<IncliningExtraWeight> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->IncliningExtraWeight())
|
|
{
|
|
IncliningExtraWeight obj;
|
|
obj.id = item.ID();
|
|
obj.type = item.Type().get();
|
|
obj.g = item.G().get();
|
|
obj.xg_symbol = item.Xg_symbol().get();
|
|
obj.xg = item.Xg().get();
|
|
obj.yg = item.Yg().get();
|
|
obj.zg = item.Zg().get();
|
|
obj.compartment = item.Compartment().get();
|
|
obj.density = item.Density().get();
|
|
obj.ratio = item.Ratio().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningRelocateWeightTableData(vector<IncliningRelocateWeight> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->IncliningRelocateWeight())
|
|
{
|
|
IncliningRelocateWeight obj;
|
|
obj.id = item.ID();
|
|
obj.g = item.G().get();
|
|
obj.xg_symbol = item.Xg_symbol().get();
|
|
obj.yg = item.Yg().get();
|
|
obj.zg = item.Zg().get();
|
|
obj.xg1_symbol = item.Xg1_symbol().get();
|
|
obj.xg1 = item.Xg1().get();
|
|
obj.yg1 = item.Yg1().get();
|
|
obj.zg1 = item.Zg1().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningAbsentWeightTableData(vector<IncliningAbsentWeight> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->IncliningAbsentWeight())
|
|
{
|
|
IncliningAbsentWeight obj;
|
|
obj.id = item.ID();
|
|
obj.g = item.G().get();
|
|
obj.xg_symbol = item.Xg_symbol().get();
|
|
obj.xg = item.Xg().get();
|
|
obj.yg = item.Yg().get();
|
|
obj.zg = item.Zg().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningTankTableData(vector<IncliningTank> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->IncliningTank())
|
|
{
|
|
IncliningTank obj;
|
|
obj.id = item.ID();
|
|
obj.compartment = item.Compartment().get();
|
|
obj.g = item.G().get();
|
|
obj.ratio = item.Ratio().get();
|
|
obj.density = item.Density().get();
|
|
obj.v = item.V().get();
|
|
obj.l = item.l().get();
|
|
obj.b = item.b().get();
|
|
obj.h = item.h().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningMobileWeightTableData(vector<IncliningMobileWeight> &data_grid_view)
|
|
{
|
|
for (const auto &item : m_ModelDS->IncliningMobileWeight())
|
|
{
|
|
IncliningMobileWeight obj;
|
|
obj.id = item.ID();
|
|
obj.g = item.G().get();
|
|
obj.xg_symbol = item.Xg_symbol().get();
|
|
obj.xg = item.Xg().get();
|
|
obj.yg = item.Yg().get();
|
|
obj.zg = item.Zg().get();
|
|
obj.b = item.b().get();
|
|
obj.description = item.Description().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningDeviceTableData(vector<IncliningDevice> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
|
|
for (const auto &item : m_ModelDS->IncliningDevice())
|
|
{
|
|
IncliningDevice obj;
|
|
obj.id = item.ID();
|
|
obj.x = item.X().get();
|
|
obj.param = item.Param().get();
|
|
obj.remark = (item.Remark() == nullptr) ? "" : item.Remark().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningCaseTableData(vector<IncliningCase> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
for (const auto &item : m_ModelDS->IncliningCase())
|
|
{
|
|
IncliningCase obj;
|
|
obj.id = item.ID();
|
|
obj.weight_ids = item.WeightIDs().get();
|
|
obj.port_weight_ids = item.PortWeightIDs().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::getIncliningRecordTableData(vector<IncliningRecord> &data_grid_view)
|
|
{
|
|
data_grid_view.clear();
|
|
for (const auto &item : m_ModelDS->IncliningRecord())
|
|
{
|
|
IncliningRecord obj;
|
|
obj.device_id = item.DeviceID();
|
|
obj.case_id = item.CaseID();
|
|
obj.avg = item.Avg().get();
|
|
obj.no1 = item.No1().get();
|
|
obj.no2 = item.No2().get();
|
|
obj.no3 = item.No3().get();
|
|
obj.no4 = item.No4().get();
|
|
obj.no5 = item.No5().get();
|
|
obj.no6 = item.No6().get();
|
|
obj.no7 = item.No7().get();
|
|
obj.no8 = item.No8().get();
|
|
obj.no9 = item.No9().get();
|
|
data_grid_view.push_back(obj);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void XmlSerialization::setXLabelDataSet(const vector<XLabel>& data_grid_view)
|
|
{
|
|
for (const auto& item : data_grid_view)
|
|
{
|
|
model_ds::XLabel obj(item.id);
|
|
obj.X(item.x);
|
|
|
|
m_ModelDS->XLabel().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setBInfDataSet(const vector<BInf> &data_grid_view)
|
|
{
|
|
// m_ModelDS->BInf().clear();不能清空，这里只能进行更新
|
|
updateBInfSequence(data_grid_view);
|
|
}
|
|
|
|
|
|
void XmlSerialization::setShellDataSet(const vector<Shell> &data_grid_view)
|
|
{
|
|
m_ModelDS->Shell().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::Shell obj(item.id, item.shell_id);
|
|
obj.ID(item.id);
|
|
obj.ShellID(item.shell_id);
|
|
obj.Type(item.type);
|
|
obj.ShellAffect(item.shell_affect);
|
|
obj.AffectCoef(item.affect_coef);
|
|
obj.Remark(item.remark);
|
|
obj.SID(item.sid);
|
|
m_ModelDS->Shell().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setFloodPointDataSet(const vector<FloodPoint> &data_grid_view)
|
|
{
|
|
m_ModelDS->FloodPoint().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::FloodPoint obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Xsymbol(item.xsymbol);
|
|
obj.X(item.x);
|
|
obj.Y(item.y);
|
|
obj.Z(item.z);
|
|
m_ModelDS->FloodPoint().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setLimitStaticPointDataSet(const vector<LimitStaticPoint> &data_grid_view)
|
|
{
|
|
m_ModelDS->LimitStaticPoint().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::LimitStaticPoint obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Xsymbol(item.xsymbol);
|
|
obj.X1(item.x1);
|
|
obj.Y1(item.y1);
|
|
obj.Z1(item.z1);
|
|
obj.X2(item.x2);
|
|
obj.Y2(item.y2);
|
|
obj.Z2(item.z2);
|
|
m_ModelDS->LimitStaticPoint().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setImmersionPointDataSet(const vector<ImmersionPoint> &data_grid_view)
|
|
{
|
|
m_ModelDS->ImmersionPoint().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::ImmersionPoint obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Xsymbol(item.xsymbol);
|
|
obj.X(item.x);
|
|
obj.Y(item.y);
|
|
obj.Z(item.z);
|
|
obj.Compartment(item.compartment);
|
|
m_ModelDS->ImmersionPoint().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setDecklineDataSet(const vector<Deckline> &data_grid_view)
|
|
{
|
|
m_ModelDS->Deckline().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::Deckline obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Xsymbol(item.xsymbol);
|
|
obj.X(item.x);
|
|
obj.Y(item.y);
|
|
obj.Z(item.z);
|
|
m_ModelDS->Deckline().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setCompartmentDataSet(const vector<Compartment> &data_grid_view)
|
|
{
|
|
m_ModelDS->Compartment().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::Compartment obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.SpaceID(item.space_id);
|
|
obj.FloodPoints(item.flood_points);
|
|
obj.Type(item.type);
|
|
obj.Coef(item.coef);
|
|
obj.Permeability(item.permeability);
|
|
obj.Density(item.density);
|
|
obj.Remark(item.remark);
|
|
obj.SID(item.sid);
|
|
m_ModelDS->Compartment().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setLwtDataSet(const vector<LWT> &data_grid_view)
|
|
{
|
|
m_ModelDS->LWT().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::LWT obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Type(item.type);
|
|
obj.G(item.g);
|
|
obj.Xg_symbol(item.xg_symbol);
|
|
obj.Xg(item.xg);
|
|
obj.Yg(item.yg);
|
|
obj.Zg(item.zg);
|
|
obj.Xa_symbol(item.xa_symbol);
|
|
obj.Xf_symbol(item.xf_symbol);
|
|
obj.Xa(item.xa);
|
|
obj.Xf(item.xf);
|
|
|
|
m_ModelDS->LWT().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setPartialLoadDataSet(const vector<PartialLoad> &data_grid_view)
|
|
{
|
|
m_ModelDS->PartialLoad().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::PartialLoad obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Remark(item.remark);
|
|
m_ModelDS->PartialLoad().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setPartialLoadWeightDataSet(const vector<PartialLoadWeight> &data_grid_view)
|
|
{
|
|
m_ModelDS->PartialLoadWeight().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::PartialLoadWeight obj(item.partial_load_id, item.id);
|
|
obj.PartialLoadID(item.partial_load_id);
|
|
obj.ID(item.id);
|
|
obj.WtType(item.wt_type);
|
|
obj.Compartment(item.compartment);
|
|
obj.CompartType(item.compartment_type);
|
|
obj.FreeSurfType(item.free_surf_type);
|
|
obj.G(item.g);
|
|
obj.Ratio(item.ratio);
|
|
obj.Density(item.density);
|
|
obj.Xg_symbol(item.xg_symbol);
|
|
obj.Xg(item.xg);
|
|
obj.Yg(item.yg);
|
|
obj.Zg(item.zg);
|
|
obj.Xa_symbol(item.xa_symbol);
|
|
obj.Xf_symbol(item.xf_symbol);
|
|
obj.Xa(item.xa);
|
|
obj.Xf(item.xf);
|
|
m_ModelDS->PartialLoadWeight().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setPartialLoadFreeSurfDataSet(const vector<PartialLoadFreeSurf> &data_grid_view)
|
|
{
|
|
m_ModelDS->PartialLoadFreeSurf().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::PartialLoadFreeSurf obj(item.partial_load_id, item.id);
|
|
obj.PartialLoadID(item.partial_load_id);
|
|
obj.ID(item.id);
|
|
obj.FreeSurfType(item.freesurftype);
|
|
obj.Compartment(item.compartment);
|
|
obj.G(item.g);
|
|
obj.Ratio(item.ratio);
|
|
obj.Density(item.density);
|
|
obj.V(item.v);
|
|
obj.l(item.l);
|
|
obj.b(item.b);
|
|
obj.h(item.h);
|
|
m_ModelDS->PartialLoadFreeSurf().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setPartialLoadBulkDataSet(const vector<PartialLoadBulk> &data_grid_view)
|
|
{
|
|
m_ModelDS->PartialLoadBulk().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::PartialLoadBulk obj(item.partial_load_id, item.id);
|
|
obj.PartialLoadID(item.partial_load_id);
|
|
obj.ID(item.id);
|
|
obj.Gbulk(item.gbulk);
|
|
m_ModelDS->PartialLoadBulk().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setPartialLoadPersonDataSet(const vector<PartialLoadPerson> &data_grid_view)
|
|
{
|
|
m_ModelDS->PartialLoadPerson().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::PartialLoadPerson obj(item.partial_load_id, item.id);
|
|
obj.PartialLoadID(item.partial_load_id);
|
|
obj.ID(item.id);
|
|
obj.PersonType(item.person_type);
|
|
obj.Np(item.np);
|
|
obj.bp(item.bp);
|
|
obj.lp(item.lp);
|
|
obj.Mpy(item.mpy);
|
|
obj.Mpz(item.mpz);
|
|
m_ModelDS->PartialLoadPerson().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setPartialLoadIceDataSet(const vector<PartialLoadIce> &data_grid_view)
|
|
{
|
|
m_ModelDS->PartialLoadIce().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::PartialLoadIce obj(item.partial_load_id, item.id);
|
|
obj.PartialLoadID(item.partial_load_id);
|
|
obj.ID(item.id);
|
|
obj.Type(item.type);
|
|
obj.As(item.as);
|
|
obj.Wi(item.wi);
|
|
obj.Xg_symbol(item.xg_symbol);
|
|
obj.Yg(item.yg);
|
|
obj.Zg(item.zg);
|
|
m_ModelDS->PartialLoadIce().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setWindFixedDataSet(const vector<WindFixed> &data_grid_view)
|
|
{
|
|
m_ModelDS->WindFixed().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::WindFixed obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Type(item.type);
|
|
obj.As(item.as);
|
|
obj.Zf(item.zf);
|
|
obj.FullCoef(item.full_coef);
|
|
obj.StreamlineCoef(item.stream_line_coef);
|
|
m_ModelDS->WindFixed().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setWindNonFixedDataSet(const vector<WindNonFixed> &data_grid_view)
|
|
{
|
|
m_ModelDS->WindNonFixed().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::WindNonFixed obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Type(item.type);
|
|
obj.As(item.as);
|
|
obj.Zf(item.zf);
|
|
obj.FullCoef(item.full_coef);
|
|
obj.StreamlineCoef(item.stream_line_coef);
|
|
m_ModelDS->WindNonFixed().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setCaseDataSet(const vector<Case> &data_grid_view)
|
|
{
|
|
m_ModelDS->Case().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::Case obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.ShipType(item.ship_type);
|
|
obj.ChildType(item.child_type);
|
|
obj.CriteriaFactor(item.criterial_factor);
|
|
obj.CheckState(item.check_state);
|
|
obj.PartialLoad(item.partial_load);
|
|
obj.Wind(item.wind);
|
|
obj.Remark(item.remark);
|
|
m_ModelDS->Case().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setAllowNMDataSet(const vector<AllowNM> &data_grid_view)
|
|
{
|
|
m_ModelDS->AllowNM().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::AllowNM obj(item.x);
|
|
obj.X(item.x);
|
|
obj.Nz(item.nz);
|
|
obj.Nf(item.nf);
|
|
obj.Mz(item.mz);
|
|
obj.Mf(item.mf);
|
|
m_ModelDS->AllowNM().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setDamCaseDataSet(const vector<DamCase> &data_grid_view)
|
|
{
|
|
m_ModelDS->DamCase().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::DamCase obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Remark(item.remark);
|
|
m_ModelDS->DamCase().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setDamCompartmentDataSet(const vector<DamCompartment> &data_grid_view)
|
|
{
|
|
m_ModelDS->DamCompartment().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::DamCompartment obj(item.id, item.compartment_ids);
|
|
obj.ID(item.id);
|
|
obj.CompartmentIDs(item.compartment_ids);
|
|
m_ModelDS->DamCompartment().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setDamCaseProbDataSet(const vector<DamCaseProb> &data_grid_view)
|
|
{
|
|
m_ModelDS->DamCaseProb().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::DamCaseProb obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Type(item.type);
|
|
obj.d(item.d);
|
|
obj.AT(item.at);
|
|
obj.GM(item.gm);
|
|
m_ModelDS->DamCaseProb().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setDamRegionDataSet(const vector<DamRegion> &data_grid_view)
|
|
{
|
|
m_ModelDS->DamRegion().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::DamRegion obj(item.id, item.type);
|
|
obj.ID(item.id);
|
|
obj.Type(item.type);
|
|
obj.Xa_symbol(item.xa_symbol);
|
|
obj.Xa(item.xa);
|
|
obj.Xf_symbol(item.xf_symbol);
|
|
obj.Xf(item.xf);
|
|
obj.Yp(item.yp);
|
|
obj.Zp(item.zp);
|
|
|
|
obj.Ymax(item.ymax);
|
|
obj.Hmax(item.hmax);
|
|
obj.Myp(item.myp);
|
|
obj.Mzp(item.mzp);
|
|
obj.isNew(item.isnew);
|
|
|
|
m_ModelDS->DamRegion().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setCompExtentDataSet(const vector<CompExtent> &data_grid_view)
|
|
{
|
|
m_ModelDS->CompExtent().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::CompExtent obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.SpaceID(item.space_id);
|
|
obj.Xmin(item.xmin);
|
|
obj.Xmax(item.xmax);
|
|
obj.Ymin(item.ymin);
|
|
obj.Ymax(item.ymax);
|
|
obj.Zmin(item.zmin);
|
|
obj.Zmax(item.zmax);
|
|
obj.XRegionID(item.xregionid);
|
|
obj.YRegionID(item.yregionid);
|
|
obj.ZRegionID(item.zregionid);
|
|
m_ModelDS->CompExtent().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setDamCompartmentProbDataSet(const vector<DamCompartmentProb> &data_grid_view)
|
|
{
|
|
m_ModelDS->DamCompartmentProb().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::DamCompartmentProb obj(item.id, item.compartment_ids);
|
|
obj.ID(item.id);
|
|
obj.CompartmentIDs(item.compartment_ids);
|
|
m_ModelDS->DamCompartmentProb().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningDraftDataSet(const vector<IncliningDraft> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningDraft().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningDraft obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Aft(item.aft);
|
|
obj.Mid(item.mid);
|
|
obj.Bow(item.bow);
|
|
obj.Remark(item.remark);
|
|
m_ModelDS->IncliningDraft().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningStatusDataSet(const vector<IncliningStatus> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningStatus().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningStatus obj(item.paramid);
|
|
obj.ParamID(item.paramid);
|
|
obj.Unit(item.unit);
|
|
obj.Caption(item.caption);
|
|
obj.ValueType(item.value_type);
|
|
obj.Value(item.value);
|
|
obj.Remark(item.remark);
|
|
m_ModelDS->IncliningStatus().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningExtraWeightDataSet(const vector<IncliningExtraWeight> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningExtraWeight().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningExtraWeight obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Type(item.type);
|
|
obj.G(item.g);
|
|
obj.Xg_symbol(item.xg_symbol);
|
|
obj.Xg(item.xg);
|
|
obj.Yg(item.yg);
|
|
obj.Zg(item.zg);
|
|
obj.Compartment(item.compartment);
|
|
obj.Density(item.density);
|
|
obj.Ratio(item.ratio);
|
|
m_ModelDS->IncliningExtraWeight().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningRelocateWeightDataSet(const vector<IncliningRelocateWeight> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningRelocateWeight().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningRelocateWeight obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.G(item.g);
|
|
obj.Xg_symbol(item.xg_symbol);
|
|
obj.Yg(item.yg);
|
|
obj.Zg(item.zg);
|
|
obj.Xg1_symbol(item.xg1_symbol);
|
|
obj.Xg1(item.xg1);
|
|
obj.Yg1(item.yg1);
|
|
obj.Zg1(item.zg1);
|
|
m_ModelDS->IncliningRelocateWeight().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningAbsentWeightDataSet(const vector<IncliningAbsentWeight> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningAbsentWeight().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningAbsentWeight obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.G(item.g);
|
|
obj.Xg_symbol(item.xg_symbol);
|
|
obj.Xg(item.xg);
|
|
obj.Yg(item.yg);
|
|
obj.Zg(item.zg);
|
|
m_ModelDS->IncliningAbsentWeight().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningTankDataSet(const vector<IncliningTank> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningTank().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningTank obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.Compartment(item.compartment);
|
|
obj.G(item.g);
|
|
obj.Ratio(item.ratio);
|
|
obj.Density(item.density);
|
|
obj.V(item.v);
|
|
obj.l(item.l);
|
|
obj.b(item.b);
|
|
obj.h(item.h);
|
|
m_ModelDS->IncliningTank().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningMobileWeightDataSet(const vector<IncliningMobileWeight> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningMobileWeight().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningMobileWeight obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.G(item.g);
|
|
obj.Xg_symbol(item.xg_symbol);
|
|
obj.Xg(item.xg);
|
|
obj.Yg(item.yg);
|
|
obj.Zg(item.zg);
|
|
obj.b(item.b);
|
|
obj.Description(item.description);
|
|
m_ModelDS->IncliningMobileWeight().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningDeviceDataSet(const vector<IncliningDevice> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningDevice().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningDevice obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.X(item.x);
|
|
obj.Param(item.param);
|
|
obj.Remark(item.remark);
|
|
m_ModelDS->IncliningDevice().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningCaseDataSet(const vector<IncliningCase> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningCase().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningCase obj(item.id);
|
|
obj.ID(item.id);
|
|
obj.WeightIDs(item.weight_ids);
|
|
obj.PortWeightIDs(item.port_weight_ids);
|
|
m_ModelDS->IncliningCase().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setIncliningRecordDataSet(const vector<IncliningRecord> &data_grid_view)
|
|
{
|
|
m_ModelDS->IncliningRecord().clear();
|
|
for (const auto &item : data_grid_view)
|
|
{
|
|
model_ds::IncliningRecord obj(item.device_id, item.case_id);
|
|
obj.DeviceID(item.device_id);
|
|
obj.CaseID(item.case_id);
|
|
obj.Avg(item.avg);
|
|
obj.No1(item.no1);
|
|
obj.No2(item.no2);
|
|
obj.No3(item.no3);
|
|
obj.No4(item.no4);
|
|
obj.No5(item.no5);
|
|
obj.No6(item.no6);
|
|
obj.No7(item.no7);
|
|
obj.No8(item.no8);
|
|
obj.No9(item.no9);
|
|
m_ModelDS->IncliningRecord().push_back(obj);
|
|
}
|
|
}
|
|
|
|
|
|
void XmlSerialization::setStationLabelDataSet(const vector<StationLabel>& data_grid_view)
|
|
{
|
|
/**/
|
|
m_ModelDS->StationLabel().clear();
|
|
for (const auto& item : data_grid_view)
|
|
{
|
|
model_ds::StationLabel obj(item.id);
|
|
obj.Pos(item.pos);
|
|
m_ModelDS->StationLabel().push_back(obj);
|
|
}
|
|
}
|
|
|
|
|
|
void XmlSerialization::setWaterlineLabelDataSet(const vector<WaterlineLabel>& data_grid_view)
|
|
{
|
|
/**/
|
|
m_ModelDS->WaterlineLabel().clear();
|
|
for (const auto& item : data_grid_view)
|
|
{
|
|
model_ds::WaterlineLabel obj(item.id);
|
|
obj.Pos(item.pos);
|
|
m_ModelDS->WaterlineLabel().push_back(obj);
|
|
}
|
|
}
|
|
|
|
void XmlSerialization::setButtocklineLabelDataSet(const vector<ButtocklineLabel>& data_grid_view)
|
|
{
|
|
m_ModelDS->ButtocklineLabel().clear();
|
|
for (const auto& item : data_grid_view)
|
|
{
|
|
model_ds::ButtocklineLabel obj(item.id);
|
|
obj.Pos(item.pos);
|
|
m_ModelDS->ButtocklineLabel().push_back(obj);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|