Detailed Description

Definition at line 35 of file BoostXmlGmlInterface.h.

#include <BoostXmlGmlInterface.h>

Inheritance diagram for GeoLib::IO::BoostXmlGmlInterface:

Collaboration diagram for GeoLib::IO::BoostXmlGmlInterface:

Public Member Functions
	BoostXmlGmlInterface (GeoLib::GEOObjects &geo_objs)

	~BoostXmlGmlInterface () override=default

bool	readFile (const std::string &fname) override
	Reads an xml-file containing OGS geometry.

Public Member Functions inherited from BaseLib::IO::Writer
	Writer ()

virtual	~Writer ()=default

std::string	writeToString ()
	Writes the object to a string.

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.

Private Member Functions
void	readPoints (BaseLib::ConfigTree const &pointsRoot, std::vector< GeoLib::Point * > &points, std::map< std::string, std::size_t > &pnt_names)
	Reads GeoLib::Point-objects from an xml-file.

void	readPolylines (BaseLib::ConfigTree const &polylinesRoot, std::vector< GeoLib::Polyline * > &polylines, std::vector< GeoLib::Point * > const &points, const std::vector< std::size_t > &pnt_id_map, std::map< std::string, std::size_t > &ply_names)
	Reads GeoLib::Polyline-objects from an xml-file.

void	readSurfaces (BaseLib::ConfigTree const &surfacesRoot, std::vector< GeoLib::Surface * > &surfaces, std::vector< GeoLib::Point * > const &points, const std::vector< std::size_t > &pnt_id_map, std::map< std::string, std::size_t > &sfc_names)
	Reads GeoLib::Surface-objects from an xml-file.

void	addSurfacesToPropertyTree (boost::property_tree::ptree &geometry_set)

void	addPolylinesToPropertyTree (boost::property_tree::ptree &geometry_set)

Private Attributes
std::map< std::size_t, std::size_t >	_idx_map

GeoLib::GEOObjects &	_geo_objects

Additional Inherited Members
Public Attributes inherited from BaseLib::IO::XMLInterface
std::string	export_name = {}

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

Constructor & Destructor Documentation

◆ BoostXmlGmlInterface()

GeoLib::IO::BoostXmlGmlInterface::BoostXmlGmlInterface ( GeoLib::GEOObjects & geo_objs )

explicit

Definition at line 33 of file BoostXmlGmlInterface.cpp.

    : _geo_objects(geo_objs)
{
}

◆ ~BoostXmlGmlInterface()

GeoLib::IO::BoostXmlGmlInterface::~BoostXmlGmlInterface ( )

overridedefault

Member Function Documentation

◆ addPolylinesToPropertyTree()

void GeoLib::IO::BoostXmlGmlInterface::addPolylinesToPropertyTree ( boost::property_tree::ptree & geometry_set )

private

Definition at line 376 of file BoostXmlGmlInterface.cpp.

{
    GeoLib::PolylineVec const* const vec(
        _geo_objects.getPolylineVecObj(export_name));
    if (!vec)
    {
        INFO(
            "BoostXmlGmlInterface::addPolylinesToPropertyTree(): No polylines "
            "within the geometry '{:s}'.",
            export_name);
        return;
    }
 
    auto const& polylines(vec->getVector());
    if (polylines.empty())
    {
        INFO(
            "BoostXmlGmlInterface::addPolylinesToPropertyTree(): No polylines "
            "within the geometry '{:s}'.",
            export_name);
        return;
    }
 
    auto& polylines_tag = geometry_set.add("polylines", "");
    for (std::size_t i = 0; i < polylines.size(); ++i)
    {
        GeoLib::Polyline const* const polyline(polylines[i]);
        std::string ply_name;
        vec->getNameOfElement(polyline, ply_name);
        auto& polyline_tag = polylines_tag.add("polyline", "");
        polyline_tag.put("<xmlattr>.id", i);
        if (!ply_name.empty())
        {
            polyline_tag.put("<xmlattr>.name", ply_name);
        }
        for (std::size_t j = 0; j < polyline->getNumberOfPoints(); ++j)
        {
            polyline_tag.add("pnt", polyline->getPointID(j));
        }
    }
}

References _geo_objects, BaseLib::IO::XMLInterface::export_name, GeoLib::TemplateVec< T >::getNameOfElement(), GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPointID(), GeoLib::GEOObjects::getPolylineVecObj(), GeoLib::TemplateVec< T >::getVector(), and INFO().

Referenced by write().

◆ addSurfacesToPropertyTree()

void GeoLib::IO::BoostXmlGmlInterface::addSurfacesToPropertyTree ( boost::property_tree::ptree & geometry_set )

private

Definition at line 330 of file BoostXmlGmlInterface.cpp.

{
    GeoLib::SurfaceVec const* const sfc_vec(
        _geo_objects.getSurfaceVecObj(export_name));
    if (!sfc_vec)
    {
        INFO(
            "BoostXmlGmlInterface::addSurfacesToPropertyTree(): No surfaces "
            "within the geometry '{:s}'.",
            export_name);
        return;
    }
 
    auto const& surfaces(sfc_vec->getVector());
    if (surfaces.empty())
    {
        INFO(
            "BoostXmlGmlInterface::addSurfacesToPropertyTree(): No surfaces "
            "within the geometry '{:s}'.",
            export_name);
        return;
    }
 
    auto& surfaces_tag = geometry_set.add("surfaces", "");
    for (std::size_t i = 0; i < surfaces.size(); ++i)
    {
        GeoLib::Surface const* const surface(surfaces[i]);
        std::string sfc_name;
        sfc_vec->getNameOfElement(surface, sfc_name);
        auto& surface_tag = surfaces_tag.add("surface", "");
        surface_tag.put("<xmlattr>.id", i);
        if (!sfc_name.empty())
        {
            surface_tag.put("<xmlattr>.name", sfc_name);
        }
        for (std::size_t j = 0; j < surface->getNumberOfTriangles(); ++j)
        {
            auto& element_tag = surface_tag.add("element", "");
            element_tag.put("<xmlattr>.p1", (*(*surface)[j])[0]);
            element_tag.put("<xmlattr>.p2", (*(*surface)[j])[1]);
            element_tag.put("<xmlattr>.p3", (*(*surface)[j])[2]);
        }
    }
}

References _geo_objects, BaseLib::IO::XMLInterface::export_name, GeoLib::TemplateVec< T >::getNameOfElement(), GeoLib::Surface::getNumberOfTriangles(), GeoLib::GEOObjects::getSurfaceVecObj(), GeoLib::TemplateVec< T >::getVector(), and INFO().

Referenced by write().

◆ readFile()

bool GeoLib::IO::BoostXmlGmlInterface::readFile ( const std::string & fname )

overridevirtual

Reads an xml-file containing OGS geometry.

Todo: Reading geometries is always strict.

Input File Parameter: gml__name

Input File Parameter: gml__points

Input File Parameter: gml__polylines

Input File Parameter: gml__surfaces

Implements BaseLib::IO::XMLInterface.

Definition at line 38 of file BoostXmlGmlInterface.cpp.

{
    auto doc = BaseLib::makeConfigTreeFromFile(fname, true, "OpenGeoSysGLI");
 
    // ignore attributes related to XML schema
    doc.ignoreConfigAttribute("xmlns:xsi");
    doc.ignoreConfigAttribute("xsi:noNamespaceSchemaLocation");
    doc.ignoreConfigAttribute("xmlns:ogs");
 
    auto geo_name = doc.getConfigParameter<std::string>("name");
    if (geo_name.empty())
    {
        OGS_FATAL("BoostXmlGmlInterface::readFile(): <name> tag is empty.");
    }
 
    for (auto st : doc.getConfigSubtreeList("points"))
    {
        std::vector<GeoLib::Point*> points;
        GeoLib::PointVec::NameIdMap pnt_names;
        readPoints(st, points, pnt_names);
        _geo_objects.addPointVec(std::move(points), geo_name,
                                 std::move(pnt_names));
    }
 
    std::vector<GeoLib::Polyline*> polylines;
    GeoLib::PolylineVec::NameIdMap ply_names;
    for (auto st : doc.getConfigSubtreeList("polylines"))
    {
        readPolylines(st,
                      polylines,
                      *_geo_objects.getPointVec(geo_name),
                      _geo_objects.getPointVecObj(geo_name)->getIDMap(),
                      ply_names);
    }
 
    std::vector<GeoLib::Surface*> surfaces;
    SurfaceVec::NameIdMap sfc_names;
 
    for (auto st : doc.getConfigSubtreeList("surfaces"))
    {
        readSurfaces(st, surfaces, *_geo_objects.getPointVec(geo_name),
                     _geo_objects.getPointVecObj(geo_name)->getIDMap(),
                     sfc_names);
    }
 
    if (!polylines.empty())
    {
        _geo_objects.addPolylineVec(std::move(polylines), geo_name,
                                    std::move(ply_names));
    }
 
    if (!surfaces.empty())
    {
        _geo_objects.addSurfaceVec(std::move(surfaces), geo_name,
                                   std::move(sfc_names));
    }
 
    return true;
}

References _geo_objects, GeoLib::GEOObjects::addPointVec(), GeoLib::GEOObjects::addPolylineVec(), GeoLib::GEOObjects::addSurfaceVec(), GeoLib::PointVec::getIDMap(), GeoLib::GEOObjects::getPointVec(), GeoLib::GEOObjects::getPointVecObj(), BaseLib::makeConfigTreeFromFile(), OGS_FATAL, readPoints(), readPolylines(), and readSurfaces().

Referenced by main(), readGeometry(), anonymous_namespace{ProjectData.cpp}::readGeometry(), and FileIO::readGeometryFromFile().

◆ readPoints()

void GeoLib::IO::BoostXmlGmlInterface::readPoints	(	BaseLib::ConfigTree const &	pointsRoot,
		std::vector< GeoLib::Point * > &	points,
		std::map< std::string, std::size_t > &	pnt_names )

private

Reads GeoLib::Point-objects from an xml-file.

Input File Parameter: gml__points__point

Input File Parameter: gml__points__point__id

Input File Parameter: gml__points__point__x

Input File Parameter: gml__points__point__y

Input File Parameter: gml__points__point__z

Input File Parameter: gml__points__point__name

Definition at line 103 of file BoostXmlGmlInterface.cpp.

{
    for (auto const pt : pointsRoot.getConfigParameterList("point"))
    {
        auto const p_id = pt.getConfigAttribute<std::size_t>("id");
        auto const p_x = pt.getConfigAttribute<double>("x");
        auto const p_y = pt.getConfigAttribute<double>("y");
        auto const p_z = pt.getConfigAttribute<double>("z");
 
        auto const p_size = points.size();
        BaseLib::insertIfKeyUniqueElseError(_idx_map, p_id, p_size,
                                            "The point id is not unique.");
        points.push_back(new GeoLib::Point(p_x, p_y, p_z, p_id));
 
        if (auto const p_name =
            pt.getConfigAttributeOptional<std::string>("name"))
        {
            if (p_name->empty())
            {
                OGS_FATAL("Empty point name found in geometry file.");
            }
 
            BaseLib::insertIfKeyUniqueElseError(
                pnt_names, *p_name, p_size, "The point name is not unique.");
        }
    }
}

References _idx_map, BaseLib::ConfigTree::getConfigParameterList(), BaseLib::insertIfKeyUniqueElseError(), and OGS_FATAL.

Referenced by readFile().

◆ readPolylines()

void GeoLib::IO::BoostXmlGmlInterface::readPolylines	(	BaseLib::ConfigTree const &	polylinesRoot,
		std::vector< GeoLib::Polyline * > &	polylines,
		std::vector< GeoLib::Point * > const &	points,
		const std::vector< std::size_t > &	pnt_id_map,
		std::map< std::string, std::size_t > &	ply_names )

private

Reads GeoLib::Polyline-objects from an xml-file.

Input File Parameter: gml__polylines__polyline

Input File Parameter: gml__polylines__polyline__id

Input File Parameter: gml__polylines__polyline__name

Input File Parameter: gml__polylines__polyline__pnt

Definition at line 140 of file BoostXmlGmlInterface.cpp.

{
    for (auto const pl : polylinesRoot.getConfigSubtreeList("polyline"))
    {
        auto const id = pl.getConfigAttribute<std::size_t>("id");
        // The id is not used but must be present in the GML file.
        // That's why pl.ignore...() cannot be used.
        (void)id;
 
        polylines.push_back(new GeoLib::Polyline(points));
 
        if (auto const p_name =
            pl.getConfigAttributeOptional<std::string>("name"))
        {
            if (p_name->empty())
            {
                OGS_FATAL("Empty polyline name found in geometry file.");
            }
 
            BaseLib::insertIfKeyUniqueElseError(
                ply_names, *p_name, polylines.size() - 1,
                "The polyline name is not unique.");
 
            auto accessOrError = [this, &p_name](auto pt_idx)
            {
                auto search = _idx_map.find(pt_idx);
                if (search == _idx_map.end())
                {
                    OGS_FATAL(
                        "Polyline `{:s}' contains the point id `{:d}', but the "
                        "id is not in the point list.",
                        p_name->c_str(), pt_idx);
                }
                return search->second;
            };
 
            for (auto const pt : pl.getConfigParameterList<std::size_t>("pnt"))
            {
                polylines.back()->addPoint(pnt_id_map[accessOrError(pt)]);
            }
        }
        else
        {
            // polyline has no name, ignore it.
            pl.ignoreConfigParameterAll("pnt");
            WARN(
                "Polyline name is required! Polylines without a name are "
                "ignored.");
        }
    }
}

References _idx_map, BaseLib::ConfigTree::getConfigSubtreeList(), BaseLib::insertIfKeyUniqueElseError(), OGS_FATAL, and WARN().

Referenced by readFile().

◆ readSurfaces()

void GeoLib::IO::BoostXmlGmlInterface::readSurfaces	(	BaseLib::ConfigTree const &	surfacesRoot,
		std::vector< GeoLib::Surface * > &	surfaces,
		std::vector< GeoLib::Point * > const &	points,
		const std::vector< std::size_t > &	pnt_id_map,
		std::map< std::string, std::size_t > &	sfc_names )

private

Reads GeoLib::Surface-objects from an xml-file.

Input File Parameter: gml__surfaces__surface

Input File Parameter: gml__surfaces__surface__id

Input File Parameter: gml__surfaces__surface__name

Input File Parameter: gml__surfaces__surface__element

Input File Parameter: gml__surfaces__surface__element__p1

Input File Parameter: gml__surfaces__surface__element__p2

Input File Parameter: gml__surfaces__surface__element__p3

Definition at line 201 of file BoostXmlGmlInterface.cpp.

{
    for (auto const& sfc : surfacesRoot.getConfigSubtreeList("surface"))
    {
        auto const id = sfc.getConfigAttribute<std::size_t>("id");
        // The id is not used but must be present in the GML file.
        // That's why sfc.ignore...() cannot be used.
        (void)id;
        surfaces.push_back(new GeoLib::Surface(points));
 
        if (auto const s_name =
            sfc.getConfigAttributeOptional<std::string>("name"))
        {
            if (s_name->empty())
            {
                OGS_FATAL("Empty surface name found in geometry file.");
            }
 
            BaseLib::insertIfKeyUniqueElseError(
                sfc_names, *s_name, surfaces.size() - 1,
                "The surface name is not unique.");
 
            for (auto const& element : sfc.getConfigParameterList("element"))
            {
                auto const p1_attr =
                    element.getConfigAttribute<std::size_t>("p1");
                auto const p2_attr =
                    element.getConfigAttribute<std::size_t>("p2");
                auto const p3_attr =
                    element.getConfigAttribute<std::size_t>("p3");
 
                auto accessOrError = [this, &s_name](std::size_t pt_idx)
                {
                    auto search = _idx_map.find(pt_idx);
                    if (search == _idx_map.end())
                    {
                        OGS_FATAL(
                            "The element list of the surface `{:s}' contains "
                            "the invalid point id `{:d}'.",
                            s_name->c_str(), pt_idx);
                    }
                    return search->second;
                };
 
                auto const p1 = pnt_id_map[accessOrError(p1_attr)];
                auto const p2 = pnt_id_map[accessOrError(p2_attr)];
                auto const p3 = pnt_id_map[accessOrError(p3_attr)];
                surfaces.back()->addTriangle(p1, p2, p3);
            }
        }
        else
        {
            // surface has no name, ignore it.
            sfc.ignoreConfigParameterAll("element");
        }
    }
}

References _idx_map, BaseLib::ConfigTree::getConfigSubtreeList(), BaseLib::insertIfKeyUniqueElseError(), and OGS_FATAL.

Referenced by readFile().

◆ write()

bool GeoLib::IO::BoostXmlGmlInterface::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 271 of file BoostXmlGmlInterface.cpp.

{
    if (export_name.empty())
    {
        ERR("BoostXmlGmlInterface::write(): No geometry specified.");
        return false;
    }
 
    GeoLib::PointVec const* const pnt_vec(
        _geo_objects.getPointVecObj(export_name));
    if (!pnt_vec)
    {
        ERR("BoostXmlGmlInterface::write(): No PointVec within the geometry "
            "'{:s}'.",
            export_name);
        return false;
    }
 
    auto const& pnts(pnt_vec->getVector());
    if (pnts.empty())
    {
        ERR("BoostXmlGmlInterface::write(): No points within the geometry "
            "'{:s}'.",
            export_name);
        return false;
    }
 
    // create a property tree for writing it to file
    boost::property_tree::ptree pt;
 
    // put header in property tree
    pt.put("<xmlattr>.xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
    pt.put("<xmlattr>.xmlns:ogs", "https://www.opengeosys.org");
    auto& geometry_set = pt.add("OpenGeoSysGLI", "");
 
    geometry_set.add("name", export_name);
    auto& pnts_tag = geometry_set.add("points", "");
    for (std::size_t k(0); k < pnts.size(); k++)
    {
        auto& pnt_tag = pnts_tag.add("point", "");
        pnt_tag.put("<xmlattr>.id", k);
        pnt_tag.put("<xmlattr>.x", (*pnts[k])[0]);
        pnt_tag.put("<xmlattr>.y", (*pnts[k])[1]);
        pnt_tag.put("<xmlattr>.z", (*pnts[k])[2]);
        std::string const& point_name(pnt_vec->getItemNameByID(k));
        if (!point_name.empty())
        {
            pnt_tag.put("<xmlattr>.name", point_name);
        }
    }
 
    addPolylinesToPropertyTree(geometry_set);
    addSurfacesToPropertyTree(geometry_set);
 
    boost::property_tree::xml_writer_settings<std::string> settings('\t', 1);
    write_xml(out, pt, settings);
    return true;
}

References _geo_objects, addPolylinesToPropertyTree(), addSurfacesToPropertyTree(), ERR(), BaseLib::IO::XMLInterface::export_name, GeoLib::PointVec::getItemNameByID(), GeoLib::GEOObjects::getPointVecObj(), GeoLib::TemplateVec< T >::getVector(), and BaseLib::IO::Writer::out.

Member Data Documentation

◆ _geo_objects

GeoLib::GEOObjects& GeoLib::IO::BoostXmlGmlInterface::_geo_objects

private

Definition at line 71 of file BoostXmlGmlInterface.h.

Referenced by addPolylinesToPropertyTree(), addSurfacesToPropertyTree(), readFile(), and write().

◆ _idx_map

std::map<std::size_t, std::size_t> GeoLib::IO::BoostXmlGmlInterface::_idx_map

private

Definition at line 70 of file BoostXmlGmlInterface.h.

Referenced by readPoints(), readPolylines(), and readSurfaces().

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

GeoLib/IO/XmlIO/Boost/BoostXmlGmlInterface.h
GeoLib/IO/XmlIO/Boost/BoostXmlGmlInterface.cpp

Detailed Description

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ BoostXmlGmlInterface()

◆ ~BoostXmlGmlInterface()

Member Function Documentation

◆ addPolylinesToPropertyTree()

◆ addSurfacesToPropertyTree()

◆ readFile()

◆ readPoints()

◆ readPolylines()

◆ readSurfaces()

◆ write()

Member Data Documentation

◆ _geo_objects

◆ _idx_map