react-native-nitro-xlsx 0.2.6 → 0.2.7

package/thirdparty/OpenXLSX/OpenXLSX/headers/OpenXLSX/XLCell.hpp

@@ -0,0 +1,367 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  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_XLCELL_HPP
+#define OPENXLSX_XLCELL_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 <iostream> // std::ostream
+#include <ostream>  // std::basic_ostream
+#include <memory>
+
+// ===== OpenXLSX Includes ===== //
+#include "OpenXLSX-Exports.hpp"
+#include "XLCellReference.hpp"
+#include "XLCellValue.hpp"
+#include "XLFormula.hpp"
+#include "XLSharedStrings.hpp"
+#include "XLStyles.hpp"          // XLStyleIndex
+#include "XLXmlParserForwardDeclarations.hpp"
+
+// ========== CLASS AND ENUM TYPE DEFINITIONS ========== //
+namespace OpenXLSX
+{
+    // ===== Flags that can be passed to XLCell::clear as parameter keep, flags can be combined with bitwise OR
+    //                                  // Do not clear the cell's:
+    constexpr const uint32_t XLKeepCellStyle   =  1; // style (attribute s)
+    constexpr const uint32_t XLKeepCellType    =  2; // type (attribute t)
+    constexpr const uint32_t XLKeepCellValue   =  4; // value (child node v)
+    constexpr const uint32_t XLKeepCellFormula =  8; // formula (child node f)
+
+    class XLCellRange;
+
+    /**
+     * @brief An implementation class encapsulating the properties and behaviours of a spreadsheet cell.
+     */
+    class OPENXLSX_EXPORT XLCell
+    {
+        friend class XLCellIterator;
+        friend class XLCellValueProxy;
+        friend class XLRowDataIterator;
+        friend bool operator==(const XLCell& lhs, const XLCell& rhs);
+        friend bool operator!=(const XLCell& lhs, const XLCell& rhs);
+
+    public:
+        //---------- Public Member Functions ----------//
+
+        /**
+         * @brief Default constructor. Constructs a null object.
+         */
+        XLCell();
+
+        /**
+         * @brief
+         * @param cellNode
+         * @param sharedStrings
+         */
+        XLCell(const XMLNode& cellNode, const XLSharedStrings& sharedStrings);
+
+        /**
+         * @brief Copy constructor
+         * @param other The XLCell object to be copied.
+         * @note The copy constructor has been deleted, as it makes no sense to copy a cell. If the objective is to
+         * copy the getValue, create the the target object and then use the copy assignment operator.
+         */
+        XLCell(const XLCell& other);
+
+        /**
+         * @brief Move constructor
+         * @param other The XLCell object to be moved
+         * @note The move constructor has been deleted, as it makes no sense to move a cell.
+         */
+        XLCell(XLCell&& other) noexcept;
+
+        /**
+         * @brief Destructor
+         * @note Using the default destructor
+         */
+        virtual ~XLCell();
+
+        /**
+         * @brief Copy assignment operator
+         * @param other The XLCell object to be copy assigned
+         * @return A reference to the new object
+         * @note Copies only the cell contents, not the pointer to parent worksheet etc.
+         */
+        virtual XLCell& operator=(const XLCell& other);
+
+        /**
+         * @brief Move assignment operator
+         * @param other The XLCell object to be move assigned
+         * @return A reference to the new object
+         * @note The move assignment constructor has been deleted, as it makes no sense to move a cell.
+         */
+        virtual XLCell& operator=(XLCell&& other) noexcept;
+
+        /**
+         * @brief Copy contents of a cell, value & formula
+         * @param other The XLCell object from which to copy
+         */
+        void copyFrom(XLCell const& other);
+
+        /**
+         * @brief test if cell object has no (valid) content
+         * @return
+         */
+        bool empty() const;
+
+        /**
+         * @brief opposite of empty()
+         * @return
+         */
+        explicit operator bool() const;
+
+        /**
+         * @brief clear all cell content and attributes except for the cell reference (attribute r)
+         * @param keep do not clear cell properties whose flags are set in keep (XLKeepCellStyle, XLKeepCellType,
+         *              XLKeepCellValue, XLKeepCellFormula), flags can be combined with bitwise OR
+         * @note due to the way OOXML separates comments from the cells, this function will *not* clear a cell comment - refer to XLComments& XLSheet::comments() for that
+         */
+        void clear(uint32_t keep);
+
+        /**
+         * @brief
+         * @return
+         */
+        XLCellValueProxy& value();
+
+        /**
+         * @brief
+         * @return
+         */
+        const XLCellValueProxy& value() const;
+
+        /**
+         * @brief get the XLCellReference object for the cell.
+         * @return A reference to the cells' XLCellReference object.
+         */
+        XLCellReference cellReference() const;
+
+        /**
+         * @brief get the XLCell object from the current cell offset
+         * @return A reference to the XLCell object.
+         */
+        XLCell offset(uint16_t rowOffset, uint16_t colOffset) const;
+
+        /**
+         * @brief test if cell has a formula (XML) node, even if it is an empty string
+         * @return true if XML has a formula node, empty or not - otherwise false
+         */
+        bool hasFormula() const;
+
+        /**
+         * @brief
+         * @return
+         */
+        XLFormulaProxy& formula();
+
+        /**
+         * @brief
+         * @return
+         */
+        const XLFormulaProxy& formula() const;
+
+        /**
+         * @brief
+         */
+        std::string getString() const { return value().getString(); }
+
+        /**
+         * @brief Get the array index of xl/styles.xml:<styleSheet>:<cellXfs> for the style used in this cell.
+         *        This value is stored in the s attribute of a cell like so: s="2"
+         * @returns The index of the applicable format style
+         */
+        XLStyleIndex cellFormat() const;
+
+        /**
+         * @brief Set the cell style (attribute s) with a reference to the array index of xl/styles.xml:<styleSheet>:<cellXfs>
+         * @param cellFormatIndex The style to set, corresponding to the nidex of XLStyles::cellStyles()
+         * @returns True on success, false on failure
+         */
+        bool setCellFormat(XLStyleIndex cellFormatIndex);
+
+        /**
+         * @brief Print the XML contents of the XLCell using the underlying XMLNode print function
+         */
+        void print(std::basic_ostream<char>& ostr) const;
+
+    private:
+        /**
+         * @brief
+         * @param lhs
+         * @param rhs
+         * @return
+         */
+        static bool isEqual(const XLCell& lhs, const XLCell& rhs);
+
+        //---------- Private Member Variables ---------- //
+        std::unique_ptr<XMLNode> m_cellNode;      /**< A pointer to the root XMLNode for the cell. */
+        XLSharedStringsRef       m_sharedStrings; /**< */
+        XLCellValueProxy         m_valueProxy;    /**< */
+        XLFormulaProxy           m_formulaProxy;  /**< */
+    };
+
+    class OPENXLSX_EXPORT XLCellAssignable : public XLCell
+    {
+    public:
+        /**
+         * @brief Default constructor. Constructs a null object.
+         */
+        XLCellAssignable() : XLCell() {}
+
+        /**
+         * @brief Copy constructor. Constructs an assignable XLCell from an existing cell
+         * @param other the cell to construct from
+         */
+        XLCellAssignable (XLCell const & other);
+
+        /**
+         * @brief Move constructor. Constructs an assignable XLCell from a temporary (r)value
+         * @param other the cell to construct from
+         */
+        XLCellAssignable (XLCell && other);
+
+        // /**
+        //  * @brief Inherit all constructors with parameters from XLCell
+        //  */
+        // template<class base>
+        // // explicit XLCellAssignable(base b) : XLCell(b)
+        // // NOTE: BUG: explicit keyword triggers tons of compiler errors when << operator attempts to use an XLCell (implicit conversion works because << is overloaded for XLCellAssignable)
+        // XLCellAssignable(base b) : XLCell(b)
+        // {}
+
+        /**
+         * @brief Copy assignment operator
+         * @param other The XLCell object to be copy assigned
+         * @return A reference to the new object
+         * @note Copies only the cell contents, not the pointer to parent worksheet etc.
+         */
+        XLCellAssignable& operator=(const XLCell& other) override;
+        XLCellAssignable& operator=(const XLCellAssignable& other);
+
+        /**
+         * @brief Move assignment operator -> overrides XLCell copy operator, becomes a copy operator
+         * @param other The XLCell object to be copy assigned
+         * @return A reference to the new object
+         * @note Copies only the cell contents, not the pointer to parent worksheet etc.
+         */
+        XLCellAssignable& operator=(XLCell&& other) noexcept override;
+        XLCellAssignable& operator=(XLCellAssignable&& other) noexcept;
+
+        /**
+         * @brief Templated assignment operator.
+         * @tparam T The type of the value argument.
+         * @param value The value.
+         * @return A reference to the assigned-to object.
+         */
+        template<typename T,
+                 typename = std::enable_if_t<
+                     std::is_integral_v<T> || std::is_floating_point_v<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*> || std::is_same_v<T, XLDateTime>>>
+        XLCellAssignable& operator=(T value)
+        {
+            XLCell::value() = value; // forward implementation to templated XLCellValue& XLCellValue::operator=(T value)
+            return *this;
+        }
+    };
+}    // namespace OpenXLSX
+
+// ========== FRIEND FUNCTION IMPLEMENTATIONS ========== //
+namespace OpenXLSX
+{
+    /**
+     * @brief
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    inline bool operator==(const XLCell& lhs, const XLCell& rhs) { return XLCell::isEqual(lhs, rhs); }
+
+    /**
+     * @brief
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    inline bool operator!=(const XLCell& lhs, const XLCell& rhs) { return !XLCell::isEqual(lhs, rhs); }
+
+    /**
+     * @brief      ostream output of XLCell content as string
+     * @param os   the ostream destination
+     * @param c    the cell to output to the stream
+     * @return
+     */
+    inline std::ostream& operator<<(std::ostream& os, const XLCell& c)
+    {
+        os << c.getString();
+        // TODO: send to stream different data types based on cell data type
+        return os;
+    }
+
+    /**
+     * @brief      ostream output of XLCellAssignable content as string
+     * @param os   the ostream destination
+     * @param c    the cell to output to the stream
+     * @return
+     */
+    inline std::ostream& operator<<(std::ostream& os, const XLCellAssignable& c)
+    {
+        os << c.getString();
+        // TODO: send to stream different data types based on cell data type
+        return os;
+    }
+}    // 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_XLCELL_HPP

package/thirdparty/OpenXLSX/OpenXLSX/headers/OpenXLSX/XLCellIterator.hpp

@@ -0,0 +1,252 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  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_XLCELLITERATOR_HPP
+#define OPENXLSX_XLCELLITERATOR_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 <algorithm>
+
+#include "OpenXLSX-Exports.hpp"
+#include "XLCell.hpp"
+#include "XLCellReference.hpp"
+#include "XLIterator.hpp"
+#include "XLXmlParserForwardDeclarations.hpp"
+
+namespace OpenXLSX
+{
+    /**
+     * @brief locate the XML row node within sheetDataNode for the row at rowNumber
+     * @param sheetDataNode the XML sheetData node to search in
+     * @param rowNumber the number of the row to locate
+     * @return the XMLNode pointing to the row, or an empty XMLNode if the row does not exist
+     */
+    XMLNode findRowNode(XMLNode sheetDataNode, uint32_t rowNumber);
+
+    /**
+     * @brief locate the XML cell node within rownode for the cell at columnNumber
+     * @param rowNode the XML node of the row to search in
+     * @param columnNumber the column number of the cell to locate
+     * @return the XMLNode pointing to the cell, or an empty XMLNode if the cell does not exist
+     */
+    XMLNode findCellNode(XMLNode rowNode, uint16_t columnNumber);
+
+    class OPENXLSX_EXPORT XLCellIterator
+    {
+    public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type        = XLCell;
+        using difference_type   = int64_t;
+        using pointer           = XLCell*;
+        using reference         = XLCell&;
+
+        /**
+         * @brief
+         * @param cellRange
+         * @param loc
+         * @param colStyles is an optional vector with all column styles configured for the worksheet when the iterator is created.
+         *                  This vector - if provided - will be used to get default cell styles for newly created cells, instead of performing
+         *                   a potentially expensive lookup in <cols>
+         */
+        explicit XLCellIterator(const XLCellRange& cellRange, XLIteratorLocation loc, std::vector<XLStyleIndex> const * colStyles);
+
+        /**
+         * @brief
+         */
+        ~XLCellIterator();
+
+        /**
+         * @brief
+         * @param other
+         */
+        XLCellIterator(const XLCellIterator& other);
+
+        /**
+         * @brief
+         * @param other
+         */
+        [[maybe_unused]] XLCellIterator(XLCellIterator&& other) noexcept;
+
+        /**
+         * @brief
+         * @param other
+         * @return
+         */
+        XLCellIterator& operator=(const XLCellIterator& other);
+
+        /**
+         * @brief
+         * @param other
+         * @return
+         */
+        XLCellIterator& operator=(XLCellIterator&& other) noexcept;
+
+    private:    // ===== Switch to private method that is used by the XLIterator increment operator++ and the dereference operators * and ->
+        static constexpr const bool XLCreateIfMissing      = true;     // code readability for updateCurrentCell parameter createIfMissing
+        static constexpr const bool XLDoNotCreateIfMissing = false;    //   "
+        /**
+         * @brief update m_currentCell by fetching (or inserting) a cell at m_currentRow, m_currentColumn
+         * @param createIfMissing m_currentCell will only be inserted if createIfMissing is true
+         */
+        void updateCurrentCell(bool createIfMissing);
+
+    public:     // ===== Switch back to public methods
+        /**
+         * @brief
+         * @return
+         */
+        XLCellIterator& operator++();
+
+        /**
+         * @brief
+         * @return
+         */
+        XLCellIterator operator++(int);    // NOLINT
+
+        /**
+         * @brief
+         * @return
+         */
+        reference operator*();
+
+        /**
+         * @brief
+         * @return
+         */
+        pointer operator->();
+
+        /**
+         * @brief
+         * @param rhs
+         * @return
+         */
+        bool operator==(const XLCellIterator& rhs) const;
+
+        /**
+         * @brief
+         * @param rhs
+         * @return
+         */
+        bool operator!=(const XLCellIterator& rhs) const;
+
+        /**
+         * @brief determine whether the cell that the iterator points to exists (cell at m_currentRow, m_currentColumn)
+         * @return true if XML already has an entry for that cell, otherwise false
+         */
+        bool cellExists();
+
+        /**
+         * @brief determine whether iterator is at 1 beyond the last cell in range
+         * @return
+         * @note 28-07-2024: Removed const from return type (Troldal)
+         */
+        bool endReached() const { return m_endReached; }
+
+        /**
+         * @brief
+         * @param last
+         * @return
+         */
+        uint64_t distance(const XLCellIterator& last);
+
+        /**
+         * @brief get the XLCellReference::address corresponding to the current iterator position
+         * @return an XLCellReference::address, with m_bottomRight.col() + 1 for the beyond-the-end iterator
+         * @note 28-07-2024: Removed const from return type (Troldal)
+         */
+        std::string address() const;
+
+    private:
+        std::unique_ptr<XMLNode> m_dataNode;             /**< */
+        XLCellReference          m_topLeft;              /**< The cell reference of the first cell in the range */
+        XLCellReference          m_bottomRight;          /**< The cell reference of the last cell in the range */
+        XLSharedStringsRef       m_sharedStrings;        /**< */
+        bool                     m_endReached;           /**< */
+        std::unique_ptr<XMLNode> m_hintNode;             /**< The cell node of the last existing cell found up to current iterator position */
+        uint32_t                 m_hintRow;              /**<   the row number for m_hintCell */
+        XLCell                   m_currentCell;          /**< The cell to which the iterator is currently pointing, if it exists, otherwise an empty XLCell */
+        static constexpr const int XLNotLoaded  = 0;    // code readability for m_currentCellStatus
+        static constexpr const int XLNoSuchCell = 1;    //   "
+        static constexpr const int XLLoaded     = 2;    //   "
+        int                      m_currentCellStatus;    /**< Status of m_currentCell: XLNotLoaded, XLNoSuchCell or XLLoaded */
+        uint32_t                 m_currentRow;
+        uint16_t                 m_currentColumn;
+        std::vector<XLStyleIndex> const * m_colStyles;
+    };
+
+    /**
+     * @brief      ostream output of XLIterator position as XLCellReference::address
+     * @param os   the ostream destination
+     * @param it    the XLIterator whose position to send to the stream
+     * @return
+     */
+    inline std::ostream& operator<<(std::ostream& os, const XLCellIterator& it)
+    {
+        os << it.address();
+        return os;
+    }
+}    // namespace OpenXLSX
+
+// ===== Template specialization for std::distance.
+namespace std    // NOLINT
+{
+    using OpenXLSX::XLCellIterator;
+    template<>
+    inline std::iterator_traits<XLCellIterator>::difference_type distance<XLCellIterator>(XLCellIterator first, XLCellIterator last)
+    {
+        return static_cast<std::iterator_traits<XLCellIterator>::difference_type>(first.distance(last));
+    }
+}    // namespace std
+
+#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
+#   pragma warning(pop)
+#endif // _MSC_VER
+
+#endif    // OPENXLSX_XLCELLITERATOR_HPP