XLMergeCells.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLMERGECELLS_HPP
#define OPENXLSX_XLMERGECELLS_HPP
 
#ifdef _MSC_VER
#    pragma warning(push)
#    pragma warning(disable : 4251)
#    pragma warning(disable : 4275)
#endif
 
#include <deque>
#include <limits>
#include <memory>
#include <ostream>
#include <string>
#include <string_view>
#include <vector>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLCellReference.hpp"
#include "XLXmlParser.hpp"
 
namespace OpenXLSX
{
    typedef int32_t              XLMergeIndex;
    constexpr const XLMergeIndex XLMergeNotFound = -1;
 
    constexpr size_t XLMaxMergeCells = (std::numeric_limits<XLMergeIndex>::max)();
 
    class OPENXLSX_EXPORT XLMergeCells
    {
    public:
        struct XLRect
        {
            uint32_t top;
            uint16_t left;
            uint32_t bottom;
            uint16_t right;
 
            [[nodiscard]] bool contains(uint32_t row, uint16_t col) const noexcept
            { return row >= top && row <= bottom && col >= left && col <= right; }
 
            [[nodiscard]] bool overlaps(const XLRect& other) const noexcept
            { return top <= other.bottom && bottom >= other.top && left <= other.right && right >= other.left; }
        };
 
        struct XLMergeEntry
        {
            std::string reference;
            XLRect      rect;
        };
 
    public:
        XLMergeCells();
 
        explicit XLMergeCells(const XMLNode& rootNode, std::vector<std::string_view> const& nodeOrder);
 
        ~XLMergeCells()                                        = default;
        XLMergeCells(const XLMergeCells& other)                = default;
        XLMergeCells(XLMergeCells&& other) noexcept            = default;
        XLMergeCells& operator=(const XLMergeCells& other)     = default;
        XLMergeCells& operator=(XLMergeCells&& other) noexcept = default;
 
        [[nodiscard]] bool valid() const;
 
        [[nodiscard]] XLMergeIndex findMerge(std::string_view reference) const;
 
        [[nodiscard]] bool mergeExists(std::string_view reference) const;
 
        [[nodiscard]] XLMergeIndex findMergeByCell(std::string_view cellRef) const;
        [[nodiscard]] XLMergeIndex findMergeByCell(XLCellReference cellRef) const;
 
        [[nodiscard]] size_t count() const;
 
        [[nodiscard]] const char* merge(XLMergeIndex index) const;
 
        [[nodiscard]] const char* operator[](XLMergeIndex index) const { return merge(index); }
 
        XLMergeIndex appendMerge(const std::string& reference);
 
        void deleteMerge(XLMergeIndex index);
 
        void deleteAll();
 
        void shiftRows(int32_t delta, uint32_t fromRow);
 
        void shiftCols(int32_t delta, uint16_t fromCol);
 
        void print(std::basic_ostream<char>& ostr) const;
 
    private:
        XMLNode                       m_rootNode;
        std::vector<std::string_view> m_nodeOrder;
        XMLNode                       m_mergeCellsNode;
        std::deque<XLMergeEntry>      m_mergeCache; 
    };
}    // namespace OpenXLSX
 
#ifdef _MSC_VER
#    pragma warning(pop)
#endif
 
#endif    // OPENXLSX_XLMERGECELLS_HPP