XLSheet.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLSHEET_HPP
#define OPENXLSX_XLSHEET_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 <ostream>
#include <variant>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLChartsheet.hpp"
#include "XLConditionalFormatting.hpp"
#include "XLSheetBase.hpp"
#include "XLWorksheet.hpp"
#include "XLXmlFile.hpp"
 
namespace OpenXLSX
{
    class OPENXLSX_EXPORT XLSheet final : public XLXmlFile
    {
    public:
        explicit XLSheet(XLXmlData* xmlData);
 
        XLSheet(const XLSheet& other) = default;
 
        XLSheet(XLSheet&& other) noexcept = default;
 
        ~XLSheet() = default;
 
        XLSheet& operator=(const XLSheet& other) = default;
 
        XLSheet& operator=(XLSheet&& other) noexcept = default;
 
        XLSheetState visibility() const;
 
        void setVisibility(XLSheetState state);
 
        XLColor color() const;
 
        void setColor(const XLColor& color);
 
        uint16_t index() const;
 
        void setIndex(uint16_t index);
 
        std::string name() const;
 
        void setName(const std::string& name);
 
        bool isSelected() const;
 
        void setSelected(bool selected);
 
        bool isActive() const;
 
        bool setActive();
 
        template<typename SheetType,
                 typename = std::enable_if_t<std::is_same_v<SheetType, XLWorksheet> or std::is_same_v<SheetType, XLChartsheet>>>
        bool isType() const
        { return std::holds_alternative<SheetType>(m_sheet); }
 
        void clone(const std::string& newName);
 
        template<typename T, typename = std::enable_if_t<std::is_same_v<T, XLWorksheet> or std::is_same_v<T, XLChartsheet>>>
        T get() const
        {
            try {
                if constexpr (std::is_same<T, XLWorksheet>::value)
                    return std::get<XLWorksheet>(m_sheet);
 
                else if constexpr (std::is_same<T, XLChartsheet>::value)
                    return std::get<XLChartsheet>(m_sheet);
            }
 
            catch (const std::bad_variant_access&) {
                throw XLSheetError("XLSheet object does not contain the requested sheet type.");
            }
        }
 
        operator XLWorksheet() const;    // NOLINT
 
        operator XLChartsheet() const;    // NOLINT
 
        void print(std::basic_ostream<char>& ostr) const;
 
    private:                                             // ---------- Private Member Variables ---------- //
        std::variant<XLWorksheet, XLChartsheet> m_sheet; 
    };
}    // 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_XLSHEET_HPP