XLRowData.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLROWDATA_HPP
#define OPENXLSX_XLROWDATA_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 <deque>
#include <iterator>
#include <list>
#include <memory>
#include <vector>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLCell.hpp"
#include "XLConstants.hpp"
#include "XLException.hpp"
#include "XLIterator.hpp"
#include "XLXmlParser.hpp"
 
namespace OpenXLSX
{
    class XLRow;
    class XLRowDataRange;
 
    class OPENXLSX_EXPORT XLRowDataIterator
    {
        friend class XLRowDataRange;
 
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type        = XLCell;
        using difference_type   = int64_t;
        using pointer           = XLCell*;
        using reference         = XLCell&;
 
        ~XLRowDataIterator();
 
        XLRowDataIterator(const XLRowDataIterator& other);
 
        XLRowDataIterator(XLRowDataIterator&& other) noexcept;
 
        XLRowDataIterator& operator=(const XLRowDataIterator& other);
 
        XLRowDataIterator& operator=(XLRowDataIterator&& other) noexcept;
 
        XLRowDataIterator& operator++();
 
        XLRowDataIterator operator++(int);    // NOLINT
 
        reference operator*();
 
        pointer operator->();
 
        bool operator==(const XLRowDataIterator& rhs) const;
 
        bool operator!=(const XLRowDataIterator& rhs) const;
 
    private:
        XLRowDataIterator(const XLRowDataRange& rowDataRange, XLIteratorLocation loc);
 
        std::unique_ptr<XLRowDataRange> m_dataRange;   
        XMLNode m_cellNode;    
        XLCell                          m_currentCell; 
    };
 
    class OPENXLSX_EXPORT XLRowDataRange
    {
        friend class XLRowDataIterator;
        friend class XLRowDataProxy;
        friend class XLRow;
 
    public:
        XLRowDataRange(const XLRowDataRange& other);
 
        XLRowDataRange(XLRowDataRange&& other) noexcept;
 
        ~XLRowDataRange();
 
        XLRowDataRange& operator=(const XLRowDataRange& other);
 
        XLRowDataRange& operator=(XLRowDataRange&& other) noexcept;
 
        uint16_t size() const;
 
        XLRowDataIterator begin();
 
        XLRowDataIterator end();
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, XLDateTime>>>
        XLRowDataRange& operator=(T value)
        {
            // forward implementation to templated XLCellValue& XLCellValue::operator=(T value)
            for (auto it = begin(); it != end(); ++it) it->value() = value;
            return *this;
        }
 
    private:
        explicit XLRowDataRange(const XMLNode& rowNode, uint16_t firstColumn, uint16_t lastColumn, const XLSharedStrings& sharedStrings);
 
        explicit XLRowDataRange();
 
        std::unique_ptr<XMLNode> m_rowNode;       
        uint16_t                 m_firstCol{1};   
        uint16_t                 m_lastCol{1};    
        XLSharedStringsRef       m_sharedStrings; 
    };
 
    class OPENXLSX_EXPORT XLRowDataProxy
    {
        friend class XLRow;
 
    public:
        ~XLRowDataProxy();
 
        XLRowDataProxy& operator=(const XLRowDataProxy& other);
 
        XLRowDataProxy& operator=(const std::vector<XLCellValue>& values);
 
        XLRowDataProxy& operator=(const std::vector<bool>& values);
 
        template<typename T,
                 typename = std::enable_if_t<!std::is_same_v<T, XLRowDataProxy> &&
                                                 std::is_base_of_v<std::bidirectional_iterator_tag,
                                                                   typename std::iterator_traits<typename T::iterator>::iterator_category>,
                                             T>>
        XLRowDataProxy& operator=(const T& values)    // 2024-04-30: whitespace support
        {
            if (values.size() > MAX_COLS) throw XLOverflowError("Container size exceeds maximum number of columns.");
            if (values.size() == 0) return *this;
 
            // ===== If the container value_type is XLCellValue, the values can be copied directly.
            if constexpr (std::is_same_v<typename T::value_type, XLCellValue>) {
                // ===== First, delete the values in the first N columns.
                deleteCellValues(static_cast<uint16_t>(values.size()));    // 2024-04-30: whitespace support
 
                // ===== Then, prepend new cell nodes to current row node
                auto colNo = values.size();
                for (auto value = values.rbegin(); value != values.rend(); ++value) {    // NOLINT
                    prependCellValue(*value,
                                     static_cast<uint16_t>(colNo));    // 2024-04-30: whitespace support: this is safe because only
                                                                       // prependCellValue (with whitespace support) touches the row data
                    --colNo;
                }
            }
 
            // ===== If the container value_type is a POD type, use the overloaded operator= on each cell.
            else {
                auto range = XLRowDataRange(*m_rowNode, 1, static_cast<uint16_t>(values.size()), getSharedStrings());
                auto dst   = range.begin();    // 2024-04-30: whitespace support: safe because XLRowDataRange::begin invokes whitespace-safe
                                               // getCellNode for column 1
                auto src = values.begin();
 
                while (true) {
                    dst->value() = *src;
                    ++src;
                    if (src == values.end()) break;
                    ++dst;    // 2024-04-30: whitespace support: XLRowDataIterator::operator++ is whitespace-safe
                }
            }
 
            return *this;
        }
 
        // // BEGIN working template header
        //         template<
        //             typename T,
        //             typename std::enable_if<
        //                 !std::is_same_v< T, XLRowDataProxy >
        //                  and std::is_base_of_v< XMLNode, T >,
        //                 T
        //             >::type* = nullptr
        //         >
        // // END working template header
        //         XLRowDataProxy& operator=(const T& values)
        //         {
        // using namespace std::literals::string_literals;
        // throw XLInternalError( "templated XLRowDataProxy& operator=(const T& values) instantiated for an XMLNode ("s+ typeid(T).name() +
        // "), this function must be implemented then"s );
        //
        //         }
 
        operator std::vector<XLCellValue>() const;    // NOLINT
 
        operator std::deque<XLCellValue>() const;    // NOLINT
 
        operator std::list<XLCellValue>() const;    // NOLINT
 
        template<typename Container,
                 typename =
                     std::enable_if_t<!std::is_same_v<Container, XLRowDataProxy> &&
                                          std::is_base_of_v<std::bidirectional_iterator_tag,
                                                            typename std::iterator_traits<typename Container::iterator>::iterator_category>,
                                      Container>>
        explicit operator Container() const
        { return convertContainer<Container>(); }
 
        void clear();
 
    private:
        //---------- Private Member Functions ---------- //
 
        XLRowDataProxy(XLRow* row, XMLNode* rowNode);
 
        XLRowDataProxy(const XLRowDataProxy& other);
 
        XLRowDataProxy(XLRowDataProxy&& other) noexcept;
 
        XLRowDataProxy& operator=(XLRowDataProxy&& other) noexcept;
 
        std::vector<XLCellValue> getValues() const;
 
        const XLSharedStrings& getSharedStrings() const;
 
        void deleteCellValues(uint16_t count);
 
        void prependCellValue(const XLCellValue& value, uint16_t col);
 
        template<typename Container,
                 typename =
                     std::enable_if_t<!std::is_same_v<Container, XLRowDataProxy> &&
                                          std::is_base_of_v<std::bidirectional_iterator_tag,
                                                            typename std::iterator_traits<typename Container::iterator>::iterator_category>,
                                      Container>>
        Container convertContainer() const    // 2024-04-30: whitespace support
        {
            Container c;
            auto      it = std::inserter(c, c.end());
            for (const auto& v : getValues()) {
                // ===== If the value_type of the container is XLCellValue, the value can be assigned directly.
                if constexpr (std::is_same_v<typename Container::value_type, XLCellValue>) *it++ = v;
 
                // ===== If the value_type is something else, the underlying value has to be extracted from the XLCellValue object.
                // ===== Note that if the type contained in the XLCellValue object does not match the value_type, a bad_variant_access
                // ===== exception will be thrown.
                else
                    *it++ = v.get<typename Container::value_type>();
            }
            return c;
        }
 
        //---------- Private Member Variables ---------- //
 
        XLRow*   m_row{nullptr};     
        XMLNode* m_rowNode{nullptr}; 
    };
 
}    // 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_XLROWDATA_HPP