XLRow.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLROW_HPP
#define OPENXLSX_XLROW_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
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLRowData.hpp"
 
namespace OpenXLSX
{
    class XLRowRange;
 
    class OPENXLSX_EXPORT XLRow
    {
        friend class XLRowIterator;
        friend class XLRowDataProxy;
        friend bool operator==(const XLRow& lhs, const XLRow& rhs);
        friend bool operator!=(const XLRow& lhs, const XLRow& rhs);
        friend bool operator<(const XLRow& lhs, const XLRow& rhs);
        friend bool operator>(const XLRow& lhs, const XLRow& rhs);
        friend bool operator<=(const XLRow& lhs, const XLRow& rhs);
        friend bool operator>=(const XLRow& lhs, const XLRow& rhs);
 
        //---------- PUBLIC MEMBER FUNCTIONS ----------//
    public:
        XLRow();
 
        XLRow(const XMLNode& rowNode, const XLSharedStrings& sharedStrings, XLWorksheet* wks = nullptr);
 
        XLRow(const XLRow& other);
 
        XLRow(XLRow&& other) noexcept;
 
        ~XLRow();
 
        XLRow& operator=(const XLRow& other);
 
        XLRow& operator=(XLRow&& other) noexcept;
 
        bool empty() const;
 
        explicit operator bool() const;
 
        double height() const;
 
        void setHeight(float height);
 
        float descent() const;
 
        void setDescent(float descent);
 
        bool isHidden() const;
 
        void setHidden(bool state);
 
        uint8_t outlineLevel() const;
 
        void setOutlineLevel(uint8_t level);
 
        bool isCollapsed() const;
 
        void setCollapsed(bool state);
 
        uint32_t rowNumber() const;
 
        uint16_t cellCount() const;
 
        XLRowDataProxy& values();
 
        const XLRowDataProxy& values() const;
 
        template<typename T>
        T values() const
        { return static_cast<T>(values()); }
 
        XLRowDataRange cells() const;
 
        XLRowDataRange cells(uint16_t cellCount) const;
 
        XLRowDataRange cells(uint16_t firstCell, uint16_t lastCell) const;
 
        XLCell findCell(uint16_t columNumber);
 
        XLStyleIndex format() const;
 
        bool setFormat(XLStyleIndex cellFormatIndex);
 
    private:
        static bool isEqual(const XLRow& lhs, const XLRow& rhs);
 
        static bool isLessThan(const XLRow& lhs, const XLRow& rhs);
 
        //---------- PRIVATE MEMBER VARIABLES ----------//
        std::unique_ptr<XMLNode> m_rowNode;       
        XLSharedStringsRef       m_sharedStrings; 
        XLRowDataProxy           m_rowDataProxy;  
        XLWorksheet*             m_wks{nullptr};  
    };
 
    class OPENXLSX_EXPORT XLRowIterator
    {
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type        = XLRow;
        using difference_type   = int64_t;
        using pointer           = XLRow*;
        using reference         = XLRow&;
 
        explicit XLRowIterator(const XLRowRange& rowRange, XLIteratorLocation loc);
 
        ~XLRowIterator();
 
        XLRowIterator(const XLRowIterator& other);
 
        XLRowIterator(XLRowIterator&& other) noexcept;
 
        XLRowIterator& operator=(const XLRowIterator& other);
 
        XLRowIterator& operator=(XLRowIterator&& other) noexcept;
 
    private
        :    // ===== Switch to private method that is used by the XLRowIterator increment operator++ and the dereference operators * and ->
        static constexpr const bool XLCreateIfMissing      = true;     // code readability for updateCurrentRow parameter createIfMissing
        static constexpr const bool XLDoNotCreateIfMissing = false;    //   "
        void updateCurrentRow(bool createIfMissing);
 
    public:    // ===== Switch back to public methods
        XLRowIterator& operator++();
 
        XLRowIterator operator++(int);    // NOLINT
 
        reference operator*();
 
        pointer operator->();
 
        bool operator==(const XLRowIterator& rhs) const;
 
        bool operator!=(const XLRowIterator& rhs) const;
 
        explicit operator bool() const;
 
        bool rowExists();
 
        bool endReached() const { return m_endReached; }
 
        uint32_t rowNumber() const { return m_endReached ? m_lastRow + 1 : m_currentRowNumber; }
 
    private:
        std::unique_ptr<XMLNode> m_dataNode;      
        uint32_t                 m_firstRow{1};   
        uint32_t                 m_lastRow{1};    
        XLRow                    m_currentRow;    
        XLSharedStringsRef       m_sharedStrings; 
        // helper variables for non-creating iterator functionality
        bool                       m_endReached;       
        XMLNode                    m_hintRow;          
        uint32_t                   m_hintRowNumber;    
        static constexpr const int XLNotLoaded = 0;    // code readability for m_currentRowStatus
        static constexpr const int XLNoSuchRow = 1;    //   "
        static constexpr const int XLLoaded    = 2;    //   "
        int                        m_currentRowStatus; 
        uint32_t                   m_currentRowNumber;
    };
 
    class OPENXLSX_EXPORT XLRowRange
    {
        friend class XLRowIterator;
 
        //----------------------------------------------------------------------------------------------------------------------
        //           Public Member Functions
        //----------------------------------------------------------------------------------------------------------------------
 
    public:
        explicit XLRowRange(const XMLNode& dataNode, uint32_t first, uint32_t last, const XLSharedStrings& sharedStrings);
 
        XLRowRange(const XLRowRange& other);
 
        XLRowRange(XLRowRange&& other) noexcept;
 
        ~XLRowRange();
 
        XLRowRange& operator=(const XLRowRange& other);
 
        XLRowRange& operator=(XLRowRange&& other) noexcept;
 
        uint32_t rowCount() const;
 
        XLRowIterator begin();
 
        XLRowIterator end();
 
        //----------------------------------------------------------------------------------------------------------------------
        //           Private Member Variables
        //----------------------------------------------------------------------------------------------------------------------
 
    private:
        std::unique_ptr<XMLNode> m_dataNode;      
        uint32_t                 m_firstRow;      
        uint32_t                 m_lastRow;       
        XLSharedStringsRef       m_sharedStrings; 
    };
 
}    // namespace OpenXLSX
 
namespace OpenXLSX
{
    inline bool operator==(const XLRow& lhs, const XLRow& rhs) { return XLRow::isEqual(lhs, rhs); }
 
    inline bool operator!=(const XLRow& lhs, const XLRow& rhs) { return !(lhs.m_rowNode == rhs.m_rowNode); }
 
    inline bool operator<(const XLRow& lhs, const XLRow& rhs) { return XLRow::isLessThan(lhs, rhs); }
 
    inline bool operator>(const XLRow& lhs, const XLRow& rhs) { return (rhs < lhs); }
 
    inline bool operator<=(const XLRow& lhs, const XLRow& rhs) { return !(lhs > rhs); }
 
    inline bool operator>=(const XLRow& lhs, const XLRow& rhs) { return !(lhs < rhs); }
 
}    // 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_XLROW_HPP