FileIO::XmlPrjInterface Class Reference

Detailed Description

Data Explorer XML interface for project files

Definition at line 23 of file XmlPrjInterface.h.

#include <XmlPrjInterface.h>

Inheritance diagram for FileIO::XmlPrjInterface:

Collaboration diagram for FileIO::XmlPrjInterface:

Public Member Functions
	XmlPrjInterface (DataHolderLib::Project &project)
	~XmlPrjInterface () override=default
int	readFile (const QString &fileName) override
	Reads an xml-file containing a project.
bool	readFile (std::string const &fname)
	Reads an xml-file containing a project.
int	writeToFile (const std::string &filename)
	Writes a project to the specified file.
Public Member Functions inherited from BaseLib::IO::Writer
	Writer ()
virtual	~Writer ()=default
std::string	writeToString ()
	Writes the object to a string.
Public Member Functions inherited from BaseLib::IO::XMLQtInterface
	XMLQtInterface (QString schemaFile="")
virtual	~XMLQtInterface ()=default

Protected Member Functions
bool	write () override
	Writes the object to the internal stream. This method must be implemented by a subclass. The implementation should return true on success, else false.
Protected Member Functions inherited from BaseLib::IO::XMLQtInterface
bool	checkHash () const
QByteArray const &	getContent () const

Private Member Functions
QDomNode	findParam (QDomNode const &param_root, QString const &param_name) const
	Tests if a given parameter exists within the file.
void	readConditions (QDomNode const &pvar_root, QDomNode const &param_root)
	Manages reading all kinds of conditions.
void	readBoundaryConditions (QDomNode const &bc_root, QDomNode const &param_root, DataHolderLib::ProcessVariable const &pvar)
	Reading all boundary conditions.
void	readSourceTerms (QDomNode const &st_root, QDomNode const &param_root, DataHolderLib::ProcessVariable const &pvar)
	Reading all source terms.
void	writeProcessVariables (QDomDocument &doc, QDomElement &root) const
	Writes information on process variables.
std::vector< DataHolderLib::ProcessVariable >	getPrimaryVariableVec () const
	Compiles a vector of all existing primary variables for writing purposes.
template<typename T>
void	writeCondition (QDomDocument &doc, QDomElement &tag, DataHolderLib::FemCondition const &cond) const
	Writes one specific condition.
void	writeBoundaryConditions (QDomDocument &doc, QDomElement &bc_list_tag, std::string const &name) const
	Writes a list of boundary conditions.
void	writeSourceTerms (QDomDocument &doc, QDomElement &st_list_tag, std::string const &name) const
	Writes a list of source terms.
template<typename T>
T *	parseCondition (QDomNode const &node, QDomNode const &param_root, DataHolderLib::ProcessVariable const &pvar) const
	Parsing one specific condition.

Private Attributes
std::string	_filename
DataHolderLib::Project &	_project

Additional Inherited Members
Protected Attributes inherited from BaseLib::IO::Writer
std::ostringstream	out
	The stream to write to.

Constructor & Destructor Documentation

XmlPrjInterface()

FileIO::XmlPrjInterface::XmlPrjInterface ( DataHolderLib::Project & project )

explicit

Definition at line 26 of file XmlPrjInterface.cpp.

    : XMLQtInterface("OpenGeoSysProject.xsd"), _filename(""), _project(project)
{
}

References BaseLib::IO::XMLQtInterface::XMLQtInterface(), _filename, and _project.

~XmlPrjInterface()

FileIO::XmlPrjInterface::~XmlPrjInterface ( )

overridedefault

Member Function Documentation

findParam()

QDomNode FileIO::XmlPrjInterface::findParam ( QDomNode const & param_root, QString const & param_name ) const

private

Tests if a given parameter exists within the file.

Definition at line 152 of file XmlPrjInterface.cpp.

{
    QDomNode param = param_root.firstChild();
 
    while (param != QDomNode())
    {
        QDomNodeList nodeList = param.childNodes();
        for (int i = 0; i < nodeList.count(); i++)
        {
            QDomNode node = nodeList.at(i);
            // std::cout << node.nodeName().toStdString() <<
            // node.toElement().text().toStdString() << std::endl;
            if (node.nodeName() == "name" &&
                node.toElement().text() == param_name)
            {
                return node;
            }
        }
        param = param.nextSibling();
    }
    return QDomNode();
}

Referenced by parseCondition().

getPrimaryVariableVec()

std::vector< DataHolderLib::ProcessVariable > FileIO::XmlPrjInterface::getPrimaryVariableVec ( ) const

private

Compiles a vector of all existing primary variables for writing purposes.

Definition at line 442 of file XmlPrjInterface.cpp.

{
    std::vector<std::unique_ptr<DataHolderLib::BoundaryCondition>> const&
        boundary_conditions = _project.getBoundaryConditions();
    std::vector<std::unique_ptr<DataHolderLib::SourceTerm>> const&
        source_terms = _project.getSourceTerms();
 
    std::vector<DataHolderLib::ProcessVariable> p_vars;
    for (auto& bc : boundary_conditions)
    {
        DataHolderLib::ProcessVariable const& pvar(bc->getProcessVar());
        if (!PVarExists(pvar.name, p_vars))
        {
            p_vars.push_back(pvar);
        }
    }
 
    for (auto& st : source_terms)
    {
        DataHolderLib::ProcessVariable const& pvar(st->getProcessVar());
        if (!PVarExists(pvar.name, p_vars))
        {
            p_vars.push_back(pvar);
        }
    }
    return p_vars;
}

References _project, DataHolderLib::ProcessVariable::name, and FileIO::PVarExists().

Referenced by writeProcessVariables().

parseCondition()

template<typename T>

T * FileIO::XmlPrjInterface::parseCondition ( QDomNode const & node, QDomNode const & param_root, DataHolderLib::ProcessVariable const & pvar ) const

private

Parsing one specific condition.

Definition at line 253 of file XmlPrjInterface.cpp.

{
    DataHolderLib::BaseObjType base_obj_type =
        DataHolderLib::BaseObjType::GEOMETRY;
    typename T::ConditionType type = T::ConditionType::NONE;
    std::string base_obj_name;
    std::string obj_name;
    std::string param_name;
    QDomNode param_node = QDomNode();
    QDomNodeList nodeList = node.childNodes();
    for (int i = 0; i < nodeList.count(); i++)
    {
        QString const node_name = nodeList.at(i).nodeName();
        QString const content = nodeList.at(i).toElement().text().trimmed();
        if (node_name == "geometrical_set" &&
            base_obj_type != DataHolderLib::BaseObjType::MESH)
        {
            base_obj_name = content.toStdString();
        }
        else if (node_name == "geometry" &&
                 base_obj_type != DataHolderLib::BaseObjType::MESH)
        {
            obj_name = content.toStdString();
        }
        else if (node_name == "type")
        {
            type = T::convertStringToType(content.toStdString());
        }
        else if (node_name == "mesh")
        {
            base_obj_type = DataHolderLib::BaseObjType::MESH;
            base_obj_name = content.toStdString();
            obj_name.clear();
        }
        else if (node_name == "field_name")
        {
            param_name = content.toStdString();
        }
        else if (node_name == "parameter")
        {
            QDomNode val = findParam(param_root, content);
            if (val == QDomNode())
            {
                continue;
            }
            param_name = content.toStdString();
            param_node = nodeList.at(i);
        }
    }
 
    if (!param_name.empty())
    {
        T* cond = new T(pvar, param_name, type);
        if (base_obj_type == DataHolderLib::BaseObjType::MESH)
        {
            cond->setMesh(base_obj_name);
        }
        else
        {
            cond->setGeoObject(base_obj_name, obj_name);
        }
 
        return cond;
    }
    return new T({"", 0, 0}, "", T::ConditionType::NONE);
}

References findParam(), DataHolderLib::GEOMETRY, and DataHolderLib::MESH.

Referenced by readBoundaryConditions(), and readSourceTerms().

readBoundaryConditions()

void FileIO::XmlPrjInterface::readBoundaryConditions ( QDomNode const & bc_root, QDomNode const & param_root, DataHolderLib::ProcessVariable const & pvar )

private

Reading all boundary conditions.

Definition at line 213 of file XmlPrjInterface.cpp.

{
    QDomNode bc = bc_root.firstChild();
    while (bc != QDomNode())
    {
        std::unique_ptr<DataHolderLib::BoundaryCondition> cond(
            parseCondition<DataHolderLib::BoundaryCondition>(bc, param_root,
                                                             pvar));
        if (cond->getType() !=
            DataHolderLib::BoundaryCondition::ConditionType::NONE)
        {
            _project.addBoundaryCondition(std::move(cond));
        }
 
        bc = bc.nextSibling();
    }
}

References _project, DataHolderLib::BoundaryCondition::NONE, and parseCondition().

Referenced by readConditions().

readConditions()

void FileIO::XmlPrjInterface::readConditions ( QDomNode const & pvar_root, QDomNode const & param_root )

private

Manages reading all kinds of conditions.

Definition at line 176 of file XmlPrjInterface.cpp.

{
    QDomNode pvar = pvar_root.firstChild();
    while (pvar != QDomNode())
    {
        DataHolderLib::ProcessVariable process_var;
        QDomNodeList nodeList = pvar.childNodes();
        for (int i = 0; i < nodeList.count(); i++)
        {
            QDomNode const node = nodeList.at(i);
            QString const node_name = node.nodeName();
            if (node_name == "name")
            {
                process_var.name = node.toElement().text().toStdString();
            }
            else if (node_name == "components")
            {
                process_var.components = node.toElement().text().toInt();
            }
            else if (node_name == "order")
            {
                process_var.order = node.toElement().text().toInt();
            }
            else if (node_name == "boundary_conditions")
            {
                readBoundaryConditions(node, param_root, process_var);
            }
            else if (node_name == "source_terms")
            {
                readSourceTerms(node, param_root, process_var);
            }
        }
        pvar = pvar.nextSibling();
    }
}

References DataHolderLib::ProcessVariable::components, DataHolderLib::ProcessVariable::name, DataHolderLib::ProcessVariable::order, readBoundaryConditions(), and readSourceTerms().

Referenced by readFile().

readFile() [1/2]

int FileIO::XmlPrjInterface::readFile ( const QString & fileName )

overridevirtual

Reads an xml-file containing a project.

Reimplemented from BaseLib::IO::XMLQtInterface.

Definition at line 31 of file XmlPrjInterface.cpp.

{
    if (XMLQtInterface::readFile(fileName) == 0)
    {
        return 0;
    }
 
    QFileInfo fi(fileName);
    QString path =
        (fi.path().length() > 3) ? QString(fi.path() + "/") : fi.path();
 
    QDomNode param_root = QDomNode();
    QDomNode pvar_root = QDomNode();
    QDomDocument doc("OGS-PROJECT-DOM");
    doc.setContent(getContent());
    QDomElement docElement = doc.documentElement();  // OpenGeoSysProject
    if (docElement.nodeName().compare("OpenGeoSysProject"))
    {
        ERR("XmlPrjInterface::readFile(): Unexpected XML root.");
        return 0;
    }
 
    auto read_single_mesh = [&](QString const& mesh_str)
    {
        std::unique_ptr<MeshLib::Mesh> mesh{
            MeshLib::IO::readMeshFromFile(mesh_str.toStdString())};
        if (mesh != nullptr)
        {
            _project.addMesh(std::move(mesh));
        }
    };
 
    QDomNodeList fileList = docElement.childNodes();
 
    for (int i = 0; i < fileList.count(); i++)
    {
        QDomNode const node(fileList.at(i));
        QString const node_name(node.nodeName());
        QString const file_name(node.toElement().text().trimmed());
        if (file_name.isEmpty())
        {
            continue;
        }
 
        if (node_name == "geometry")
        {
            GeoLib::IO::XmlGmlInterface gml(_project.getGEOObjects());
            try
            {
                gml.readFile(QString(path + file_name));
            }
            catch (std::runtime_error const& err)
            {
                OGSError::box(err.what(),
                              "Failed to read file `" + fileName + "'");
            }
        }
        else if (node_name == "stations")
        {
            GeoLib::IO::XmlStnInterface stn(_project.getGEOObjects());
            stn.readFile(QString(path + file_name));
        }
        else if (node_name == "mesh")
        {
            read_single_mesh(path + file_name);
        }
        else if (node_name == "meshes")
        {
            for (QDomNode meshes_node = node.firstChild();
                 meshes_node != QDomNode();
                 meshes_node = meshes_node.nextSibling())
            {
                if (!meshes_node.isElement())
                {
                    ERR("Expected an XML element node.");
                    return 0;
                }
                if (meshes_node.nodeName() != "mesh")
                {
                    ERR("Expected an XML element node named 'mesh' got '{:s}'.",
                        meshes_node.nodeName().toStdString());
                    return 0;
                }
                if (meshes_node.childNodes().count() != 1)
                {
                    ERR("Expected an XML element node named 'mesh' to contain "
                        "exactly one child node but it has {:d} children.",
                        meshes_node.childNodes().count());
                    return 0;
                }
                QDomNode node_text = meshes_node.firstChild();
                if (!node_text.isText())
                {
                    ERR("Expected an XML element node named 'mesh' to contain "
                        "text.");
                    return 0;
                }
                read_single_mesh(path + node_text.toText().data().trimmed());
            }
        }
 
        else if (node_name == "parameters")
        {
            param_root = node;
        }
        else if (node_name == "process_variables")
        {
            pvar_root = node;
        }
    }
 
    if (param_root != QDomNode() && pvar_root != QDomNode())
    {
        readConditions(pvar_root, param_root);
    }
    else
        INFO("Skipping process variables");
 
    return 1;
}

References _project, OGSError::box(), ERR(), BaseLib::IO::XMLQtInterface::getContent(), INFO(), readConditions(), GeoLib::IO::XmlGmlInterface::readFile(), GeoLib::IO::XmlStnInterface::readFile(), and MeshLib::IO::readMeshFromFile().

Referenced by MainWindow::loadFile(), and readFile().

readFile() [2/2]

bool FileIO::XmlPrjInterface::readFile ( std::string const & fname )

inline

Reads an xml-file containing a project.

Definition at line 35 of file XmlPrjInterface.h.

    {
        return readFile(QString(fname.c_str())) != 0;
    }

References readFile().

readSourceTerms()

void FileIO::XmlPrjInterface::readSourceTerms ( QDomNode const & st_root, QDomNode const & param_root, DataHolderLib::ProcessVariable const & pvar )

private

Reading all source terms.

Definition at line 234 of file XmlPrjInterface.cpp.

{
    QDomNode st = st_root.firstChild();
    while (st != QDomNode())
    {
        std::unique_ptr<DataHolderLib::SourceTerm> cond(
            parseCondition<DataHolderLib::SourceTerm>(st, param_root, pvar));
        if (cond->getType() != DataHolderLib::SourceTerm::ConditionType::NONE)
        {
            _project.addSourceTerm(std::move(cond));
        }
        st = st.nextSibling();
    }
}

References _project, DataHolderLib::SourceTerm::NONE, and parseCondition().

Referenced by readConditions().

write()

bool FileIO::XmlPrjInterface::write ( )

overrideprotectedvirtual

Writes the object to the internal stream. This method must be implemented by a subclass. The implementation should return true on success, else false.

Implements BaseLib::IO::Writer.

Definition at line 329 of file XmlPrjInterface.cpp.

{
    GeoLib::GEOObjects& geo_objects = _project.getGEOObjects();
    QFileInfo fi(QString::fromStdString(_filename));
    std::string path((fi.absolutePath()).toStdString() + "/");
 
    out << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";  // xml
                                                                 // definition
    out << "<?xml-stylesheet type=\"text/xsl\" "
           "href=\"OpenGeoSysProject.xsl\"?>\n\n";  // stylefile definition
 
    QDomDocument doc("OGS-PROJECT-DOM");
    QDomElement root = doc.createElement("OpenGeoSysProject");
    root.setAttribute("xmlns:ogs", "http://www.opengeosys.org");
    root.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
 
    doc.appendChild(root);
 
    // meshes
    auto const& mesh_vector = _project.getMeshObjects();
    for (auto const& mesh : mesh_vector)
    {
        // write mesh file
        if (MeshLib::IO::writeMeshToFile(*mesh,
                                         path + mesh->getName() + ".vtu") != 0)
        {
            return false;
        }
 
        // write entry in project file
        QDomElement mesh_tag = doc.createElement("mesh");
        root.appendChild(mesh_tag);
        QDomText filename_text =
            doc.createTextNode(QString::fromStdString(mesh->getName()));
        mesh_tag.appendChild(filename_text);
    }
 
    // geometries
    for (std::string const& name : geo_objects.getGeometryNames())
    {
        // write gml file
        GeoLib::IO::XmlGmlInterface gml(geo_objects);
        gml.export_name = name;
        if (BaseLib::IO::writeStringToFile(gml.writeToString(),
                                           std::string(path + name + ".gml")))
        {
            // write entry in project file
            QDomElement geo_tag = doc.createElement("geometry");
            root.appendChild(geo_tag);
            QDomText filename_text =
                doc.createTextNode(QString::fromStdString(name + ".gml"));
            geo_tag.appendChild(filename_text);
        }
        else
            ERR("XmlGmlInterface::writeFile(): Error writing gml-file '{:s}'.",
                name);
    }
 
    // stations
    std::vector<std::string> stn_names;
    geo_objects.getStationVectorNames(stn_names);
    for (std::string const& name : stn_names)
    {
        // write station file
        GeoLib::IO::XmlStnInterface stn(geo_objects);
        stn.export_name = name;
 
        if (BaseLib::IO::writeStringToFile(stn.writeToString(),
                                           path + name + ".stn"))
        {
            // write entry in project file
            QDomElement stn_tag = doc.createElement("stations");
            root.appendChild(stn_tag);
            QDomText filename_text =
                doc.createTextNode(QString::fromStdString(name + ".stn"));
            stn_tag.appendChild(filename_text);
        }
        else
            ERR("XmlStnInterface::writeFile(): Error writing stn-file '{:s}'.",
                name);
    }
 
    if (!_project.getBoundaryConditions().empty() ||
        !_project.getSourceTerms().empty())
    {
        // parameters
        writeProcessVariables(doc, root);
    }
 
    std::string xml = doc.toString().toStdString();
    out << xml;
    return true;
}

References _filename, _project, ERR(), BaseLib::IO::XMLInterface::export_name, GeoLib::GEOObjects::getGeometryNames(), GeoLib::GEOObjects::getStationVectorNames(), BaseLib::IO::Writer::out, MeshLib::IO::writeMeshToFile(), writeProcessVariables(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

writeBoundaryConditions()

void FileIO::XmlPrjInterface::writeBoundaryConditions ( QDomDocument & doc, QDomElement & bc_list_tag, std::string const & name ) const

private

Writes a list of boundary conditions.

Definition at line 508 of file XmlPrjInterface.cpp.

{
    std::vector<std::unique_ptr<DataHolderLib::BoundaryCondition>> const&
        boundary_conditions = _project.getBoundaryConditions();
    for (auto& bc : boundary_conditions)
    {
        if (bc->getProcessVarName() != name)
        {
            continue;
        }
        QDomElement bc_tag = doc.createElement("boundary_condition");
        bc_list_tag.appendChild(bc_tag);
        writeCondition<DataHolderLib::BoundaryCondition>(doc, bc_tag, *bc);
    }
}

References _project, and writeCondition().

Referenced by writeProcessVariables().

writeCondition()

template<typename T>

void FileIO::XmlPrjInterface::writeCondition ( QDomDocument & doc, QDomElement & tag, DataHolderLib::FemCondition const & cond ) const

private

Writes one specific condition.

Definition at line 471 of file XmlPrjInterface.cpp.

{
    if (cond.getBaseObjType() == DataHolderLib::BaseObjType::GEOMETRY)
    {
        addTextNode(doc,
                    tag,
                    "geometrical_set",
                    QString::fromStdString(cond.getBaseObjName()));
        addTextNode(doc, tag, "geometry",
                    QString::fromStdString(cond.getObjName()));
        addTextNode(doc,
                    tag,
                    "type",
                    QString::fromStdString(T::convertTypeToString(
                        static_cast<T const&>(cond).getType())));
        addTextNode(doc, tag, "parameter",
                    QString::fromStdString(cond.getParamName()));
    }
    else if (cond.getBaseObjType() == DataHolderLib::BaseObjType::MESH)
    {
        addTextNode(doc,
                    tag,
                    "type",
                    QString::fromStdString(T::convertTypeToString(
                        static_cast<T const&>(cond).getType())));
        addTextNode(doc, tag, "mesh",
                    QString::fromStdString(cond.getBaseObjName()));
        addTextNode(doc,
                    tag,
                    "field_name",
                    QString::fromStdString(cond.getParamName()));
    }
}

References FileIO::addTextNode(), DataHolderLib::GEOMETRY, DataHolderLib::FemCondition::getBaseObjName(), DataHolderLib::FemCondition::getBaseObjType(), DataHolderLib::FemCondition::getObjName(), DataHolderLib::FemCondition::getParamName(), and DataHolderLib::MESH.

Referenced by writeBoundaryConditions(), and writeSourceTerms().

writeProcessVariables()

void FileIO::XmlPrjInterface::writeProcessVariables ( QDomDocument & doc, QDomElement & root ) const

private

Writes information on process variables.

Definition at line 544 of file XmlPrjInterface.cpp.

{
    std::vector<DataHolderLib::ProcessVariable> const p_vars(
        getPrimaryVariableVec());
 
    QDomElement param_list_tag = doc.createElement("parameters");
    root.appendChild(param_list_tag);
 
    QDomElement pvar_list_tag = doc.createElement("process_variables");
    root.appendChild(pvar_list_tag);
 
    for (DataHolderLib::ProcessVariable const& p_var : p_vars)
    {
        QDomElement pvar_tag = doc.createElement("process_variable");
        pvar_list_tag.appendChild(pvar_tag);
        addTextNode(doc, pvar_tag, "name", QString::fromStdString(p_var.name));
        addTextNode(doc, pvar_tag, "order", QString::number(p_var.order));
        addTextNode(doc, pvar_tag, "components",
                    QString::number(p_var.components));
        QDomElement bc_list_tag = doc.createElement("boundary_conditions");
        pvar_tag.appendChild(bc_list_tag);
        writeBoundaryConditions(doc, bc_list_tag, p_var.name);
        QDomElement st_list_tag = doc.createElement("source_terms");
        pvar_tag.appendChild(st_list_tag);
        writeSourceTerms(doc, st_list_tag, p_var.name);
    }
}

References FileIO::addTextNode(), getPrimaryVariableVec(), writeBoundaryConditions(), and writeSourceTerms().

Referenced by write().

writeSourceTerms()

void FileIO::XmlPrjInterface::writeSourceTerms ( QDomDocument & doc, QDomElement & st_list_tag, std::string const & name ) const

private

Writes a list of source terms.

Definition at line 526 of file XmlPrjInterface.cpp.

{
    std::vector<std::unique_ptr<DataHolderLib::SourceTerm>> const&
        source_terms = _project.getSourceTerms();
    for (auto& st : source_terms)
    {
        if (st->getProcessVarName() != name)
        {
            continue;
        }
        QDomElement st_tag = doc.createElement("source_term");
        st_list_tag.appendChild(st_tag);
        writeCondition<DataHolderLib::SourceTerm>(doc, st_tag, *st);
    }
}

References _project, and writeCondition().

Referenced by writeProcessVariables().

writeToFile()

int FileIO::XmlPrjInterface::writeToFile

(

const std::string &

filename

)

Writes a project to the specified file.

Definition at line 323 of file XmlPrjInterface.cpp.

{
    _filename = filename;
    return BaseLib::IO::writeStringToFile(writeToString(), filename);
}

References _filename, BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

Member Data Documentation

_filename

std::string FileIO::XmlPrjInterface::_filename

private

Definition at line 87 of file XmlPrjInterface.h.

Referenced by XmlPrjInterface(), write(), and writeToFile().

_project

DataHolderLib::Project& FileIO::XmlPrjInterface::_project

private

Definition at line 88 of file XmlPrjInterface.h.

Referenced by XmlPrjInterface(), getPrimaryVariableVec(), readBoundaryConditions(), readFile(), readSourceTerms(), write(), writeBoundaryConditions(), and writeSourceTerms().

---

The documentation for this class was generated from the following files:

• XmlPrjInterface.h
• XmlPrjInterface.cpp