COMPASSi/trunk/code/projects/DataManager/Infrastructure.Data/DataContainer/StabCalculationData.cpp

#include "DataContainer/StabCalculationData.h"
#include "XmlSerialization.h"

int StabCalculationData::fromXml(const pugi::xml_node node)
{

    if(node.empty())
    {
        return -1;
    }

    m_StabilityCal.fromXmlEx(node, m_childModules, m_childModuleNames, m_DataRows, m_ModuleNames);

    std::string xml_string = getDataRowValue("Stab").toStdString();

    XmlSerialization* xmlPtr = XmlSerialization::getXmlSerializationInstance();
    xmlPtr->loadStabModelDS(xml_string);

    m_CalcBaseData.fromXml();

    // m_Name = node.attribute("Name").as_string();
    return 1;
}

void StabCalculationData::saveStabCalcData(QString path)
{
    m_CalcBaseData.toXml();

    XmlSerialization* xmlPtr = XmlSerialization::getXmlSerializationInstance();
    xmlPtr->saveSerializationXMLFile(path);
}
std::vector<std::string>& StabCalculationData::getAnalyseNameList()
{
    return m_childModuleNames;
}

int StabCalculationData::toXml(pugi::xml_node node)
{
    m_CalcBaseData.toXml();
    XmlSerialization* xmlPtr = XmlSerialization::getXmlSerializationInstance();
    std::string strValue = xmlPtr->saveSerializationXMLString();

    addOrUpdateDataRow("Stab", QString::fromStdString(strValue));
    m_StabilityCal.toXml(node, m_DataRows, m_childModules, m_childModuleNames);
   
    return 0;    
}


void StabCalculationData::addHydroBInfo(BInf& info)
{
    m_Hydro.addBInfData(info);
}

BInf* StabCalculationData::FindByParamID(std::string strParamID)
{
    return m_Hydro.FindByParamID(strParamID);
}

void StabCalculationData::AddXLabelRow(XLabel& data)
{
    bool bf = false;
    auto it = StabCalcBaseData::xlabel_data_grid_view.begin();
    for (; it != StabCalcBaseData::xlabel_data_grid_view.end(); ++it)
    {
        if (it->id == data.id)
        {
            it->x = data.x;
            bf = true;
        }
    }
    if (!bf)
    {
        StabCalcBaseData::xlabel_data_grid_view.emplace_back(data);
    }
}

void StabCalculationData::AddStationLabelRow(StationLabel& data)
{

    bool bf = false;
    auto it = StabCalcBaseData::station_label_data_grid_view.begin();
    for (; it != StabCalcBaseData::station_label_data_grid_view.end(); ++it)
    {
        if (it->id == data.id)
        {
            it->pos = data.pos;
            bf = true;
        }
    }
    if (!bf)
    {
        StabCalcBaseData::station_label_data_grid_view.emplace_back(data);
    }

}

void StabCalculationData::AddWaterlineLabelRow(WaterlineLabel& data)
{

    bool bf = false;
    auto it = StabCalcBaseData::waterline_label_data_grid_view.begin();
    for (; it != StabCalcBaseData::waterline_label_data_grid_view.end(); ++it)
    {
        if (it->id == data.id)
        {
            it->pos = data.pos;
            bf = true;
        }
    }
    if (!bf)
    {
        StabCalcBaseData::waterline_label_data_grid_view.emplace_back(data);
    }
}

void StabCalculationData::AddButtocklineLabelRow(ButtocklineLabel& data)
{
    bool bf = false;
    auto it = StabCalcBaseData::buttockline_label_data_grid_view.begin();
    for (; it != StabCalcBaseData::buttockline_label_data_grid_view.end(); ++it)
    {
        if (it->id == data.id)
        {
            it->pos = data.pos;
            bf = true;
        }
    }
    if (!bf)
    {
        StabCalcBaseData::buttockline_label_data_grid_view.emplace_back(data);
    }
}

bool StabCalculationData::isEmpty()
{
    if (m_DataRows.size() > 0)
    {
        return false;
    }
    return true;
}

QString StabCalculationData::getDataRowValue(const QString& key)
{
    if (!m_DataRows.contains(key))
        return "";
    QString dd = m_DataRows[key]->Value();
    return dd;
}

void StabCalculationData::addOrUpdateDataRow(const QString& key, QString value , QString caption, QString remark )
{
    if (key.isEmpty())
        return;

    if (!m_DataRows.contains(key))
    {
        DataRowInf* o = new DataRowInf();
        o->setID(key);
        o->setCaption(caption);
        o->setRemark(remark);
        o->setValue(value);
        m_DataRows.insert(key, o);
    }
    else
    {
        DataRowInf* o = m_DataRows.value(key);
        o->setCaption(caption);
        o->setRemark(remark);
        o->setValue(value);
    }
}

bool StabCalculationData::createDataRow(const QString& key, QString value, QString caption, QString remark )
{
    if (!m_DataRows.contains(key))
    {
        DataRowInf* o = new DataRowInf();
        o->setID(key);
        o->setCaption(caption);
        o->setRemark(remark);
        o->setValue(value);
        m_DataRows.insert(key, o);
        return true;
    }
    return false;
}

bool StabCalculationData::CreateChildModulus(const QString& key, QString caption, QString remark)
{
    if (!m_childModules.contains(key))
    {
        DataRowInf* o = new DataRowInf();
        o->setID(key);
        o->setCaption(caption);
        o->setRemark(remark);
        o->setValue("");
        m_childModules.insert(key, o);
        m_childModuleNames.push_back(key.toStdString());
        return true;
    }
    return false;
}