react-native-nitro-xlsx 0.2.5 → 0.2.7

package/thirdparty/OpenXLSX/OpenXLSX/sources/XLFormula.cpp

@@ -0,0 +1,201 @@
+//
+// Created by Kenneth Balslev on 27/08/2021.
+//
+
+// ===== External Includes ===== //
+#include <cassert>
+
+// ===== OpenXLSX Includes ===== //
+#include "XLFormula.hpp"
+#include "XLException.hpp"
+#include "XLXmlParser.hpp"              // pugixml wrapper
+
+using namespace OpenXLSX;
+
+/**
+ * @details Constructor. Default implementation.
+ */
+XLFormula::XLFormula() = default;
+
+/**
+ * @details Copy constructor. Default implementation.
+ */
+XLFormula::XLFormula(const XLFormula& other) = default;
+
+/**
+ * @details Move constructor. Default implementation.
+ */
+XLFormula::XLFormula(XLFormula&& other) noexcept = default;
+
+/**
+ * @details Destructor. Default implementation.
+ */
+XLFormula::~XLFormula() = default;
+
+/**
+ * @details Copy assignment operator. Default implementation.
+ */
+XLFormula& XLFormula::operator=(const XLFormula& other) = default;
+
+/**
+ * @details Move assignment operator. Default implementation.
+ */
+XLFormula& XLFormula::operator=(XLFormula&& other) noexcept = default;
+
+/**
+ * @details Return the m_formulaString member variable.
+ */
+std::string XLFormula::get() const { return m_formulaString; }
+
+/**
+ * @details Set the m_formulaString member to an empty string.
+ */
+XLFormula& XLFormula::clear()
+{
+    m_formulaString = "";
+    return *this;
+}
+
+/**
+ * @details
+ */
+XLFormula::operator std::string() const { return get(); }
+
+/**
+ * @details [private] Constructor. Set the m_cell and m_cellNode objects.
+ */
+XLFormulaProxy::XLFormulaProxy(XLCell* cell, XMLNode* cellNode)
+ : m_cell(cell),
+   m_cellNode(cellNode)
+{
+    assert(cell);    // NOLINT
+}
+
+/**
+ * @details [private] Copy constructor
+ */
+XLFormulaProxy::XLFormulaProxy(const XLFormulaProxy& other)
+ : m_cell(other.m_cell),
+   m_cellNode(other.m_cellNode)
+{}
+
+/**
+ * @details [private] Move constructor. Default implementation.
+ */
+XLFormulaProxy::XLFormulaProxy(XLFormulaProxy&& other) noexcept = default;
+
+/**
+ * @details Destructor. Default implementation.
+ */
+XLFormulaProxy::~XLFormulaProxy() = default;
+
+/**
+ * @details Copy assignment operator. Calls the templated string assignment operator.
+ */
+XLFormulaProxy& XLFormulaProxy::operator=(const XLFormulaProxy& other)
+{
+    if (&other != this) {
+        *this = other.getFormula();
+    }
+
+    return *this;
+}
+
+/**
+ * @details [private] Move assignment operator. Default implementation.
+ */
+XLFormulaProxy& XLFormulaProxy::operator=(XLFormulaProxy&& other) noexcept = default;
+
+/**
+ * @details
+ */
+XLFormulaProxy::operator std::string() const { return get(); }
+
+/**
+ * @details Returns the underlying XLFormula object, by calling getFormula().
+ */
+XLFormulaProxy::operator XLFormula() const { return getFormula(); }
+
+/**
+ * @details Call the .get() function in the underlying XLFormula object.
+ */
+std::string XLFormulaProxy::get() const { return getFormula().get(); }
+
+/**
+ * @details If a formula node exists, it will be erased.
+ */
+XLFormulaProxy& XLFormulaProxy::clear()
+{
+    // ===== Check that the m_cellNode is valid.
+    assert(m_cellNode != nullptr);      // NOLINT
+    assert(not m_cellNode->empty());    // NOLINT
+
+    // ===== Remove the value node.
+    if (not m_cellNode->child("f").empty()) m_cellNode->remove_child("f");
+    return *this;
+}
+
+/**
+ * @details Convenience function for setting the formula. This method is called from the templated
+ * string assignment operator.
+ */
+void XLFormulaProxy::setFormulaString(const char* formulaString, bool resetValue) // NOLINT
+{
+    // ===== Check that the m_cellNode is valid.
+    assert(m_cellNode != nullptr);      // NOLINT
+    assert(not m_cellNode->empty());    // NOLINT
+
+    if (formulaString[0] == 0) {    // if formulaString is empty
+        m_cellNode->remove_child("f");    // clear the formula node
+        return;                           // and exit
+    }
+
+    // ===== If the cell node doesn't have formula or value child nodes, create them.
+    if (m_cellNode->child("f").empty()) m_cellNode->append_child("f");
+    if (m_cellNode->child("v").empty()) m_cellNode->append_child("v");
+
+    // ===== Remove the formula type and shared index attributes, if they exist.
+    m_cellNode->child("f").remove_attribute("t");
+    m_cellNode->child("f").remove_attribute("si");
+
+    // ===== Set the text of the formula and value nodes.
+    m_cellNode->child("f").text().set(formulaString);
+    if (resetValue) m_cellNode->child("v").text().set(0);
+
+    // BEGIN pull request #189
+    // ===== Remove cell type attribute so that it can be determined by Office Suite when next calculating the formula.
+    m_cellNode->remove_attribute("t");
+
+    // ===== Remove inline string <is> tag, in case previous type was "inlineStr".
+    m_cellNode->remove_child("is");
+
+    // ===== Ensure that the formula node <f> is the first child, listed before the value <v> node.
+    m_cellNode->prepend_move(m_cellNode->child("f"));
+    // END pull request #189
+}
+
+/**
+ * @details Creates and returns an XLFormula object, based on the formula string in the underlying
+ * XML document.
+ */
+XLFormula XLFormulaProxy::getFormula() const
+{
+    assert(m_cellNode != nullptr);      // NOLINT
+    assert(not m_cellNode->empty());    // NOLINT
+
+    const auto formulaNode = m_cellNode->child("f");
+
+    // ===== If the formula node doesn't exist, return an empty XLFormula object.
+    if (formulaNode.empty()) return XLFormula();
+
+    // ===== If the formula type is 'shared' or 'array', throw an exception.
+    if (not formulaNode.attribute("t").empty() ) {    // 2024-05-28: de-duplicated check (only relevant for performance,
+                                                      //  xml_attribute::value() returns an empty string for empty attributes)
+        if (std::string(formulaNode.attribute("t").value()) == "shared")
+            throw XLFormulaError("Shared formulas not supported.");
+        if (std::string(formulaNode.attribute("t").value()) == "array")
+            throw XLFormulaError("Array formulas not supported.");
+    }
+
+    return XLFormula(formulaNode.text().get());
+}

package/thirdparty/OpenXLSX/OpenXLSX/sources/XLMergeCells.cpp

@@ -0,0 +1,357 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  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 <algorithm>
+#include <iostream>
+
+// ===== OpenXLSX Includes ===== //
+#include "XLMergeCells.hpp"
+#include "XLCellReference.hpp"
+#include "XLException.hpp"
+#include "XLXmlParser.hpp"              // pugixml wrapper
+#include "utilities/XLUtilities.hpp"    // appendAndGetNode
+
+using namespace OpenXLSX;
+
+/**
+ * @details Constructs an uninitialized XLMergeCells object
+ */
+XLMergeCells::XLMergeCells() = default;
+
+/**
+ * @details Constructs a new XLMergeCells object. Invoked by XLWorksheet::mergeCells / ::unmergeCells
+ * @note Unfortunately, there is no easy way to persist the reference cache, this could be optimized - however, references access shouldn't
+ *       be much of a performance issue
+ */
+XLMergeCells::XLMergeCells(const XMLNode& rootNode, std::vector< std::string_view > const & nodeOrder)
+ : m_rootNode(std::make_unique<XMLNode>(rootNode)),
+   m_nodeOrder(nodeOrder),
+   m_mergeCellsNode() // std::unique_ptr initializes to nullptr
+{
+    if (m_rootNode->empty())
+        throw XLInternalError("XLMergeCells constructor: can not construct with an empty XML root node");
+
+    m_mergeCellsNode = std::make_unique<XMLNode>(m_rootNode->child("mergeCells"));
+    XMLNode mergeNode = m_mergeCellsNode->first_child_of_type(pugi::node_element);
+    while (not mergeNode.empty()) {
+        bool invalidNode = true;
+
+        // ===== For valid mergeCell nodes, add the reference to the reference cache
+        if (std::string(mergeNode.name()) == "mergeCell") {
+            std::string ref = mergeNode.attribute("ref").value();
+            if (ref.length() > 0) {
+                m_referenceCache.emplace_back(ref);
+                invalidNode = false;
+            }
+        }
+
+        // ===== Determine next element mergeNode
+        XMLNode nextNode = mergeNode.next_sibling_of_type(pugi::node_element);
+
+        // ===== In case of an invalid XML element: print an error and remove it from the XML, including whitespaces to the next sibling
+        if (invalidNode) { // if mergeNode is not named mergeCell or does not have a valid ref attribute: remove it from the XML
+            std::cerr << "XLMergeCells constructor: invalid child element, either name is not mergeCell or reference is invalid:" << std::endl;
+            mergeNode.print(std::cerr);
+            if (not nextNode.empty()) {
+                // delete whitespaces between mergeNode and nextNode
+                while (mergeNode.next_sibling() != nextNode) m_mergeCellsNode->remove_child(mergeNode.next_sibling());
+            }
+            m_mergeCellsNode->remove_child(mergeNode);
+        }
+
+        // ===== Advance to next element mergeNode
+        mergeNode = nextNode;
+    }
+
+    if (m_referenceCache.size() > 0) {
+        // ===== Ensure initial array count attribute / issue #351
+        XMLAttribute attr = m_mergeCellsNode->attribute("count");
+        if (attr.empty()) attr = m_mergeCellsNode->append_attribute("count");
+        attr.set_value(m_referenceCache.size());
+    }
+    else // no merges left
+        deleteAll(); // delete mergeCells element & re-initialize m_mergeCellsNode to a default-constructed XMLNode()
+}
+
+/**
+ * @details
+ */
+XLMergeCells::~XLMergeCells() = default;
+
+/**
+ * @details Copy constructor
+ */
+XLMergeCells::XLMergeCells(const XLMergeCells& other)
+{
+    m_rootNode = other.m_rootNode ? std::make_unique<XMLNode>( *other.m_rootNode ) : std::unique_ptr<XMLNode> {};
+    m_nodeOrder = other.m_nodeOrder;
+    m_mergeCellsNode = other.m_mergeCellsNode ? std::make_unique<XMLNode>( *other.m_mergeCellsNode ) : std::unique_ptr<XMLNode> {};
+    m_referenceCache = other.m_referenceCache;
+}
+
+/**
+ * @details Move constructor
+ */
+XLMergeCells::XLMergeCells(XLMergeCells&& other)
+{
+    m_rootNode = std::move( other.m_rootNode );
+    m_nodeOrder = std::move( other.m_nodeOrder );
+    m_mergeCellsNode = std::move( other.m_mergeCellsNode );
+    m_referenceCache = std::move( other.m_referenceCache );
+}
+
+/**
+ * @details Copy assignment operator
+ */
+XLMergeCells& XLMergeCells::operator=(const XLMergeCells& other)
+{
+    if (&other != this) {
+        XLMergeCells temp = other;  // copy-construct
+        *this = std::move(temp);    // move-assign & invalidate temp
+    }
+    return *this;
+}
+
+/**
+ * @details Move assignment operator
+ */
+XLMergeCells& XLMergeCells::operator=(XLMergeCells&& other)
+{
+    m_rootNode = std::move( other.m_rootNode );
+    m_nodeOrder = std::move( other.m_nodeOrder );
+    m_mergeCellsNode = std::move( other.m_mergeCellsNode );
+    m_referenceCache = std::move( other.m_referenceCache );
+    return *this;
+}
+
+/**
+ * @details
+ */
+bool XLMergeCells::valid() const { return ( m_rootNode != nullptr && not m_rootNode->empty() ); }
+
+
+namespace { // anonymous namespace: do not export any symbols from here
+    /**
+     * @brief Test if (range) reference overlaps with the cell window defined by topRow, firstCol, bottomRow, lastCol
+     * @return true in case of overlap, false if no overlap
+     */
+    bool XLReferenceOverlaps(std::string reference, uint32_t topRow, uint16_t firstCol, uint32_t bottomRow, uint16_t lastCol)
+    {
+        using namespace std::literals::string_literals;
+
+        size_t pos = reference.find_first_of(':'); // find split mark between top left and bottom right cell
+        if (pos < 2 || pos + 2 >= reference.length()) // range reference must have at least 2 characters before and after the colon
+            throw XLInputError("XLMergeCells::"s + __func__ + ": not a valid range reference: \""s + reference + "\""s);
+        XLCellReference refTL(reference.substr(0, pos));  // get top left cell reference
+        XLCellReference refBR(reference.substr(pos + 1)); // get bottom right cell reference
+
+        uint32_t refTopRow    = refTL.row();
+        uint16_t refFirstCol  = refTL.column();
+        uint32_t refBottomRow = refBR.row();
+        uint16_t refLastCol   = refBR.column();
+        if (refBottomRow < refTopRow || refLastCol < refFirstCol || (refBottomRow == refTopRow && refLastCol == refFirstCol))
+            throw XLInputError("XLMergeCells::"s + __func__ + ": not a valid range reference: \""s + reference + "\""s);
+
+// std::cout << __func__ << ":" << " reference is " << reference
+//    << " refTopRow is " << refTopRow << " refBottomRow is " << refBottomRow << " refFirstCol is " << refFirstCol << " refLastCol is " << refLastCol
+//    << " topRow is " << topRow << " bottomRow is " << bottomRow << " firstCol is " << firstCol << " lastCol is " << lastCol
+//    << std::endl;
+
+        // overlap
+        if (refTopRow <= bottomRow && refBottomRow >= topRow        // vertical overlap
+            && refFirstCol <= lastCol && refLastCol >= firstCol)    // horizontal overlap
+            return true;
+        return false; // otherwise: no overlap
+    }
+} // anonymous namespace
+
+/**
+ * @details Look up a merge index by the reference. If the reference does not exist, the returned index is XLMergeNotFound (-1).
+ */
+XLMergeIndex XLMergeCells::findMerge(const std::string& reference) const
+{
+    const auto iter = std::find_if(m_referenceCache.begin(), m_referenceCache.end(), [&](const std::string& ref) { return reference == ref; });
+
+    return iter == m_referenceCache.end() ? XLMergeNotFound : static_cast<XLMergeIndex>(std::distance(m_referenceCache.begin(), iter));
+}
+
+/**
+ * @details
+ */
+bool XLMergeCells::mergeExists(const std::string& reference) const { return findMerge(reference) >= 0; }
+
+/**
+ * @details Find the index of the merge of which cellRef is a part. If no such merge exists, the returned index is XLMergeNotFound (-1).
+ */
+XLMergeIndex XLMergeCells::findMergeByCell(const std::string& cellRef) const { return findMergeByCell(XLCellReference(cellRef)); }
+XLMergeIndex XLMergeCells::findMergeByCell(XLCellReference cellRef) const
+{
+    const auto iter = std::find_if(m_referenceCache.begin(), m_referenceCache.end(),
+    /**/                           [&](const std::string& ref) { // use XLReferenceOverlaps with a "range" that only contains cellRef
+    /**/                               return XLReferenceOverlaps( ref, cellRef.row(), cellRef.column(), cellRef.row(), cellRef.column());
+    /**/                           });
+
+    return iter == m_referenceCache.end() ? XLMergeNotFound : static_cast<XLMergeIndex>(std::distance(m_referenceCache.begin(), iter));
+}
+
+/**
+ * @details
+ */
+size_t XLMergeCells::count() const { return m_referenceCache.size(); }
+
+/**
+ * @details
+ */
+const char* XLMergeCells::merge(XLMergeIndex index) const
+{
+    if (index < 0 || static_cast<uint32_t>(index) >= m_referenceCache.size()) {
+        using namespace std::literals::string_literals;
+        throw XLInputError("XLMergeCells::"s + __func__ + ": index "s + std::to_string(index) + " is out of range"s);
+    }
+    return m_referenceCache[index].c_str();
+}
+
+/**
+ * @details Append a mergeCell by creating a new node in the XML file and adding the string to it. The index to the
+ * appended merge is returned
+ * Before appending a mergeCell entry with reference, check that reference does not overlap with any existing references
+ */
+XLMergeIndex XLMergeCells::appendMerge(const std::string& reference)
+{
+    using namespace std::literals::string_literals;
+
+    size_t referenceCacheSize = m_referenceCache.size();
+    if (referenceCacheSize >= XLMaxMergeCells)
+        throw XLInputError("XLMergeCells::"s + __func__ + ": exceeded max merge cells count "s + std::to_string(XLMaxMergeCells));
+
+    size_t pos = reference.find_first_of(':'); // find split mark between top left and bottom right cell
+    if (pos < 2 || pos + 2 >= reference.length()) // range reference must have at least 2 characters before and after the colon
+        throw XLInputError("XLMergeCells::"s + __func__ + ": not a valid range reference: \""s + reference + "\""s);
+    XLCellReference refTL(reference.substr(0, pos));  // get top left cell reference
+    XLCellReference refBR(reference.substr(pos + 1)); // get bottom right cell reference
+
+    uint32_t refTopRow    = refTL.row();
+    uint16_t refFirstCol  = refTL.column();
+    uint32_t refBottomRow = refBR.row();
+    uint16_t refLastCol   = refBR.column();
+    if (refBottomRow < refTopRow || refLastCol < refFirstCol || (refBottomRow == refTopRow && refLastCol == refFirstCol))
+        throw XLInputError("XLMergeCells::"s + __func__ + ": not a valid range reference: \""s + reference + "\""s);
+
+    for (std::string ref : m_referenceCache) {
+        if (XLReferenceOverlaps(ref, refTopRow, refFirstCol, refBottomRow, refLastCol))
+            throw XLInputError("XLMergeCells::"s + __func__ + ": reference \""s + reference
+            /**/                   + "\" overlaps with existing reference \""s + ref + "\""s);
+    }
+    // if execution gets here: no overlaps
+
+    if (m_mergeCellsNode->empty()) // create mergeCells element if needed
+        m_mergeCellsNode = std::make_unique<XMLNode>(appendAndGetNode(*m_rootNode, "mergeCells", m_nodeOrder));
+
+    // append new mergeCell element and set attribute ref
+    XMLNode insertAfter = m_mergeCellsNode->last_child_of_type(pugi::node_element);
+    XMLNode newMerge{};
+    if (insertAfter.empty()) newMerge = m_mergeCellsNode->prepend_child("mergeCell");
+    else                     newMerge = m_mergeCellsNode->insert_child_after("mergeCell", insertAfter);
+    if (newMerge.empty())
+        throw XLInternalError("XLMergeCells::"s + __func__ + ": failed to insert reference: \""s + reference + "\""s);
+    newMerge.append_attribute("ref").set_value(reference.c_str());
+
+    m_referenceCache.emplace_back(newMerge.attribute("ref").value()); // index of this element = previous referenceCacheSize
+
+    // ===== Update the array count attribute
+    XMLAttribute attr = m_mergeCellsNode->attribute("count");
+    if (attr.empty()) attr = m_mergeCellsNode->append_attribute("count");
+    attr.set_value(m_referenceCache.size());
+
+    return static_cast<XLMergeIndex>(referenceCacheSize);
+}
+
+/**
+ * @details Delete the merge at the given index
+ */
+void XLMergeCells::deleteMerge(XLMergeIndex index)
+{
+    using namespace std::literals::string_literals;
+
+    if (index < 0 || static_cast<uint32_t>(index) >= m_referenceCache.size())
+        throw XLInputError("XLMergeCells::"s + __func__ + ": index "s + std::to_string(index) + " is out of range"s);
+
+    XLMergeIndex curIndex = 0;
+    XMLNode node = m_mergeCellsNode->first_child_of_type(pugi::node_element);
+    while(curIndex < index && not node.empty()) {
+        node = node.next_sibling_of_type(pugi::node_element);
+        ++curIndex;
+    }
+    if (node.empty())
+        throw XLInternalError("XLMergeCells::"s + __func__ + ": mismatch between size of mergeCells XML node and internal reference cache"s);
+
+    // ===== node was found: delete preceeding whitespace nodes and the node itself
+    while (node.previous_sibling().type() == pugi::node_pcdata) m_mergeCellsNode->remove_child(node.previous_sibling());
+    m_mergeCellsNode->remove_child(node);
+
+    m_referenceCache.erase(m_referenceCache.begin() + curIndex);
+
+    if (m_referenceCache.size() > 0) {
+        // ===== Update the array count attribute
+        XMLAttribute attr = m_mergeCellsNode->attribute("count");
+        if (attr.empty()) attr = m_mergeCellsNode->append_attribute("count");
+        attr.set_value(m_referenceCache.size()); // update the array count attribute
+    }
+    else // no merges left
+        deleteAll(); // delete mergeCells element & re-initialize m_mergeCellsNode to a default-constructed XMLNode()
+}
+
+void XLMergeCells::deleteAll()
+{
+    m_referenceCache.clear();
+    m_rootNode->remove_child(*m_mergeCellsNode);
+    m_mergeCellsNode = std::make_unique<XMLNode>(XMLNode());
+}
+
+/**
+ * @details Print the underlying XML using pugixml::xml_node::print
+ */
+void XLMergeCells::print(std::basic_ostream<char>& ostr) const { m_mergeCellsNode->print(ostr); }