XLCellRange.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLCELLRANGE_HPP
#define OPENXLSX_XLCELLRANGE_HPP
 
#ifdef _MSC_VER
#    pragma warning(push)
#    pragma warning(disable : 4251)
#    pragma warning(disable : 4275)
#endif
 
// ===== External Includes ===== //
#include <memory>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLCell.hpp"
#include "XLCellIterator.hpp"
#include "XLCellReference.hpp"
#include "XLStyle.hpp"
#include "XLXmlParser.hpp"
 
namespace OpenXLSX
{
    class OPENXLSX_EXPORT XLCellRange
    {
        friend class XLCellIterator;
 
    public:
        XLCellRange();
 
        explicit XLCellRange(const XMLNode&         dataNode,
                             const XLCellReference& topLeft,
                             const XLCellReference& bottomRight,
                             const XLSharedStrings& sharedStrings);
 
        ~XLCellRange()                                       = default;
        XLCellRange(const XLCellRange& other)                = default;
        XLCellRange(XLCellRange&& other) noexcept            = default;
        XLCellRange& operator=(const XLCellRange& other)     = default;
        XLCellRange& operator=(XLCellRange&& other) noexcept = default;
 
        void fetchColumnStyles();
 
        [[nodiscard]] XLCellReference topLeft() const;
        [[nodiscard]] XLCellReference bottomRight() const;
 
        [[nodiscard]] std::string address() const;
 
        [[nodiscard]] uint32_t numRows() const;
        [[nodiscard]] uint16_t numColumns() const;
 
        [[nodiscard]] XLCellIterator begin() const;
        [[nodiscard]] XLCellIterator end() const;
 
        void applyStyle(const XLStyle& style);
 
        void setBorderOutline(XLLineStyle style, XLColor color);
 
        template<typename T>
        std::vector<std::vector<T>> getValue() const;
 
        template<typename T>
        void setValue(const std::vector<std::vector<T>>& matrix);
        [[nodiscard]] bool empty() const;
 
        void clear();
 
        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>>>
        XLCellRange& operator=(T value)
        {
            for (auto it = begin(); it != end(); ++it) it->value() = value;
            return *this;
        }
 
        XLCellRange& setFormat(XLStyleIndex cellFormatIndex);
 
        [[nodiscard]] XLCellRange intersect(const XLCellRange& other) const;
 
    private:
        XMLNode                   m_dataNode;
        XLCellReference           m_topLeft;
        XLCellReference           m_bottomRight;
        XLSharedStringsRef        m_sharedStrings;
        std::vector<XLStyleIndex> m_columnStyles; 
    };
}    // namespace OpenXLSX
 
#ifdef _MSC_VER
#    pragma warning(pop)
#endif
 
// Template implementations
namespace OpenXLSX
{
    template<typename T>
    std::vector<std::vector<T>> XLCellRange::getValue() const
    {
        std::vector<std::vector<T>> matrix;
        if (numRows() == 0 || numColumns() == 0) return matrix;
 
        matrix.resize(numRows(), std::vector<T>(numColumns()));
 
        uint32_t startRow = topLeft().row();
        uint16_t startCol = topLeft().column();
 
        for (auto& cell : *this) {
            uint32_t r   = cell.cellReference().row() - startRow;
            uint16_t c   = cell.cellReference().column() - startCol;
            matrix[r][c] = cell.value().get<T>();
        }
        return matrix;
    }
 
    template<typename T>
    void XLCellRange::setValue(const std::vector<std::vector<T>>& matrix)
    {
        if (matrix.empty() || matrix[0].empty()) return;
 
        uint32_t startRow = topLeft().row();
        uint16_t startCol = topLeft().column();
 
        for (auto& cell : *this) {
            uint32_t r = cell.cellReference().row() - startRow;
            uint16_t c = cell.cellReference().column() - startCol;
            if (r < matrix.size() && c < matrix[r].size()) { cell.value() = matrix[r][c]; }
        }
    }
}    // namespace OpenXLSX
#endif    // OPENXLSX_XLCELLRANGE_HPP