#include "XmlSerialization.h"
#include <algorithm>
#include <string>
#include "PathUtil.h"
#include <QFile>

//XmlSerialization *XmlSerialization::m_pXmlSerialization = nullptr;
#ifdef __cplusplus
extern "C"
{
#endif
    void XmlSerialization::saveSerializationXMLFile(QString xmlfile_path)
    {

        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();


    }

    std::string XmlSerialization::saveSerializationXMLString()
    {
        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);

        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