react-native-nitro-xlsx 0.2.5 → 0.2.6

package/thirdparty/OpenXLSX/OpenXLSX/sources/XLXmlData.cpp

@@ -0,0 +1,247 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  6MMMMb                              `MM(      )M' `MM'      6MMMMb\`MM(      )M'
+ 8P    Y8                              `MM.     d'   MM      6M'    ` `MM.     d'
+6M      Mb __ ____     ____  ___  __    `MM.   d'    MM      MM        `MM.   d'
+MM      MM `M6MMMMb   6MMMMb `MM 6MMb    `MM. d'     MM      YM.        `MM. d'
+MM      MM  MM'  `Mb 6M'  `Mb MMM9 `Mb    `MMd       MM       YMMMMb     `MMd
+MM      MM  MM    MM MM    MM MM'   MM     dMM.      MM           `Mb     dMM.
+MM      MM  MM    MM MMMMMMMM MM    MM    d'`MM.     MM            MM    d'`MM.
+YM      M9  MM    MM MM       MM    MM   d'  `MM.    MM            MM   d'  `MM.
+ 8b    d8   MM.  ,M9 YM    d9 MM    MM  d'    `MM.   MM    / L    ,M9  d'    `MM.
+  YMMMM9    MMYMMM9   YMMMM9 _MM_  _MM_M(_    _)MM_ _MMMMMMM MYMMMM9 _M(_    _)MM_
+            MM
+            MM
+           _MM_
+
+  Copyright (c) 2018, Kenneth Troldal Balslev
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  - Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  - Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  - Neither the name of the author nor the
+    names of any contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+// ===== External Includes ===== //
+#include <sstream>
+
+// ===== OpenXLSX Includes ===== //
+#include "XLDocument.hpp"
+#include "XLXmlData.hpp"
+#include "XLXmlParser.hpp"              // pugixml wrapper
+
+using namespace OpenXLSX;
+
+
+// ===== XLXmlSavingDeclaration
+
+/**
+ * @details
+ */
+XLXmlSavingDeclaration::XLXmlSavingDeclaration()
+    : m_version(XLXmlDefaultVersion),
+      m_encoding(XLXmlDefaultEncoding),
+      m_standalone(XLXmlNotStandalone)
+{}
+
+/**
+ * @details
+ */
+XLXmlSavingDeclaration::XLXmlSavingDeclaration(std::string version, std::string encoding, bool standalone)
+    : m_version(version),
+      m_encoding(encoding),
+      m_standalone(standalone)
+{}
+
+/**
+ * @details Copy constructor
+ */
+XLXmlSavingDeclaration::XLXmlSavingDeclaration(const XLXmlSavingDeclaration& other) = default;
+
+/**
+ * @details Move constructor
+ */
+XLXmlSavingDeclaration::XLXmlSavingDeclaration(XLXmlSavingDeclaration&& other) noexcept = default;
+
+/**
+ * @details
+ */
+XLXmlSavingDeclaration::~XLXmlSavingDeclaration() = default;
+
+/**
+ * @details Copy assignment operator
+ */
+XLXmlSavingDeclaration& XLXmlSavingDeclaration::operator=(const XLXmlSavingDeclaration& other) = default;
+
+/**
+ * @details Move assignment operator
+ */
+XLXmlSavingDeclaration& XLXmlSavingDeclaration::operator=(XLXmlSavingDeclaration&& other) noexcept = default;
+
+
+// ===== XLXmlData
+
+/**
+ * @details
+ */
+XLXmlData::XLXmlData() = default;
+
+/**
+ * @details
+ */
+XLXmlData::XLXmlData(XLDocument* parentDoc, const std::string& xmlPath, const std::string& xmlId, XLContentType xmlType)
+    : m_parentDoc(parentDoc),
+      m_xmlPath(xmlPath),
+      m_xmlID(xmlId),
+      m_xmlType(xmlType),
+      m_xmlDoc(std::make_unique<XMLDocument>())
+{
+    m_xmlDoc->reset();
+}
+
+/**
+ * @details
+ */
+XLXmlData::XLXmlData(XLXmlData&& other) noexcept = default;
+
+/**
+ * @details
+ */
+XLXmlData::~XLXmlData() = default;
+
+/**
+ * @details
+ */
+XLXmlData& XLXmlData::operator=(XLXmlData&& other) noexcept = default;
+
+/**
+ * @details
+ */
+void XLXmlData::setRawData(const std::string& data) // NOLINT
+{
+    m_xmlDoc->load_string(data.c_str(), pugi_parse_settings);
+}
+
+/**
+ * @details
+ * @note Default encoding for pugixml xml_document::save is pugi::encoding_auto, becomes pugi::encoding_utf8
+ */
+std::string XLXmlData::getRawData(XLXmlSavingDeclaration savingDeclaration) const
+{
+    XMLDocument *doc = const_cast<XMLDocument *>(getXmlDocument());
+
+    // ===== 2024-07-08: ensure that the default encoding UTF-8 is explicitly written to the XML document with a custom saving declaration
+    XMLNode saveDeclaration = doc->first_child();
+    if (saveDeclaration.empty() || saveDeclaration.type() != pugi::node_declaration) {    // if saving declaration node does not exist
+        doc->prepend_child(pugi::node_pcdata).set_value("\n");                                // prepend a line break
+        saveDeclaration = doc->prepend_child(pugi::node_declaration);                         // prepend a saving declaration
+    }
+
+    // ===== If a node_declaration could be fetched or created
+    if (not saveDeclaration.empty()) {
+        // ===== Fetch or create saving declaration attributes
+        XMLAttribute attrVersion = saveDeclaration.attribute("version");
+        if (attrVersion.empty())
+            attrVersion = saveDeclaration.append_attribute("version");
+        XMLAttribute attrEncoding = saveDeclaration.attribute("encoding");
+        if (attrEncoding.empty())
+            attrEncoding = saveDeclaration.append_attribute("encoding");
+        XMLAttribute attrStandalone = saveDeclaration.attribute("standalone");
+        if (attrStandalone.empty() && savingDeclaration.standalone_as_bool())    // only if standalone is set in passed savingDeclaration
+            attrStandalone = saveDeclaration.append_attribute("standalone");         // then make sure it exists
+
+        // ===== Set saving declaration attribute values (potentially overwriting existing values)
+        attrVersion = savingDeclaration.version().c_str();              // version="1.0" is XML default
+        attrEncoding = savingDeclaration.encoding().c_str();            // encoding="UTF-8" is XML default
+
+        if (not attrStandalone.empty()) // only save standalone attribute if previously existing or newly set to standalone="yes"
+            attrStandalone = savingDeclaration.standalone().c_str();    // standalone="no" is XML default
+    }
+
+    std::ostringstream ostr;
+    doc->save(ostr, "", pugi::format_raw);
+    return ostr.str();
+}
+
+/**
+ * @details
+ */
+XLDocument* XLXmlData::getParentDoc()
+{
+    return m_parentDoc;
+}
+
+/**
+ * @details
+ */
+const XLDocument* XLXmlData::getParentDoc() const
+{
+    return m_parentDoc;
+}
+
+/**
+ * @details
+ */
+std::string XLXmlData::getXmlPath() const
+{
+    return m_xmlPath;
+}
+
+/**
+ * @details
+ */
+std::string XLXmlData::getXmlID() const
+{
+    return m_xmlID;
+}
+
+/**
+ * @details
+ */
+XLContentType XLXmlData::getXmlType() const
+{
+    return m_xmlType;
+}
+
+/**
+ * @details
+ */
+XMLDocument* XLXmlData::getXmlDocument()
+{
+    if (!m_xmlDoc->document_element())
+        m_xmlDoc->load_string(m_parentDoc->extractXmlFromArchive(m_xmlPath).c_str(), pugi_parse_settings);
+
+    return m_xmlDoc.get();
+}
+
+/**
+ * @details
+ */
+const XMLDocument* XLXmlData::getXmlDocument() const
+{
+    if (!m_xmlDoc->document_element())
+        m_xmlDoc->load_string(m_parentDoc->extractXmlFromArchive(m_xmlPath).c_str(), pugi_parse_settings);
+
+    return m_xmlDoc.get();
+}

package/thirdparty/OpenXLSX/OpenXLSX/sources/XLXmlFile.cpp

@@ -0,0 +1,160 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  6MMMMb                              `MM(      )M' `MM'      6MMMMb\`MM(      )M'
+ 8P    Y8                              `MM.     d'   MM      6M'    ` `MM.     d'
+6M      Mb __ ____     ____  ___  __    `MM.   d'    MM      MM        `MM.   d'
+MM      MM `M6MMMMb   6MMMMb `MM 6MMb    `MM. d'     MM      YM.        `MM. d'
+MM      MM  MM'  `Mb 6M'  `Mb MMM9 `Mb    `MMd       MM       YMMMMb     `MMd
+MM      MM  MM    MM MM    MM MM'   MM     dMM.      MM           `Mb     dMM.
+MM      MM  MM    MM MMMMMMMM MM    MM    d'`MM.     MM            MM    d'`MM.
+YM      M9  MM    MM MM       MM    MM   d'  `MM.    MM            MM   d'  `MM.
+ 8b    d8   MM.  ,M9 YM    d9 MM    MM  d'    `MM.   MM    / L    ,M9  d'    `MM.
+  YMMMM9    MMYMMM9   YMMMM9 _MM_  _MM_M(_    _)MM_ _MMMMMMM MYMMMM9 _M(_    _)MM_
+            MM
+            MM
+           _MM_
+
+  Copyright (c) 2018, Kenneth Troldal Balslev
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  - Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  - Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  - Neither the name of the author nor the
+    names of any contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+// ===== External Includes ===== //
+
+// ===== OpenXLSX Includes ===== //
+#include "XLDocument.hpp"
+#include "XLXmlFile.hpp"
+#include "XLXmlParser.hpp"              // pugixml wrapper
+
+using namespace OpenXLSX;
+
+/**
+ * @details Default constructor
+ */
+XLXmlFile::XLXmlFile() = default;
+
+/**
+ * @details The constructor creates a new object with the parent XLDocument and the file path as input, with
+ * an optional input being a std::string with the XML data. If the XML data is provided by a string, any file with
+ * the same path in the .zip file will be overwritten upon saving of the document. If no xmlData is provided,
+ * the data will be read from the .zip file, using the given path.
+ */
+XLXmlFile::XLXmlFile(XLXmlData* xmlData) : m_xmlData(xmlData) {}
+
+/**
+ * @details Copy constructor
+ */
+XLXmlFile::XLXmlFile(const XLXmlFile& other) = default;
+
+/**
+ * @details Move constructor
+ */
+XLXmlFile::XLXmlFile(XLXmlFile&& other) noexcept = default;
+
+/**
+ * @details
+ */
+XLXmlFile::~XLXmlFile() = default;
+
+/**
+ * @details Copy assignment operator
+ */
+XLXmlFile& XLXmlFile::operator=(const XLXmlFile& other) = default;
+
+/**
+ * @details Move assignment operator
+ */
+XLXmlFile& XLXmlFile::operator=(XLXmlFile&& other) noexcept = default;
+
+/**
+ * @details This method sets the XML data with a std::string as input. The underlying XMLDocument reads the data.
+ * When envoking the load_string method in PugiXML, the flag 'parse_ws_pcdata' is passed along with the default flags.
+ * This will enable parsing of whitespace characters. If not set, Excel cells with only spaces will be returned as
+ * empty strings, which is not what we want. The downside is that whitespace characters such as \\n and \\t in the
+ * input xml file may mess up the parsing.
+ */
+void XLXmlFile::setXmlData(const std::string& xmlData) // NOLINT
+{
+    m_xmlData->setRawData(xmlData);
+}
+
+/**
+ * @details This method retrieves the underlying XML data as a std::string.
+ */
+std::string XLXmlFile::xmlData() const
+{
+    return m_xmlData->getRawData();
+}
+
+/**
+ * @details
+ */
+const XLDocument& XLXmlFile::parentDoc() const
+{
+    return *m_xmlData->getParentDoc();
+}
+
+/**
+ * @details
+ */
+XLDocument& XLXmlFile::parentDoc()
+{
+    return *m_xmlData->getParentDoc();
+}
+
+/**
+ * @details
+ */
+std::string XLXmlFile::relationshipID() const
+{
+    return m_xmlData->getXmlID();
+}
+
+/**
+ * @details This method returns a pointer to the underlying XMLDocument resource.
+ */
+XMLDocument& XLXmlFile::xmlDocument()
+{
+    return const_cast<XMLDocument&>(static_cast<const XLXmlFile*>(this)->xmlDocument());    // NOLINT
+    // return *m_xmlData->getXmlDocument();    // <- why not this easy version?
+}
+
+/**
+ * @details This method returns a pointer to the underlying XMLDocument resource as const.
+ */
+const XMLDocument& XLXmlFile::xmlDocument() const
+{
+    return *m_xmlData->getXmlDocument();
+}
+
+/**
+ * @details provide access to the underlying XLXmlData::getXmlPath() function
+ */
+std::string XLXmlFile::getXmlPath() const
+{
+    return m_xmlData == nullptr ? "" : m_xmlData->getXmlPath();
+}

package/thirdparty/OpenXLSX/OpenXLSX/sources/XLXmlParser.cpp

@@ -0,0 +1,261 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  6MMMMb                              `MM(      )M' `MM'      6MMMMb\`MM(      )M'
+ 8P    Y8                              `MM.     d'   MM      6M'    ` `MM.     d'
+6M      Mb __ ____     ____  ___  __    `MM.   d'    MM      MM        `MM.   d'
+MM      MM `M6MMMMb   6MMMMb `MM 6MMb    `MM. d'     MM      YM.        `MM. d'
+MM      MM  MM'  `Mb 6M'  `Mb MMM9 `Mb    `MMd       MM       YMMMMb     `MMd
+MM      MM  MM    MM MM    MM MM'   MM     dMM.      MM           `Mb     dMM.
+MM      MM  MM    MM MMMMMMMM MM    MM    d'`MM.     MM            MM    d'`MM.
+YM      M9  MM    MM MM       MM    MM   d'  `MM.    MM            MM   d'  `MM.
+ 8b    d8   MM.  ,M9 YM    d9 MM    MM  d'    `MM.   MM    / L    ,M9  d'    `MM.
+  YMMMM9    MMYMMM9   YMMMM9 _MM_  _MM_M(_    _)MM_ _MMMMMMM MYMMMM9 _M(_    _)MM_
+            MM
+            MM
+           _MM_
+
+  Copyright (c) 2018, Kenneth Troldal Balslev
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  - Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  - Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  - Neither the name of the author nor the
+    names of any contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+// ===== External Includes ===== //
+#include <cstring>      // strlen, memcpy, strcpy
+
+// // ===== OpenXLSX Includes ===== //
+#include "XLXmlParser.hpp"
+
+namespace OpenXLSX
+{
+    bool NO_XML_NS = true; // default: no XML namespaces
+    /**
+     * @details this function is meaningless when PUGI_AUGMENTED is not defined / used
+     */
+    bool enable_xml_namespaces()
+    {
+#       ifdef PUGI_AUGMENTED
+            NO_XML_NS = false;
+            return true;
+#       else
+            return false;
+#       endif
+    }
+    /**
+     * @details this function is meaningless when PUGI_AUGMENTED is not defined / used
+     */
+    bool disable_xml_namespaces()
+    {
+#       ifdef PUGI_AUGMENTED
+            NO_XML_NS = true;
+            return true;
+#       else
+            return false;
+#       endif
+    }
+
+
+    /**
+     * @brief provide a PUGIXML_WCHAR_MODE compatible strequal
+     * @param src operand
+     * @param dst operand
+     * @return true if operands are not null and equal
+     */
+    bool strequal(const pugi::char_t* src, const pugi::char_t* dst)
+    {
+        if( !src || !dst ) return false;
+#ifdef PUGIXML_WCHAR_MODE
+        return wcscmp(src, dst) == 0;
+#else
+        return strcmp(src, dst) == 0;
+#endif
+    }
+
+    /**
+     * @details return the node name without a potentially(!) existing namespace
+     */
+    const pugi::char_t* XMLNode::name_without_namespace(const pugi::char_t* name_) const
+    {
+        if (NO_XML_NS) return name_;    // if node namespaces are not stripped: return immediately
+        int pos = 0;
+        while (name_[pos] && name_[pos] != ':') ++pos;    // find namespace delimiter
+        if (!name_[pos]) return name_;                    // if no delimiter found: return unmodified name
+        return name_ + pos + 1;                           // if delimiter was found: return the name minus the namespace
+    }
+
+    /**
+     * @details for creation of node children: copy this node's namespace without thread safety, using
+     *  a static character array to avoid smart pointer performance impact
+     */
+    const pugi::char_t* XMLNode::namespaced_name_char(const pugi::char_t* name_, bool force_ns) const
+    {
+        // ===== If node has no namespace: Early pass-through return
+        if (!name_begin || force_ns) return name_;
+        if( name_begin + strlen(name_) > XLMaxNamespacedNameLen ) {
+        using namespace std::literals::string_literals;
+        throw XLException("OpenXLSX_xml_node::"s + __func__ + ": strlen of "s + name_ + " exceeds XLMaxNamespacedNameLen "s + std::to_string(XLMaxNamespacedNameLen));
+        }
+
+        static pugi::char_t namespaced_name_[ XLMaxNamespacedNameLen + 1 ]; // static memory allocation for concatenating node namespace and name_
+
+        // ===== If node has a namespace: create a namespaced version of name_
+        memcpy(namespaced_name_, xml_node::name(), name_begin);    // copy the node namespace
+        strcpy(namespaced_name_ + name_begin, name_);              // concatenate the name_ including the terminating zero
+        return namespaced_name_;
+    }
+
+    /**
+     * @details for creation of node children: copy this node's namespace with thread safety, using
+     *  smart pointer with a trade-off for ~15-20% performance impact (increased runtime)
+     * @note // 2024-08-18: made lambda parameter unnamed to eliminate -Wunused-parameter
+     */
+    std::shared_ptr<pugi::char_t> XMLNode::namespaced_name_shared_ptr(const pugi::char_t* name_, bool force_ns) const
+    {
+        // ===== If node has no namespace: Early pass-through return with noop-deleter
+        if (!name_begin || force_ns) return std::shared_ptr<pugi::char_t>(const_cast<pugi::char_t*>(name_), [](pugi::char_t*){});
+
+        // ===== If node has a namespace: allocate memory for concatenation and create a namespaced version of name_
+        std::shared_ptr<pugi::char_t> namespaced_name_ (new pugi::char_t[name_begin + strlen(name_) + 1], std::default_delete<pugi::char_t[]>());
+        memcpy(namespaced_name_.get(), xml_node::name(), name_begin);    // copy the node namespace
+        strcpy(namespaced_name_.get() + name_begin, name_);          // concatenate the name_ with terminating zero
+        return namespaced_name_;
+    }
+
+    /**
+     * @details determine the first xml_node child whose xml_node_type matches type_
+     * @date 2024-04-25
+     */
+    XMLNode XMLNode::first_child_of_type(pugi::xml_node_type type_) const
+    {
+        if (_root) {
+            XMLNode x = first_child();
+            XMLNode l = last_child();
+            while (x != l && x.type() != type_) x = x.next_sibling();
+            if (x.type() == type_)
+                return XMLNode(x);
+        }
+        return XMLNode();    // if no node matching type_ was found: return an empty node
+    }
+
+    /**
+     * @details determine the last xml_node child whose xml_node_type matches type_
+     * @date 2024-04-25
+     */
+    XMLNode XMLNode::last_child_of_type(pugi::xml_node_type type_) const
+    {
+        if (_root) {
+            XMLNode f = first_child();
+            XMLNode x = last_child();
+            while (x != f && x.type() != type_) x = x.previous_sibling();
+            if (x.type() == type_)
+                return XMLNode(x);
+        }
+        return XMLNode();    // if no node matching type_ was found: return an empty node
+    }
+
+    /**
+     * @details determine amount of xml_node children child whose xml_node_type matches type_
+     * @date 2024-04-28
+     */
+    size_t XMLNode::child_count_of_type(pugi::xml_node_type type_) const
+    {
+        size_t counter = 0;
+        if (_root) {
+            XMLNode c = first_child_of_type(type_);
+            while (!c.empty()) {
+                ++counter;
+                c = c.next_sibling_of_type(type_);
+            }
+        }
+        return counter;
+    }
+
+    /**
+     * @details determine the next xml_node sibling whose xml_node_type matches type_
+     * @date 2024-04-26
+     */
+    XMLNode XMLNode::next_sibling_of_type(pugi::xml_node_type type_) const
+    {
+        if (_root) {
+            XMLNode next = next_sibling();
+            while (next && next.type() != type_) next = next.next_sibling();
+            if (next)
+                return XMLNode(next);
+        }
+        return XMLNode();    // if no node matching type_ was found: return an empty node
+    }
+
+    /**
+     * @details determine the previous xml_node sibling whose xml_node_type matches type_
+     * @date 2024-04-26
+     */
+    XMLNode XMLNode::previous_sibling_of_type(pugi::xml_node_type type_) const
+    {
+        if (_root) {
+            XMLNode prev = previous_sibling();
+            while (prev.next_sibling() && prev.type() != type_) prev = prev.previous_sibling();
+            if (prev.next_sibling())
+                return XMLNode(prev);
+        }
+        return XMLNode();    // if no node matching type_ was found: return an empty node
+    }
+
+    /**
+     * @details determine the next xml_node sibling whose name() matches name_ and xml_node_type matches type_
+     * @date 2024-04-26
+     */
+    XMLNode XMLNode::next_sibling_of_type(const pugi::char_t* name_, pugi::xml_node_type type_) const
+    {
+        if (_root) {
+            for (XMLNode i = next_sibling(); i; i = i.next_sibling())
+            {
+                const pugi::char_t* iname = i.name();
+                if (iname && OpenXLSX::strequal(name_, iname) && i.type() == type_)
+                    return XMLNode(i);
+            }
+        }
+        return XMLNode();    // if no node matching type_ was found: return an empty node
+    }
+
+    /**
+     * @details determine the previous xml_node sibling whose name() matches name_ and xml_node_type matches type_
+     * @date 2024-04-26
+     */
+    XMLNode XMLNode::previous_sibling_of_type(const pugi::char_t* name_, pugi::xml_node_type type_) const
+    {
+        if (_root) {
+            for (XMLNode i = previous_sibling(); i.next_sibling(); i = i.previous_sibling())
+            {
+                const pugi::char_t* iname = i.name();
+                if (iname && OpenXLSX::strequal(name_, iname) && i.type() == type_)
+                    return XMLNode(i);
+            }
+        }
+        return XMLNode();    // if no node matching type_ was found: return an empty node
+    }
+
+}    // namespace OpenXLSX
+