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 340 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 350 of file libxml_wrapper.h.

                  : _doc(xml_detail::createDocument(), &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 277 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 = xml_detail::toString(buffer, size);
    xmlFree(buffer);
    return result;
}

References logging::ERROR, LOG, max, and xml_detail::toString().

Here is the call 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 428 of file libxml_wrapper.h.

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

References max.

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 247 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)
    {
        const 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, LOG, and max.

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 262 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)
    {
        const 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, math::Vec3::length(), LOG, and max.

Here is the call 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 390 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, LOG, and max.

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 413 of file libxml_wrapper.h.

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

References max.

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 123 of file libxml_wrapper.cpp.

{
    const std::string dtd_string = bytesToString(dtdData);
    xmlDtdPtr dtd =
        xmlIOParseDTD(nullptr,
                      xmlParserInputBufferCreateMem(dtd_string.data(), checkedXmlInputSize(dtd_string.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)
    {
        const 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, LOG, and max.

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 165 of file libxml_wrapper.cpp.

{
    const std::string xsd_string = bytesToString(xsdData);
    const std::unique_ptr<xmlSchemaParserCtxt, decltype(&xmlSchemaFreeParserCtxt)> schema_parser_ctxt(
        xmlSchemaNewMemParserCtxt(xsd_string.data(), checkedXmlInputSize(xsd_string.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)
    {
        const 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)
    {
        const 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, LOG, and max.

---

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