react-native-nitro-xlsx 0.1.4 → 0.2.6

package/thirdparty/OpenXLSX/OpenXLSX/headers/XLFormula.hpp

@@ -0,0 +1,375 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  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.
+
+ */
+
+#ifndef OPENXLSX_XLFORMULA_HPP
+#define OPENXLSX_XLFORMULA_HPP
+
+#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
+#   pragma warning(push)
+#   pragma warning(disable : 4251)
+#   pragma warning(disable : 4275)
+#endif // _MSC_VER
+
+// ===== External Includes ===== //
+#include <iostream> // std::ostream
+#include <string>
+#include <variant>
+
+// ===== OpenXLSX Includes ===== //
+#include "OpenXLSX-Exports.hpp"
+#include "XLXmlParserForwardDeclarations.hpp"
+
+// ========== CLASS AND ENUM TYPE DEFINITIONS ========== //
+namespace OpenXLSX
+{
+    constexpr bool XLResetValue    = true;
+    constexpr bool XLPreserveValue = false;
+
+    //---------- Forward Declarations ----------//
+    class XLFormulaProxy;
+    class XLCell;
+
+    /**
+     * @brief The XLFormula class encapsulates the concept of an Excel formula. The class is essentially
+     * a wrapper around a std::string.
+     * @warning This class currently only supports simple formulas. Array formulas and shared formulas are
+     * not supported. Unfortunately, many spreadsheets have shared formulas, so this class is probably
+     * best used for adding formulas, not reading them from an existing spreadsheet.
+     * @todo Enable handling of shared and array formulas.
+     */
+    class OPENXLSX_EXPORT XLFormula
+    {
+        //---------- Friend Declarations ----------//
+
+        friend bool          operator==(const XLFormula& lhs, const XLFormula& rhs);
+        friend bool          operator!=(const XLFormula& lhs, const XLFormula& rhs);
+        friend std::ostream& operator<<(std::ostream& os, const XLFormula& value);
+
+    public:
+        /**
+         * @brief Constructor
+         */
+        XLFormula();
+
+        /**
+         * @brief Constructor, taking a string-type argument
+         * @tparam T Type of argument used. Must be string-type.
+         * @param formula The formula to initialize the object with.
+         */
+        template<typename T,
+                 typename = std::enable_if_t<
+                     std::is_same_v<std::decay_t<T>, std::string> || std::is_same_v<std::decay_t<T>, std::string_view> ||
+                     std::is_same_v<std::decay_t<T>, const char*> || std::is_same_v<std::decay_t<T>, char*>>>
+        explicit XLFormula(T formula)
+        {
+            // ===== If the argument is a const char *, use the argument directly; otherwise, assume it has a .c_str() function.
+            if constexpr (std::is_same_v<std::decay_t<T>, const char*> || std::is_same_v<std::decay_t<T>, char*>)
+                m_formulaString = formula;
+            else if constexpr (std::is_same_v<std::decay_t<T>, std::string_view>)
+                m_formulaString = std::string(formula);
+            else
+                m_formulaString = formula.c_str();
+        }
+
+        /**
+         * @brief Copy constructor.
+         * @param other Object to be copied.
+         */
+        XLFormula(const XLFormula& other);
+
+        /**
+         * @brief Move constructor.
+         * @param other Object to be moved.
+         */
+        XLFormula(XLFormula&& other) noexcept;
+
+        /**
+         * @brief Destructor.
+         */
+        ~XLFormula();
+
+        /**
+         * @brief Copy assignment operator.
+         * @param other Object to be copied.
+         * @return Reference to copied-to object.
+         */
+        XLFormula& operator=(const XLFormula& other);
+
+        /**
+         * @brief Move assignment operator.
+         * @param other Object to be moved.
+         * @return Reference to moved-to object.
+         */
+        XLFormula& operator=(XLFormula&& other) noexcept;
+
+        /**
+         * @brief Templated assignment operator, taking a string-type object as an argument.
+         * @tparam T Type of argument (only string-types are allowed).
+         * @param formula String containing the formula.
+         * @return Reference to the assigned-to object.
+         */
+        template<typename T,
+                 typename = std::enable_if_t<
+                     std::is_same_v<std::decay_t<T>, std::string> || std::is_same_v<std::decay_t<T>, std::string_view> ||
+                     std::is_same_v<std::decay_t<T>, const char*> || std::is_same_v<std::decay_t<T>, char*>>>
+        XLFormula& operator=(T formula)
+        {
+            XLFormula temp(formula);
+            std::swap(*this, temp);
+            return *this;
+        }
+
+        /**
+         * @brief Templated setter function, taking a string-type object as an argument.
+         * @tparam T Type of argument (only string-types are allowed).
+         * @param formula String containing the formula.
+         */
+        template<typename T,
+                 typename = std::enable_if_t<
+                     std::is_same_v<std::decay_t<T>, std::string> || std::is_same_v<std::decay_t<T>, std::string_view> ||
+                     std::is_same_v<std::decay_t<T>, const char*> || std::is_same_v<std::decay_t<T>, char*>>>
+        void set(T formula)
+        {
+            *this = formula;
+        }
+
+        /**
+         * @brief Get the formula as a std::string.
+         * @return A std::string with the formula.
+         */
+        std::string get() const;
+
+        /**
+         * @brief Conversion operator, for converting object to a std::string.
+         * @return The formula as a std::string.
+         */
+        operator std::string() const;    // NOLINT
+
+        /**
+         * @brief Clear the formula.
+         * @return Return a reference to the cleared object.
+         */
+        XLFormula& clear();
+
+    private:
+        std::string m_formulaString; /**< A std::string, holding the formula string.*/
+    };
+
+    /**
+     * @brief The XLFormulaProxy serves as a placeholder for XLFormula objects. This enable
+     * getting and setting formulas through the same interface.
+     */
+    class OPENXLSX_EXPORT XLFormulaProxy
+    {
+        friend class XLCell;
+        friend class XLFormula;
+
+    private:
+        /**
+         * @brief Constructor, taking pointers to the cell and cell node objects.
+         * @param cell Pointer to the associated cell object.
+         * @param cellNode Pointer to the associated cell node object.
+         */
+        XLFormulaProxy(XLCell* cell, XMLNode* cellNode);
+
+        /**
+         * @brief Copy constructor.
+         * @param other Object to be copied.
+         */
+        XLFormulaProxy(const XLFormulaProxy& other);
+
+        /**
+         * @brief Move constructor.
+         * @param other Object to be moved.
+         */
+        XLFormulaProxy(XLFormulaProxy&& other) noexcept;
+
+    public:
+        /**
+         * @brief Destructor
+         */
+        ~XLFormulaProxy();
+
+        /**
+         * @brief Copy assignment operator.
+         * @param other Object to be copied.
+         * @return A reference to the copied-to object.
+         */
+        XLFormulaProxy& operator=(const XLFormulaProxy& other);
+
+    private:
+        /**
+         * @brief Move assignment operator.
+         * @param other Object to be moved.
+         * @return A reference to the moved-to object.
+         */
+        XLFormulaProxy& operator=(XLFormulaProxy&& other) noexcept;
+
+    public:
+        /**
+         * @brief Templated assignment operator, taking a string-type argument.
+         * @tparam T Type of argument.
+         * @param formula The formula string to be assigned.
+         * @return A reference to the copied-to object.
+         */
+        template<
+            typename T,
+            typename = std::enable_if_t<std::is_same_v<std::decay_t<T>, XLFormula> || std::is_same_v<std::decay_t<T>, std::string> ||
+                                        std::is_same_v<std::decay_t<T>, std::string_view> || std::is_same_v<std::decay_t<T>, const char*> ||
+                                        std::is_same_v<std::decay_t<T>, char*>>>
+        XLFormulaProxy& operator=(T formula)
+        {
+            if constexpr (std::is_same_v<std::decay_t<T>, XLFormula>)
+                setFormulaString(formula.get().c_str());
+            else if constexpr (std::is_same_v<std::decay_t<T>, std::string>)
+                setFormulaString(formula.c_str());
+            else if constexpr (std::is_same_v<std::decay_t<T>, std::string_view>)
+                setFormulaString(std::string(formula).c_str());
+            else
+                setFormulaString(formula);
+
+            return *this;
+        }
+
+        /**
+         * @brief Templated setter, taking a string-type argument.
+         * @tparam T Type of argument.
+         * @param formula The formula string to be assigned.
+         */
+        template<typename T,
+                 typename = std::enable_if_t<
+                     std::is_same_v<std::decay_t<T>, std::string> || std::is_same_v<std::decay_t<T>, std::string_view> ||
+                     std::is_same_v<std::decay_t<T>, const char*> || std::is_same_v<std::decay_t<T>, char*>>>
+        void set(T formula)
+        {
+            *this = formula;
+        }
+
+        /**
+         * @brief Get the formula as a std::string.
+         * @return A std::string with the formula.
+         */
+        std::string get() const;
+
+        /**
+         * @brief Clear the formula.
+         * @return Return a reference to the cleared object.
+         */
+        XLFormulaProxy& clear();
+
+        /**
+         * @brief Conversion operator, for converting the object to a std::string.
+         * @return The formula as a std::string.
+         */
+        operator std::string() const;    // NOLINT
+
+        /**
+         * @brief Implicit conversion to XLFormula object.
+         * @return Returns the corresponding XLFormula object.
+         */
+        operator XLFormula() const;    // NOLINT
+
+    private:
+        /**
+         * @brief Set the formula to the given string.
+         * @param formulaString String holding the formula.
+         * @param resetValue if true (XLResetValue), the cell value will be set to 0, if false (XLPreserveValue), it will remain unchanged
+         */
+        void setFormulaString(const char* formulaString, bool resetValue = XLResetValue);
+
+        /**
+         * @brief Get the underlying XLFormula object.
+         * @return A XLFormula object.
+         * @throw XLFormulaError if the formula is of 'shared' or 'array' types.
+         */
+        XLFormula getFormula() const;
+
+        //---------- Private Member Variables ---------- //
+        XLCell*  m_cell;     /**< Pointer to the owning XLCell object. */
+        XMLNode* m_cellNode; /**< Pointer to corresponding XML cell node. */
+    };
+}    // namespace OpenXLSX
+
+// ========== FRIEND FUNCTION IMPLEMENTATIONS ========== //
+namespace OpenXLSX
+{
+    /**
+     * @brief
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    inline bool operator==(const XLFormula& lhs, const XLFormula& rhs) { return lhs.m_formulaString == rhs.m_formulaString; }
+
+    /**
+     * @brief
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    inline bool operator!=(const XLFormula& lhs, const XLFormula& rhs) { return lhs.m_formulaString != rhs.m_formulaString; }
+
+    /**
+     * @brief send a formula string to an ostream
+     * @param os the output destination
+     * @param value the formula to send to os
+     * @return
+     */
+    inline std::ostream& operator<<(std::ostream& os, const XLFormula& value) { return os << value.m_formulaString; }
+
+    /**
+     * @brief send a formula string to an ostream
+     * @param os the output destination
+     * @param value the formula proxy whose formula to send to os
+     * @return
+     */
+    inline std::ostream& operator<<(std::ostream& os, const XLFormulaProxy& value) { return os << value.get(); }
+}    // namespace OpenXLSX
+
+#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
+#   pragma warning(pop)
+#endif // _MSC_VER
+
+#endif    // OPENXLSX_XLFORMULA_HPP

package/thirdparty/OpenXLSX/OpenXLSX/headers/XLIterator.hpp

@@ -0,0 +1,40 @@
+//
+// Created by Kenneth Balslev on 22/08/2020.
+//
+
+#ifndef OPENXLSX_XLITERATOR_HPP
+#define OPENXLSX_XLITERATOR_HPP
+
+#include <memory> // std::unique_ptr
+
+namespace OpenXLSX
+{
+    enum class XLIteratorDirection { Forward, Reverse };
+    enum class XLIteratorLocation { Begin, End };
+
+    template<typename T>
+    class OPENXLSX_EXPORT XLReverseRange {
+    public:
+        /**
+         * @brief Construct a reverse range from an lvalue (existing variable)
+         */
+        XLReverseRange(T& rr)
+            : m_RR(nullptr),
+              m_rr(rr)
+        {}
+        /**
+         * @brief Construct a reverse range from an rvalue (temporary variable)
+         */
+        XLReverseRange(T&& rr)
+            : m_RR(std::make_unique<T>(rr)),
+              m_rr(*m_RR)
+        {}
+        typename T::reverse_iterator begin() { return m_rr.rbegin(); }
+        typename T::reverse_iterator end() { return m_rr.rend(); }
+    private:
+        std::unique_ptr<T> m_RR;
+        T& m_rr;
+    };
+}    // namespace OpenXLSX
+
+#endif    // OPENXLSX_XLITERATOR_HPP

package/thirdparty/OpenXLSX/OpenXLSX/headers/XLMergeCells.hpp

@@ -0,0 +1,216 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  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.
+
+ */
+
+#ifndef OPENXLSX_XLMERGECELLS_HPP
+#define OPENXLSX_XLMERGECELLS_HPP
+
+#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
+#   pragma warning(push)
+#   pragma warning(disable : 4251)
+#   pragma warning(disable : 4275)
+#endif // _MSC_VER
+
+#include <deque>
+#include <limits>     // std::numeric_limits
+#include <memory>     // std::unique_ptr
+#include <ostream>    // std::basic_ostream
+#include <string>
+#include <string_view>  // std::string_view
+#include <vector>       // std::vector
+
+// ===== OpenXLSX Includes ===== //
+#include "OpenXLSX-Exports.hpp"
+#include "XLCellReference.hpp"
+#include "XLXmlParserForwardDeclarations.hpp"
+
+namespace OpenXLSX
+{
+    typedef int32_t XLMergeIndex;
+    constexpr const XLMergeIndex XLMergeNotFound = -1;
+
+    // pull request #261: wrapped max in parentheses to prevent expansion of windows.h "max" macro
+    constexpr size_t XLMaxMergeCells = (std::numeric_limits< XLMergeIndex >::max)();
+
+    /**
+     * @brief This class encapsulate the Excel concept of <mergeCells>. Each worksheet that has merged cells has a list of
+     * (empty) <mergeCell> elements within that array, with a sole attribute ref="..." with ... being a range reference, e.g. A1:B5
+     * Unfortunately, since an empty <mergeCells> element is not allowed, the class must have access to the worksheet root node and
+     *  delete the <mergeCells> element each time the merge count is zero
+     */
+    class OPENXLSX_EXPORT XLMergeCells
+    {
+        //----------------------------------------------------------------------------------------------------------------------
+        //           Public Member Functions
+        //----------------------------------------------------------------------------------------------------------------------
+
+    public:
+        /**
+         * @brief
+         */
+        XLMergeCells();
+
+        /**
+         * @brief
+         * @param node The root node of the worksheet document - must not be an empty node
+         * @param nodeOrder the worksheet node sequence to respect when inserting <mergeCells> node
+         */
+        explicit XLMergeCells(const XMLNode& rootNode, std::vector< std::string_view > const & nodeOrder);
+
+        /**
+         * @brief Destructor
+         */
+        ~XLMergeCells();
+
+        /**
+         * @brief Copy constructor
+         * @param other
+         */
+        XLMergeCells(const XLMergeCells& other);
+
+        /**
+         * @brief Move constructor
+         * @param other
+         */
+        XLMergeCells(XLMergeCells&& other);
+
+        /**
+         * @brief Copy assignment operator
+         * @param other
+         * @return
+         */
+        XLMergeCells& operator=(const XLMergeCells& other);
+
+        /**
+         * @brief Move assignment operator
+         * @param other
+         * @return
+         */
+        XLMergeCells& operator=(XLMergeCells&& other);
+
+        /**
+         * @brief test if XLMergeCells has been initialized with a valid XMLNode
+         * @return true if m_rootNode is neither nullptr nor an empty XMLNode
+         */
+        bool valid() const;
+
+        /**
+         * @brief get the index of a <mergeCell> entry by its reference
+         * @param reference the reference to search for
+         * @return XLMergeNotFound (-1) if no such reference exists, 0-based index otherwise
+         */
+        XLMergeIndex findMerge(const std::string& reference) const;
+
+        /**
+         * @brief test if a mergeCell with reference exists, equivalent to findMerge(reference) >= 0
+         * @param reference the reference to find
+         * @return true if reference exists, false otherwise
+         */
+        bool mergeExists(const std::string& reference) const;
+
+        /**
+         * @brief get the index of a <mergeCell> entry of which cellReference is a part
+         * @param cellRef the cell reference (string or XLCellReference) to search for in the merged ranges
+         * @return XLMergeNotFound (-1) if no such reference exists, 0-based index otherwise
+         */
+        XLMergeIndex findMergeByCell(const std::string& cellRef) const;
+        XLMergeIndex findMergeByCell(XLCellReference cellRef) const;
+
+        /**
+         * @brief get the amount of entries in <mergeCells>
+         * @return the count of defined cell merges
+         */
+        size_t count() const;
+
+        /**
+         * @brief return the cell reference string for the given index
+         * @param index
+         * @return
+         */
+        const char* merge(XLMergeIndex index) const;
+
+        /**
+         * @brief Operator overload: allow [] as shortcut access to merge
+         */
+        const char* operator[](XLMergeIndex index) const { return merge(index); }
+
+        /**
+         * @brief Append a new merge to the list of merges
+         * @param reference The reference to append.
+         * @return An XLMergeIndex with the index of the appended merge
+         * @throws XLInputException if the reference would overlap with an existing reference
+         */
+        XLMergeIndex appendMerge(const std::string& reference);
+
+        /**
+         * @brief Delete the merge at the given index.
+         * @param index The index to delete
+         * @note Previously obtained merge indexes will be invalidated when calling deleteMerge
+         * @throws XLInputException if the index does not exist
+         */
+        void deleteMerge(XLMergeIndex index);
+
+        /**
+         * @brief Delete all merges of the worksheet
+         */
+        void deleteAll();
+
+        /**
+         * @brief print the XML contents of the mergeCells array using the underlying XMLNode print function
+         */
+        void print(std::basic_ostream<char>& ostr) const;
+
+    private:
+        std::unique_ptr<XMLNode> m_rootNode;         /**< An XMLNode object with the worksheet root node (document element) */
+        std::vector< std::string_view > m_nodeOrder; /**< worksheet XML root node required child sequence as passed into constructor */
+        std::unique_ptr<XMLNode> m_mergeCellsNode; /**< An XMLNode object with the mergeCells item */
+        std::deque<std::string> m_referenceCache;
+    };
+}    // namespace OpenXLSX
+
+#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
+#   pragma warning(pop)
+#endif // _MSC_VER
+
+#endif    // OPENXLSX_XLMERGECELLS_HPP