XLTables.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLTABLES_HPP
#define OPENXLSX_XLTABLES_HPP
 
// ===== External Includes ===== //
#include <cstdint>    // uint8_t, uint16_t, uint32_t
#include <ostream>    // std::basic_ostream
#include <string>
#include <string_view>
#include <vector>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLAutoFilter.hpp"
#include "XLException.hpp"
#include "XLTableColumn.hpp"
#include "XLXmlData.hpp"
#include "XLXmlFile.hpp"
 
namespace OpenXLSX
{
    class XLWorksheet;
    class XLCellRange;
 
    struct XLSlicerOptions
    {
        std::string name    = "";     // Defaults to column name if empty
        std::string caption = "";     // Defaults to column name if empty
        uint32_t    width   = 144;    // pixels
        uint32_t    height  = 200;    // pixels
        int32_t     offsetX = 0;      // pixels
        int32_t     offsetY = 0;      // pixels
    };
 
    class XLTable;
 
    class OPENXLSX_EXPORT XLTableCollection
    {
        friend class XLWorksheet;
 
    public:
        XLTableCollection() = default;
 
        explicit XLTableCollection(XMLNode node, XLWorksheet* worksheet);
 
        size_t count() const;
 
        XLTable operator[](size_t index) const;
 
        XLTable table(std::string_view name) const;
 
        XLTable add(std::string_view name, std::string_view range);
 
        XLTable add(std::string_view name, const XLCellRange& range);
 
        bool valid() const;
 
    private:
        XMLNode                      m_sheetNode;
        XLWorksheet*                 m_worksheet{nullptr};
        mutable std::vector<XLTable> m_tables;
        mutable bool                 m_loaded{false};
 
        void load() const;
    };
 
    class OPENXLSX_EXPORT XLTable : public XLXmlFile
    {
        friend class XLTableCollection;
        friend class XLWorksheet;
 
    public:
        XLTable() : XLXmlFile(nullptr) {};
 
        XLTable(XLXmlData* xmlData);
 
        XLTable(const XLTable& other) = default;
 
        XLTable(XLTable&& other) noexcept = default;
 
        ~XLTable() = default;
 
        XLTable& operator=(const XLTable&) = default;
 
        XLTable& operator=(XLTable&& other) noexcept = default;
 
        uint32_t id() const;
 
        std::string name() const;
 
        void setName(std::string_view name);
 
        std::string displayName() const;
 
        void setDisplayName(std::string_view name);
 
        std::string rangeReference() const;
 
        void setRangeReference(std::string_view ref);
 
        std::string styleName() const;
 
        void setStyleName(std::string_view styleName);
 
        std::string comment() const;
 
        void setComment(std::string_view comment);
 
        uint32_t headerRowDxfId() const;
 
        void setHeaderRowDxfId(uint32_t id);
 
        uint32_t dataDxfId() const;
 
        void setDataDxfId(uint32_t id);
 
        bool published() const;
 
        void setPublished(bool published);
 
        bool showRowStripes() const;
 
        void setShowRowStripes(bool show);
 
        bool showHeaderRow() const;
 
        void setShowHeaderRow(bool show);
 
        bool showTotalsRow() const;
 
        void setShowTotalsRow(bool show);
 
        bool showColumnStripes() const;
 
        void setShowColumnStripes(bool show);
 
        bool showFirstColumn() const;
 
        void setShowFirstColumn(bool show);
 
        bool showLastColumn() const;
 
        void setShowLastColumn(bool show);
 
        XLTableColumn appendColumn(std::string_view name);
 
        XLTableColumn column(std::string_view name) const;
 
        XLTableColumn column(uint32_t id) const;
 
        XLAutoFilter autoFilter() const;
 
        void resizeToFitData(const XLWorksheet& worksheet);
 
        void createColumnsFromRange(const XLWorksheet& worksheet);
 
        void print(std::basic_ostream<char>& ostr) const;
    };
 
    // For compatibility
    using XLTables = XLTableCollection;
}    // namespace OpenXLSX
 
#endif    // OPENXLSX_XLTABLES_HPP