XmlDocument Class Reference

Class for managing XML documents. More...

#include "libxml_wrapper.h"

Public Member Functions
	XmlDocument ()
	Constructor for XmlDocument.
	~XmlDocument ()=default
	XmlDocument (const XmlDocument &)=delete
	XmlDocument (XmlDocument &&) noexcept=default
XmlDocument &	operator= (const XmlDocument &)=delete
XmlDocument &	operator= (XmlDocument &&) noexcept=default
bool	loadFile (std::string_view filename)
	Load an XML file into the document.
bool	loadString (const std::string &content)
	Load an XML document from a string in memory.
bool	saveFile (const std::string_view filename) const
	Save the document to a file.
std::string	dumpToString () const
	Dumps the document to a string.
void	setRootElement (const XmlElement &root) const
	Set the root element of the document.
XmlElement	getRootElement () const
	Get the root element of the document.
bool	validateWithDtd (std::span< const unsigned char > dtdData) const
	Validate the document using a DTD.
bool	validateWithXsd (std::span< const unsigned char > xsdData) const
	Validate the document using an XSD schema.

Detailed Description

Class for managing XML documents.

Definition at line 227 of file libxml_wrapper.h.

Constructor & Destructor Documentation

XmlDocument() [1/3]

XmlDocument::XmlDocument

(

)

Constructor for XmlDocument.

Exceptions

std::runtime_error

if the document creation fails.

Definition at line 237 of file libxml_wrapper.h.

                  : _doc(xmlNewDoc(reinterpret_cast<const xmlChar*>("1.0")), &xmlFreeDoc)
    {
        if (!_doc)
        {
            throw XmlException("Failed to create XML document.");
        }
    }

~XmlDocument()

XmlDocument::~XmlDocument ( )

default

XmlDocument() [2/3]

XmlDocument::XmlDocument ( const XmlDocument &  )

delete

XmlDocument() [3/3]

XmlDocument::XmlDocument ( XmlDocument &&  )

defaultnoexcept

Member Function Documentation

dumpToString()

std::string XmlDocument::dumpToString

(

)

const

Dumps the document to a string.

Returns

A string containing the XML document.

Definition at line 248 of file libxml_wrapper.cpp.

{
    if (!_doc)
    {
        LOG(logging::Level::ERROR, "Document is null; Cannot dump to string");
        return "";
    }
    xmlChar* buffer = nullptr;
    int size = 0;
    xmlDocDumpFormatMemory(_doc.get(), &buffer, &size, 1);
    if (buffer == nullptr)
    {
        LOG(logging::Level::ERROR, "Failed to dump XML document to memory buffer.");
        return "";
    }
    const std::string result(reinterpret_cast<const char*>(buffer), static_cast<size_t>(size));
    xmlFree(buffer);
    return result;
}

References logging::ERROR, and LOG.

Referenced by serial::world_to_xml_string().

Here is the caller graph for this function:

getRootElement()

XmlElement XmlDocument::getRootElement

(

)

const

Get the root element of the document.

Returns

The root element.

Exceptions

std::runtime_error

if the document is not loaded or the root element is missing.

Definition at line 315 of file libxml_wrapper.h.

    {
        if (!_doc)
        {
            throw std::runtime_error("Document not loaded");
        }
        const xmlNode* root = xmlDocGetRootElement(_doc.get());
        if (root == nullptr)
        {
            throw std::runtime_error("Root element not found");
        }
        return XmlElement(root);
    }

Referenced by serial::xml_parser_utils::collectIncludeElements(), radar::FileTarget::FileTarget(), mergeXmlDocuments(), serial::xml_parser_utils::processParsedDocument(), and removeIncludeElements().

Here is the caller graph for this function:

loadFile()

bool XmlDocument::loadFile

(

std::string_view

filename

)

Load an XML file into the document.

Parameters

filename

The name of the file to load.

Returns

True if the file was successfully loaded, otherwise false.

Definition at line 218 of file libxml_wrapper.cpp.

{
    xmlResetLastError();
    // Pass NOERROR and NOWARNING to prevent default terminal spam, so we handle it cleanly
    _doc.reset(xmlReadFile(filename.data(), nullptr, XML_PARSE_NOERROR | XML_PARSE_NOWARNING));
    if (!_doc)
    {
        std::string fancyError =
            formatError("XML Parsing Failed", getXmlLastErrorFormatted(), "Ensure the XML file is well-formed.");
        LOG(logging::Level::ERROR, "{}", fancyError);
        return false;
    }
    return true;
}

References logging::ERROR, and LOG.

Referenced by serial::xml_parser_utils::addIncludeFilesToMainDocument(), serial::xml_parser_utils::collectIncludeElements(), radar::FileTarget::FileTarget(), and serial::parseSimulation().

Here is the caller graph for this function:

loadString()

bool XmlDocument::loadString

(

const std::string &

content

)

Load an XML document from a string in memory.

Parameters

content

The string containing the XML document.

Returns

True if the string was successfully parsed, otherwise false.

Definition at line 233 of file libxml_wrapper.cpp.

{
    xmlResetLastError();
    _doc.reset(xmlReadMemory(content.c_str(), static_cast<int>(content.length()), "in_memory.xml", nullptr,
                             XML_PARSE_NOERROR | XML_PARSE_NOWARNING));
    if (!_doc)
    {
        std::string fancyError =
            formatError("XML Parsing Failed", getXmlLastErrorFormatted(), "Ensure the XML string is well-formed.");
        LOG(logging::Level::ERROR, "{}", fancyError);
        return false;
    }
    return true;
}

References logging::ERROR, and LOG.

Referenced by serial::parseSimulationFromString().

Here is the caller graph for this function:

operator=() [1/2]

XmlDocument & XmlDocument::operator= ( const XmlDocument &  )

delete

operator=() [2/2]

XmlDocument & XmlDocument::operator= ( XmlDocument &&  )

defaultnoexcept

saveFile()

bool XmlDocument::saveFile

(

const std::string_view

filename

)

const

Save the document to a file.

Parameters

filename

The name of the file to save to.

Returns

True if the file was successfully saved, otherwise false.

Definition at line 277 of file libxml_wrapper.h.

    {
        if (!_doc)
        {
            LOG(logging::Level::ERROR, "Document is null; Cannot save to file");
            return false;
        }
        return xmlSaveFormatFileEnc(filename.data(), _doc.get(), "UTF-8", 1) != -1;
    }

References logging::ERROR, and LOG.

setRootElement()

void XmlDocument::setRootElement

(

const XmlElement &

root

)

const

Set the root element of the document.

Parameters

root	The root element to set.

Exceptions

std::runtime_error

if the document is not created.

Definition at line 300 of file libxml_wrapper.h.

    {
        if (!_doc)
        {
            throw std::runtime_error("Document not created");
        }
        xmlDocSetRootElement(_doc.get(), root.getNode());
    }

References XmlElement::getNode().

Referenced by serial::world_to_xml_string().

Here is the call graph for this function:

Here is the caller graph for this function:

validateWithDtd()

bool XmlDocument::validateWithDtd

(

std::span< const unsigned char >

dtdData

)

const

Validate the document using a DTD.

Parameters

dtdData

The DTD data used for validation.

Returns

True if the document is valid according to the DTD.

Exceptions

XmlException

if the DTD is invalid or the validation fails.

Definition at line 97 of file libxml_wrapper.cpp.

{
    xmlDtdPtr dtd =
        xmlIOParseDTD(nullptr,
                      xmlParserInputBufferCreateMem(reinterpret_cast<const char*>(dtdData.data()),
                                                    static_cast<int>(dtdData.size()), XML_CHAR_ENCODING_UTF8),
                      XML_CHAR_ENCODING_UTF8);
    if (dtd == nullptr)
    {
        throw XmlException("Failed to parse DTD from memory.");
    }
 
    const std::unique_ptr<xmlValidCtxt, decltype(&xmlFreeValidCtxt)> validation_ctxt(xmlNewValidCtxt(),
                                                                                     xmlFreeValidCtxt);
    if (!validation_ctxt)
    {
        xmlFreeDtd(dtd);
        throw XmlException("Failed to create validation context.");
    }
 
    // Bind our custom error handler into the DTD Validation Context
    std::string dtdErrors;
    validation_ctxt->userData = &dtdErrors;
    validation_ctxt->error = libxmlGenericErrorCallback;
    validation_ctxt->warning = libxmlGenericErrorCallback;
 
    const bool is_valid = xmlValidateDtd(validation_ctxt.get(), _doc.get(), dtd) != 0;
    xmlFreeDtd(dtd);
 
    if (!is_valid)
    {
        std::string fancyError = formatError("XML DTD Validation Failed", dtdErrors,
                                             "Check your scenario XML tags and attributes against 'fers-xml.dtd'.");
        LOG(logging::Level::ERROR, "{}", fancyError);
        throw XmlException("XML failed DTD validation.");
    }
 
    return true;
}

References logging::ERROR, and LOG.

Referenced by serial::xml_parser_utils::validateXml().

Here is the caller graph for this function:

validateWithXsd()

bool XmlDocument::validateWithXsd

(

std::span< const unsigned char >

xsdData

)

const

Validate the document using an XSD schema.

Parameters

xsdData

The XSD data used for validation.

Returns

True if the document is valid according to the XSD schema.

Exceptions

XmlException

if the XSD is invalid or the validation fails.

Definition at line 137 of file libxml_wrapper.cpp.

{
    const std::unique_ptr<xmlSchemaParserCtxt, decltype(&xmlSchemaFreeParserCtxt)> schema_parser_ctxt(
        xmlSchemaNewMemParserCtxt(reinterpret_cast<const char*>(xsdData.data()), static_cast<int>(xsdData.size())),
        xmlSchemaFreeParserCtxt);
    if (!schema_parser_ctxt)
    {
        throw XmlException("Failed to create schema parser context.");
    }
 
    // Bind custom error handler into the Schema Parse Context
    std::string xsdParseErrors;
    xmlSchemaSetParserErrors(schema_parser_ctxt.get(), libxmlGenericErrorCallback, libxmlGenericErrorCallback,
                             &xsdParseErrors);
 
    const std::unique_ptr<xmlSchema, decltype(&xmlSchemaFree)> schema(xmlSchemaParse(schema_parser_ctxt.get()),
                                                                      xmlSchemaFree);
    if (!schema)
    {
        std::string fancyError =
            formatError("XSD Schema Parse Failed", xsdParseErrors, "The internal XSD schema is invalid.");
        LOG(logging::Level::FATAL, "{}", fancyError);
        throw XmlException("Failed to parse schema from memory.");
    }
 
    const std::unique_ptr<xmlSchemaValidCtxt, decltype(&xmlSchemaFreeValidCtxt)> schema_valid_ctxt(
        xmlSchemaNewValidCtxt(schema.get()), xmlSchemaFreeValidCtxt);
    if (!schema_valid_ctxt)
    {
        throw XmlException("Failed to create schema validation context.");
    }
 
    // Bind custom error handler into the Schema Validation Context
    std::string xsdErrors;
    xmlSchemaSetValidErrors(schema_valid_ctxt.get(), libxmlGenericErrorCallback, libxmlGenericErrorCallback,
                            &xsdErrors);
 
    if (const bool is_valid = xmlSchemaValidateDoc(schema_valid_ctxt.get(), _doc.get()) == 0; !is_valid)
    {
        std::string fancyError = formatError("XML XSD Validation Failed", xsdErrors,
                                             "Check your scenario XML tags and attributes against 'fers-xml.xsd'.");
        LOG(logging::Level::ERROR, "{}", fancyError);
        throw XmlException("XML failed XSD validation.");
    }
 
    return true;
}

References logging::ERROR, logging::FATAL, and LOG.

Referenced by serial::xml_parser_utils::validateXml().

Here is the caller graph for this function:

---

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

• packages/libfers/src/serial/libxml_wrapper.h
• packages/libfers/src/serial/libxml_wrapper.cpp