XLStyles.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLSTYLES_HPP
#define OPENXLSX_XLSTYLES_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 <cstdint>    // uint32_t etc
#include <optional>
#include <string>
#include <string_view>    // std::string_view
#include <unordered_map>
#include <vector>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLColor.hpp"
#include "XLXmlFile.hpp"
#include "XLXmlParser.hpp"
 
namespace OpenXLSX
{
    using namespace std::literals::string_view_literals;    // enables sv suffix only
 
    // Forward declaration to avoid circular includes (XLStyle.hpp uses enums from this header)
    struct XLStyle;
 
    using XLStyleIndex = size_t;    // custom data type for XLStyleIndex
 
    constexpr const uint32_t XLInvalidUInt16  = 0xffff;             // used to signal "value not defined" for uint16_t return types
    constexpr const uint32_t XLInvalidUInt32  = 0xffffffff;         // used to signal "value not defined" for uint32_t return types
    constexpr const uint32_t XLDeleteProperty = XLInvalidUInt32;    // when 0 or "" is not the same as "property does not exist", this value
    //                                                            //  can be passed to setter functions to delete the property from XML
    //                                                            //  currently supported in: XLDataBarColor::setTheme
 
    constexpr const bool XLPermitXfID = true;    // use with XLCellFormat constructor to enable xfId() getter and setXfId() setter
 
    constexpr const bool XLCreateIfMissing = true;     // use with XLCellFormat::alignment(XLCreateIfMissing)
    constexpr const bool XLDoNotCreate     = false;    // use with XLCellFormat::alignment(XLDoNotCreate)
 
    constexpr const bool XLForceFillType = true;
 
    constexpr const char* XLDefaultStylesPrefix       = "\n\t";      // indentation to use for newly created root level style node tags
    constexpr const char* XLDefaultStyleEntriesPrefix = "\n\t\t";    // indentation to use for newly created style entry nodes
 
    constexpr const XLStyleIndex XLDefaultCellFormat = 0;    // default cell format index in xl/styles.xml:<styleSheet>:<cellXfs>
 
    // ===== As pugixml attributes are not guaranteed to support value range of XLStyleIndex, use 32 bit unsigned int
    constexpr const XLStyleIndex XLInvalidStyleIndex = XLInvalidUInt32;    // as a function return value, indicates no valid index
 
    constexpr const uint32_t XLDefaultFontSize       = 12;            //
    constexpr const char*    XLDefaultFontColor      = "ff000000";    // default font color
    constexpr const char*    XLDefaultFontColorTheme = "";            // Theme color ID from theme1.xml (e.g., "1" for dark1)
    constexpr const char*    XLDefaultFontName       = "Arial";       //
    constexpr const uint32_t XLDefaultFontFamily     = 0;             // Font Family (0 = N/A, 1 = Roman, 2 = Swiss, 3 = Modern)
    constexpr const uint32_t XLDefaultFontCharset    = 1;             // Character set (0 = ANSI, 1 = Default, 2 = Symbol)
 
    constexpr const char* XLDefaultLineStyle = "";    // empty string = line not set
 
    // forward declarations of all classes in this header
    class XLNumberFormat;
    class XLNumberFormats;
    class XLFont;
    class XLFonts;
    class XLFill;
    class XLFills;
    class XLLine;
    class XLBorder;
    class XLBorders;
    class XLAlignment;
    class XLCellFormat;
    class XLCellFormats;
    class XLCellStyle;
    class XLCellStyles;
    class XLStyles;
 
    enum XLUnderlineStyle : uint8_t { 
        XLUnderlineNone = 0, 
        XLUnderlineSingle = 1, 
        XLUnderlineDouble = 2, 
        XLUnderlineSingleAccounting = 3, 
        XLUnderlineDoubleAccounting = 4, 
        XLUnderlineInvalid = 255 
    };
 
    enum XLFontSchemeStyle : uint8_t {
        XLFontSchemeNone    = 0,     // <scheme val="none"/>
        XLFontSchemeMajor   = 1,     // <scheme val="major"/>
        XLFontSchemeMinor   = 2,     // <scheme val="minor"/>
        XLFontSchemeInvalid = 255    // all other values
    };
 
    enum XLVerticalAlignRunStyle : uint8_t {
        XLBaseline                = 0,    // <vertAlign val="baseline"/>
        XLSubscript               = 1,    // <vertAlign val="subscript"/>
        XLSuperscript             = 2,    // <vertAlign val="superscript"/>
        XLVerticalAlignRunInvalid = 255
    };
 
    enum XLFillType : uint8_t {
        XLGradientFill    = 0,      // <gradientFill />
        XLPatternFill     = 1,      // <patternFill />
        XLFillTypeInvalid = 255,    // any child of <fill> that is not one of the above
    };
 
    enum XLGradientType : uint8_t { XLGradientLinear = 0, XLGradientPath = 1, XLGradientTypeInvalid = 255 };
 
    enum XLPatternType : uint8_t {
        XLPatternNone            = 0,     // "none"
        XLPatternSolid           = 1,     // "solid"
        XLPatternMediumGray      = 2,     // "mediumGray"
        XLPatternDarkGray        = 3,     // "darkGray"
        XLPatternLightGray       = 4,     // "lightGray"
        XLPatternDarkHorizontal  = 5,     // "darkHorizontal"
        XLPatternDarkVertical    = 6,     // "darkVertical"
        XLPatternDarkDown        = 7,     // "darkDown"
        XLPatternDarkUp          = 8,     // "darkUp"
        XLPatternDarkGrid        = 9,     // "darkGrid"
        XLPatternDarkTrellis     = 10,    // "darkTrellis"
        XLPatternLightHorizontal = 11,    // "lightHorizontal"
        XLPatternLightVertical   = 12,    // "lightVertical"
        XLPatternLightDown       = 13,    // "lightDown"
        XLPatternLightUp         = 14,    // "lightUp"
        XLPatternLightGrid       = 15,    // "lightGrid"
        XLPatternLightTrellis    = 16,    // "lightTrellis"
        XLPatternGray125         = 17,    // "gray125"
        XLPatternGray0625        = 18,    // "gray0625"
        XLPatternTypeInvalid     = 255    // any patternType that is not one of the above
    };
    constexpr const XLFillType    XLDefaultFillType       = XLPatternFill;    // node name for the pattern description is derived from this
    constexpr const XLPatternType XLDefaultPatternType    = XLPatternNone;    // attribute patternType default value: no fill
    constexpr const char*         XLDefaultPatternFgColor = "ffffffff";       // child node fgcolor attribute rgb value
    constexpr const char*         XLDefaultPatternBgColor = "ff000000";       // child node bgcolor attribute rgb value
 
    enum XLLineType : uint8_t {
        XLLineLeft       = 0,
        XLLineRight      = 1,
        XLLineTop        = 2,
        XLLineBottom     = 3,
        XLLineDiagonal   = 4,
        XLLineVertical   = 5,
        XLLineHorizontal = 6,
        XLLineInvalid    = 255
    };
 
    enum XLLineStyle : uint8_t {
        XLLineStyleNone             = 0,
        XLLineStyleThin             = 1,
        XLLineStyleMedium           = 2,
        XLLineStyleDashed           = 3,
        XLLineStyleDotted           = 4,
        XLLineStyleThick            = 5,
        XLLineStyleDouble           = 6,
        XLLineStyleHair             = 7,
        XLLineStyleMediumDashed     = 8,
        XLLineStyleDashDot          = 9,
        XLLineStyleMediumDashDot    = 10,
        XLLineStyleDashDotDot       = 11,
        XLLineStyleMediumDashDotDot = 12,
        XLLineStyleSlantDashDot     = 13,
        XLLineStyleInvalid          = 255
    };
 
    enum XLAlignmentStyle : uint8_t {
        XLAlignGeneral          = 0,     // value="general",          horizontal only
        XLAlignLeft             = 1,     // value="left",             horizontal only
        XLAlignRight            = 2,     // value="right",            horizontal only
        XLAlignCenter           = 3,     // value="center",           both
        XLAlignTop              = 4,     // value="top",              vertical only
        XLAlignBottom           = 5,     // value="bottom",           vertical only
        XLAlignFill             = 6,     // value="fill",             horizontal only
        XLAlignJustify          = 7,     // value="justify",          both
        XLAlignCenterContinuous = 8,     // value="centerContinuous", horizontal only
        XLAlignDistributed      = 9,     // value="distributed",      both
        XLAlignInvalid          = 255    // all other values
    };
 
    enum XLReadingOrder : uint32_t { XLReadingOrderContextual = 0, XLReadingOrderLeftToRight = 1, XLReadingOrderRightToLeft = 2 };
 
    // XLNumberFormats Class
 
    class OPENXLSX_EXPORT XLNumberFormat
    {
        friend class XLNumberFormats;    // for access to m_numberFormatNode in XLNumberFormats::create
    public:                              // ---------- Public Member Functions ---------- //
        XLNumberFormat();
 
        explicit XLNumberFormat(const XMLNode& node);
 
        XLNumberFormat(const XLNumberFormat& other);
 
        XLNumberFormat(XLNumberFormat&& other) noexcept = default;
 
        ~XLNumberFormat();
 
        XLNumberFormat& operator=(const XLNumberFormat& other);
 
        XLNumberFormat& operator=(XLNumberFormat&& other) noexcept = default;
 
        uint32_t numberFormatId() const;
 
        std::string formatCode() const;
 
        bool setNumberFormatId(uint32_t newNumberFormatId);
        bool setFormatCode(std::string_view newFormatCode);
 
        std::string summary() const;
 
    private:                                         // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_numberFormatNode; 
    };
 
    class OPENXLSX_EXPORT XLNumberFormats
    {
    public:    // ---------- Public Member Functions ---------- //
        XLNumberFormats();
 
        explicit XLNumberFormats(const XMLNode& node);
 
        XLNumberFormats(const XLNumberFormats& other);
 
        XLNumberFormats(XLNumberFormats&& other);
 
        ~XLNumberFormats();
 
        XLNumberFormats& operator=(const XLNumberFormats& other);
 
        XLNumberFormats& operator=(XLNumberFormats&& other) noexcept = default;
 
        size_t count() const;
 
        XLNumberFormat numberFormatByIndex(XLStyleIndex index) const;
 
        XLNumberFormat operator[](XLStyleIndex index) const { return numberFormatByIndex(index); }
 
        XLNumberFormat numberFormatById(uint32_t numberFormatId) const;
 
        uint32_t numberFormatIdFromIndex(XLStyleIndex index) const;
 
        uint32_t createNumberFormat(std::string_view formatCode);
 
        uint32_t getFreeNumberFormatId() const;
 
        XLStyleIndex create(XLNumberFormat copyFrom = XLNumberFormat{}, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
    private:                                             // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode>    m_numberFormatsNode; 
        std::vector<XLNumberFormat> m_numberFormats;
    };
 
    // XLFonts Class
 
    class OPENXLSX_EXPORT XLFont
    {
        friend class XLFonts;    // for access to m_fontNode in XLFonts::create
    public:                      // ---------- Public Member Functions ---------- //
        XLFont();
 
        explicit XLFont(const XMLNode& node);
 
        XLFont(const XLFont& other);
 
        XLFont(XLFont&& other) noexcept = default;
 
        ~XLFont();
 
        XLFont& operator=(const XLFont& other);
 
        XLFont& operator=(XLFont&& other) noexcept = default;
 
        std::string fontName() const;
 
        size_t fontCharset() const;
 
        size_t fontFamily() const;
 
        size_t fontSize() const;
 
        XLColor fontColor() const;
 
        bool bold() const;
 
        bool italic() const;
 
        bool strikethrough() const;
 
        XLUnderlineStyle underline() const;
 
        XLFontSchemeStyle scheme() const;
 
        XLVerticalAlignRunStyle vertAlign() const;
 
        bool outline() const;
 
        bool shadow() const;
 
        bool condense() const;
 
        bool extend() const;
 
        XLFont& setFontName(std::string_view newName);
        XLFont& setFontCharset(size_t newCharset);
        XLFont& setFontFamily(size_t newFamily);
        XLFont& setFontSize(size_t newSize);
        XLFont& setFontColor(XLColor newColor);
        XLFont& setBold(bool set = true);
        XLFont& setItalic(bool set = true);
        XLFont& setStrikethrough(bool set = true);
        XLFont& setUnderline(XLUnderlineStyle style = XLUnderlineSingle);
        XLFont& setScheme(XLFontSchemeStyle newScheme);
        XLFont& setVertAlign(XLVerticalAlignRunStyle newVertAlign);
        XLFont& setOutline(bool set = true);
        XLFont& setShadow(bool set = true);
        XLFont& setCondense(bool set = true);
        XLFont& setExtend(bool set = true);
 
        std::string summary() const;
 
    private:                                 // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_fontNode; 
    };
 
    class OPENXLSX_EXPORT XLFonts
    {
    public:    // ---------- Public Member Functions ---------- //
        XLFonts();
 
        explicit XLFonts(const XMLNode& node);
 
        XLFonts(const XLFonts& other);
 
        XLFonts(XLFonts&& other);
 
        ~XLFonts();
 
        XLFonts& operator=(const XLFonts& other);
 
        XLFonts& operator=(XLFonts&& other) noexcept = default;
 
        size_t count() const;
 
        XLFont fontByIndex(XLStyleIndex index) const;
 
        XLFont operator[](XLStyleIndex index) const { return fontByIndex(index); }
 
        XLStyleIndex create(XLFont copyFrom = XLFont{}, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
        XLStyleIndex findOrCreate(XLFont copyFrom, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
    private:                                                               // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode>                              m_fontsNode; 
        std::vector<XLFont>                                   m_fonts;
        mutable std::unordered_map<std::string, XLStyleIndex> m_fingerprintCache; 
    };
 
    // XLDataBarColor Class
 
    class OPENXLSX_EXPORT XLDataBarColor
    {
    public:
        XLDataBarColor();
 
        explicit XLDataBarColor(const XMLNode& node);
 
        XLDataBarColor(const XLDataBarColor& other);
 
        XLDataBarColor(XLDataBarColor&& other) noexcept = default;
 
        ~XLDataBarColor() = default;
 
        XLDataBarColor& operator=(const XLDataBarColor& other);
 
        XLDataBarColor& operator=(XLDataBarColor&& other) noexcept = default;
 
        XLColor rgb() const;
 
        double tint() const;
 
        bool     automatic() const;    // <color auto="true" />
        uint32_t indexed() const;      // <color indexed="1" />
        uint32_t theme() const;        // <color theme="1" />
 
        bool setRgb(XLColor newColor);
        bool set(XLColor newColor) { return setRgb(newColor); }    // alias for setRgb
        bool setTint(double newTint);
        bool setAutomatic(bool set = true);
        bool setIndexed(uint32_t newIndex);
        bool setTheme(uint32_t newTheme);
 
        std::string summary() const;
 
    private:                                  // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_colorNode; 
    };
 
    // XLFills Class
 
    class OPENXLSX_EXPORT XLGradientStop
    {
        friend class XLGradientStops;    // for access to m_stopNode in XLGradientStops::create
    public:                              // ---------- Public Member Functions ----------- //
        XLGradientStop();
 
        explicit XLGradientStop(const XMLNode& node);
 
        XLGradientStop(const XLGradientStop& other);
 
        XLGradientStop(XLGradientStop&& other) noexcept = default;
 
        ~XLGradientStop() = default;
 
        XLGradientStop& operator=(const XLGradientStop& other);
 
        XLGradientStop& operator=(XLGradientStop&& other) noexcept = default;
 
        XLDataBarColor color() const;       // <stop><color /></stop>
        double         position() const;    // <stop position="1.2" />
 
        bool setPosition(double newPosition);
 
        std::string summary() const;
 
    private:                                 // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_stopNode; 
    };
 
    class OPENXLSX_EXPORT XLGradientStops
    {
    public:    // ---------- Public Member Functions ---------- //
        XLGradientStops();
 
        explicit XLGradientStops(const XMLNode& node);
 
        XLGradientStops(const XLGradientStops& other);
 
        XLGradientStops(XLGradientStops&& other);
 
        ~XLGradientStops();
 
        XLGradientStops& operator=(const XLGradientStops& other);
 
        XLGradientStops& operator=(XLGradientStops&& other) noexcept = default;
 
        size_t count() const;
 
        XLGradientStop stopByIndex(XLStyleIndex index) const;
 
        XLGradientStop operator[](XLStyleIndex index) const { return stopByIndex(index); }
 
        XLStyleIndex create(XLGradientStop copyFrom = XLGradientStop{}, std::string_view styleEntriesPrefix = "");
 
        std::string summary() const;
 
    private:
        std::unique_ptr<XMLNode>    m_gradientNode; 
        std::vector<XLGradientStop> m_gradientStops;
    };
 
    class OPENXLSX_EXPORT XLFill
    {
        friend class XLFills;    // for access to m_fillNode in XLFills::create
    public:                      // ---------- Public Member Functions ----------- //
        XLFill();
 
        explicit XLFill(const XMLNode& node);
 
        XLFill(const XLFill& other);
 
        XLFill(XLFill&& other) noexcept = default;
 
        ~XLFill();
 
        XLFill& operator=(const XLFill& other);
 
        XLFill& operator=(XLFill&& other) noexcept = default;
 
        XLFillType fillType() const;
 
        bool setFillType(XLFillType newFillType, bool force = false);
 
    private:    // ---------- Switch to private context for two Methods  --------- //
        void throwOnFillType(XLFillType typeToThrowOn, const char* functionName) const;
 
        XMLNode getValidFillDescription(XLFillType fillTypeIfEmpty, const char* functionName);
 
    public:    // ---------- Switch back to public context ---------------------- //
        XLGradientType  gradientType();    // <gradientFill type="path" />
        double          degree();
        double          left();
        double          right();
        double          top();
        double          bottom();
        XLGradientStops stops();
 
        XLPatternType patternType();
        XLColor       color();
        XLColor       backgroundColor();
 
        bool setGradientType(XLGradientType newType);
        bool setDegree(double newDegree);
        bool setLeft(double newLeft);
        bool setRight(double newRight);
        bool setTop(double newTop);
        bool setBottom(double newBottom);
 
        XLFill& setPatternType(XLPatternType newPatternType);
        XLFill& setColor(XLColor newColor);
        XLFill& setBackgroundColor(XLColor newBgColor);
 
        std::string summary();
 
    private:                                 // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_fillNode; 
    };
 
    class OPENXLSX_EXPORT XLFills
    {
    public:    // ---------- Public Member Functions ---------- //
        XLFills();
 
        explicit XLFills(const XMLNode& node);
 
        XLFills(const XLFills& other);
 
        XLFills(XLFills&& other);
 
        ~XLFills();
 
        XLFills& operator=(const XLFills& other);
 
        XLFills& operator=(XLFills&& other) noexcept = default;
 
        size_t count() const;
 
        XLFill fillByIndex(XLStyleIndex index) const;
 
        XLFill operator[](XLStyleIndex index) const { return fillByIndex(index); }
 
        XLStyleIndex create(XLFill copyFrom = XLFill{}, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
        XLStyleIndex findOrCreate(XLFill copyFrom, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
    private:                                                               // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode>                              m_fillsNode; 
        std::vector<XLFill>                                   m_fills;
        mutable std::unordered_map<std::string, XLStyleIndex> m_fingerprintCache; 
    };
 
    // XLBorders Class
 
    class OPENXLSX_EXPORT XLLine
    {
    public:    // ---------- Public Member Functions ---------- //
        XLLine();
 
        explicit XLLine(const XMLNode& node);
 
        XLLine(const XLLine& other);
 
        XLLine(XLLine&& other) noexcept = default;
 
        ~XLLine();
 
        XLLine& operator=(const XLLine& other);
 
        XLLine& operator=(XLLine&& other) noexcept = default;
 
        XLLineStyle style() const;
 
        explicit operator bool() const;
 
        XLDataBarColor
            color() const;    // <line><color /></line> where node can be left, right, top, bottom, diagonal, vertical, horizontal
 
        std::string summary() const;
 
    private:                                 // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_lineNode; 
    };
 
    class OPENXLSX_EXPORT XLBorder
    {
        friend class XLBorders;    // for access to m_borderNode in XLBorders::create
    public:                        // ---------- Public Member Functions ---------- //
        XLBorder();
 
        explicit XLBorder(const XMLNode& node);
 
        XLBorder(const XLBorder& other);
 
        XLBorder(XLBorder&& other) noexcept = default;
 
        ~XLBorder();
 
        XLBorder& operator=(const XLBorder& other);
 
        XLBorder& operator=(XLBorder&& other) noexcept = default;
 
        bool diagonalUp() const;
 
        bool diagonalDown() const;
 
        bool outline() const;
 
        XLLine left() const;
 
        XLLine right() const;
 
        XLLine top() const;
 
        XLLine bottom() const;
 
        XLLine diagonal() const;
 
        XLLine vertical() const;
 
        XLLine horizontal() const;
 
        XLBorder& setDiagonalUp(bool set = true);
        XLBorder& setDiagonalDown(bool set = true);
        XLBorder& setOutline(bool set = true);
        bool      setLine(XLLineType lineType, XLLineStyle lineStyle, XLColor lineColor, double lineTint = 0.0);
        bool      setLeft(XLLineStyle lineStyle, XLColor lineColor, double lineTint = 0.0);
        bool      setRight(XLLineStyle lineStyle, XLColor lineColor, double lineTint = 0.0);
        bool      setTop(XLLineStyle lineStyle, XLColor lineColor, double lineTint = 0.0);
        bool      setBottom(XLLineStyle lineStyle, XLColor lineColor, double lineTint = 0.0);
        bool      setDiagonal(XLLineStyle lineStyle, XLColor lineColor, double lineTint = 0.0);
        bool      setVertical(XLLineStyle lineStyle, XLColor lineColor, double lineTint = 0.0);
        bool      setHorizontal(XLLineStyle lineStyle, XLColor lineColor, double lineTint = 0.0);
 
        std::string summary() const;
 
    private:                                                            // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode>                          m_borderNode; 
        inline static const std::vector<std::string_view> m_nodeOrder =
            {"left", "right", "top", "bottom", "diagonal", "vertical", "horizontal"};
    };
 
    class OPENXLSX_EXPORT XLBorders
    {
    public:    // ---------- Public Member Functions ---------- //
        XLBorders();
 
        explicit XLBorders(const XMLNode& node);
 
        XLBorders(const XLBorders& other);
 
        XLBorders(XLBorders&& other);
 
        ~XLBorders();
 
        XLBorders& operator=(const XLBorders& other);
 
        XLBorders& operator=(XLBorders&& other) noexcept = default;
 
        size_t count() const;
 
        XLBorder borderByIndex(XLStyleIndex index) const;
 
        XLBorder operator[](XLStyleIndex index) const { return borderByIndex(index); }
 
        XLStyleIndex create(XLBorder copyFrom = XLBorder{}, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
        XLStyleIndex findOrCreate(XLBorder copyFrom, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
    private:                                                                 // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode>                              m_bordersNode; 
        std::vector<XLBorder>                                 m_borders;
        mutable std::unordered_map<std::string, XLStyleIndex> m_fingerprintCache; 
    };
 
    // XLCellFormats Class
 
    class OPENXLSX_EXPORT XLAlignment
    {
    public:    // ---------- Public Member Functions ---------- //
        XLAlignment();
 
        explicit XLAlignment(const XMLNode& node);
 
        XLAlignment(const XLAlignment& other);
 
        XLAlignment(XLAlignment&& other) noexcept = default;
 
        ~XLAlignment();
 
        XLAlignment& operator=(const XLAlignment& other);
 
        XLAlignment& operator=(XLAlignment&& other) noexcept = default;
 
        XLAlignmentStyle horizontal() const;
 
        XLAlignmentStyle vertical() const;
 
        uint16_t textRotation() const;
 
        bool wrapText() const;
 
        uint32_t indent() const;
 
        int32_t relativeIndent() const;
 
        bool justifyLastLine() const;
 
        bool shrinkToFit() const;
 
        uint32_t readingOrder() const;
 
        bool setHorizontal(XLAlignmentStyle newStyle);
        bool setVertical(XLAlignmentStyle newStyle);
        bool setTextRotation(uint16_t newRotation);
        bool setWrapText(bool set = true);
        bool setIndent(uint32_t newIndent);
        bool setRelativeIndent(int32_t newIndent);
        bool setJustifyLastLine(bool set = true);
        bool setShrinkToFit(bool set = true);
        bool setReadingOrder(
            uint32_t newReadingOrder);    // can be used with XLReadingOrderContextual, XLReadingOrderLeftToRight, XLReadingOrderRightToLeft
 
        std::string summary() const;
 
    private:                                      // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_alignmentNode; 
    };
 
    class OPENXLSX_EXPORT XLCellFormat
    {
        friend class XLCellFormats;    // for access to m_cellFormatNode in XLCellFormats::create
 
    public:    // ---------- Public Member Functions ---------- //
        XLCellFormat();
 
        explicit XLCellFormat(const XMLNode& node, bool permitXfId);
 
        XLCellFormat(const XLCellFormat& other);
 
        XLCellFormat(XLCellFormat&& other) noexcept = default;
 
        ~XLCellFormat();
 
        XLCellFormat& operator=(const XLCellFormat& other);
 
        XLCellFormat& operator=(XLCellFormat&& other) noexcept = default;
 
        uint32_t numberFormatId() const;
 
        XLStyleIndex fontIndex() const;
 
        XLStyleIndex fillIndex() const;
 
        XLStyleIndex borderIndex() const;
 
        XLStyleIndex xfId() const;
 
        bool applyNumberFormat() const;
 
        bool applyFont() const;
 
        bool applyFill() const;
 
        bool applyBorder() const;
 
        bool applyAlignment() const;
 
        bool applyProtection() const;
 
        bool quotePrefix() const;
 
        bool pivotButton() const;
 
        bool locked() const;
 
        bool hidden() const;
 
        XLAlignment alignment(bool createIfMissing = false) const;
 
        XLUnsupportedElement extLst() const { return XLUnsupportedElement{}; }    // <xf><extLst>...</extLst></xf>
 
        XLCellFormat& setNumberFormatId(uint32_t newNumFmtId);
        XLCellFormat& setFontIndex(XLStyleIndex newFontIndex);
        XLCellFormat& setFillIndex(XLStyleIndex newFillIndex);
        XLCellFormat& setBorderIndex(XLStyleIndex newBorderIndex);
        XLCellFormat& setXfId(XLStyleIndex newXfId);    // NOTE: throws when invoked from cellStyleFormats
        XLCellFormat& setApplyNumberFormat(bool set = true);
        XLCellFormat& setApplyFont(bool set = true);
        XLCellFormat& setApplyFill(bool set = true);
        XLCellFormat& setApplyBorder(bool set = true);
        XLCellFormat& setApplyAlignment(bool set = true);
        XLCellFormat& setApplyProtection(bool set = true);
        XLCellFormat& setQuotePrefix(bool set = true);
        XLCellFormat& setPivotButton(bool set = true);
        XLCellFormat& setLocked(bool set = true);
        XLCellFormat& setHidden(bool set = true);
        XLCellFormat& setExtLst(XLUnsupportedElement const& newExtLst);
 
        std::string summary() const;
 
    private:                                                                // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode>                          m_cellFormatNode; 
        bool                                              m_permitXfId{false};
        inline static const std::vector<std::string_view> m_nodeOrder = {"alignment", "protection"};
    };
 
    class OPENXLSX_EXPORT XLCellFormats
    {
    public:    // ---------- Public Member Functions ---------- //
        XLCellFormats();
 
        explicit XLCellFormats(const XMLNode& node, bool permitXfId = false);
 
        XLCellFormats(const XLCellFormats& other);
 
        XLCellFormats(XLCellFormats&& other);
 
        ~XLCellFormats();
 
        XLCellFormats& operator=(const XLCellFormats& other);
 
        XLCellFormats& operator=(XLCellFormats&& other) noexcept = default;
 
        size_t count() const;
 
        XLCellFormat cellFormatByIndex(XLStyleIndex index) const;
 
        XLCellFormat operator[](XLStyleIndex index) const { return cellFormatByIndex(index); }
 
        XLStyleIndex create(XLCellFormat copyFrom = XLCellFormat{}, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
        XLStyleIndex findOrCreate(XLCellFormat copyFrom, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
    private:                                                                     // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode>                              m_cellFormatsNode; 
        std::vector<XLCellFormat>                             m_cellFormats;
        bool                                                  m_permitXfId{false};
        mutable std::unordered_map<std::string, XLStyleIndex> m_fingerprintCache; 
    };
 
    // XLCellStyles Class
 
    class OPENXLSX_EXPORT XLCellStyle
    {
        friend class XLCellStyles;    // for access to m_cellStyleNode in XLCellStyles::create
 
    public:    // ---------- Public Member Functions ---------- //
        XLCellStyle();
 
        explicit XLCellStyle(const XMLNode& node);
 
        XLCellStyle(const XLCellStyle& other);
 
        XLCellStyle(XLCellStyle&& other) noexcept = default;
 
        ~XLCellStyle();
 
        XLCellStyle& operator=(const XLCellStyle& other);
 
        XLCellStyle& operator=(XLCellStyle&& other) noexcept = default;
 
        bool empty() const;
 
        std::string name() const;
 
        XLStyleIndex xfId() const;
 
        uint32_t builtinId() const;
 
        uint32_t outlineStyle() const;
 
        bool hidden() const;
 
        bool customBuiltin() const;
 
        XLUnsupportedElement extLst() const { return XLUnsupportedElement{}; }    // <cellStyle><extLst>...</extLst></cellStyle>
 
        bool setName(std::string_view newName);
        bool setXfId(XLStyleIndex newXfId);
        bool setBuiltinId(uint32_t newBuiltinId);
        bool setOutlineStyle(uint32_t newOutlineStyle);
        bool setHidden(bool set = true);
        bool setCustomBuiltin(bool set = true);
        bool setExtLst(XLUnsupportedElement const& newExtLst);
 
        std::string summary() const;
 
    private:                                      // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_cellStyleNode; 
    };
 
    class OPENXLSX_EXPORT XLCellStyles
    {
    public:    // ---------- Public Member Functions ---------- //
        XLCellStyles();
 
        explicit XLCellStyles(const XMLNode& node);
 
        XLCellStyles(const XLCellStyles& other);
 
        XLCellStyles(XLCellStyles&& other);
 
        ~XLCellStyles();
 
        XLCellStyles& operator=(const XLCellStyles& other);
 
        XLCellStyles& operator=(XLCellStyles&& other) noexcept = default;
 
        size_t count() const;
 
        XLCellStyle cellStyleByIndex(XLStyleIndex index) const;
 
        XLCellStyle operator[](XLStyleIndex index) const { return cellStyleByIndex(index); }
 
        XLStyleIndex create(XLCellStyle copyFrom = XLCellStyle{}, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
    private:                                       // ---------- Private Member Variables ---------- //
        std::unique_ptr<XMLNode> m_cellStylesNode; 
        std::vector<XLCellStyle> m_cellStyles;
    };
 
    // XLDxfs Class
 
    class OPENXLSX_EXPORT XLDxf
    {
        friend class XLDxfs;
 
    public:
        XLDxf();
 
        explicit XLDxf(const XMLNode& node);
 
        XLDxf(const XLDxf& other);
 
        XLDxf(XLDxf&& other) noexcept;
 
        ~XLDxf();
 
        XLDxf& operator=(const XLDxf& other);
 
        XLDxf& operator=(XLDxf&& other) noexcept;
 
        bool empty() const;
 
        XLFont         font() const;
        XLNumberFormat numFmt() const;
        XLFill         fill() const;
        XLAlignment    alignment() const;
        XLBorder       border() const;
 
        bool hasFont() const;
        bool hasNumFmt() const;
        bool hasFill() const;
        bool hasAlignment() const;
        bool hasBorder() const;
 
        void clearFont();
        void clearNumFmt();
        void clearFill();
        void clearAlignment();
        void clearBorder();
 
        XLUnsupportedElement extLst() const { return XLUnsupportedElement{}; }
 
        bool setExtLst(XLUnsupportedElement const& newExtLst);
 
        std::string summary() const;
 
        XMLNode node() const { return m_dxfNode; }
 
    private:
        std::unique_ptr<XMLDocument> m_xmlDocument; 
        mutable XMLNode              m_dxfNode;     
    };
 
    using XLDiffCellFormat = XLDxf;
 
    class OPENXLSX_EXPORT XLDxfs
    {
    public:
        XLDxfs();
 
        explicit XLDxfs(const XMLNode& node);
 
        XLDxfs(const XLDxfs& other);
 
        XLDxfs(XLDxfs&& other);
 
        ~XLDxfs();
 
        XLDxfs& operator=(const XLDxfs& other);
 
        XLDxfs& operator=(XLDxfs&& other) noexcept;
 
        size_t count() const;
 
        XLDxf dxfByIndex(XLStyleIndex index) const;
 
        XLDxf operator[](XLStyleIndex index) const { return dxfByIndex(index); }
 
        XLStyleIndex create(XLDxf copyFrom = XLDxf{}, std::string_view styleEntriesPrefix = XLDefaultStyleEntriesPrefix);
 
    private:
        mutable XMLNode    m_dxfsNode; 
        std::vector<XLDxf> m_dxfs;
    };
 
    using XLDiffCellFormats = XLDxfs;
 
    // XLStyles Class
 
    class OPENXLSX_EXPORT XLStyles : public XLXmlFile
    {
    public:    // ---------- Public Member Functions ---------- //
        XLStyles();
 
        explicit XLStyles(gsl::not_null<XLXmlData*> xmlData,
                          bool                      suppressWarnings = false,
                          std::string_view          stylesPrefix     = XLDefaultStylesPrefix);
 
        ~XLStyles();
 
        XLStyles(XLStyles&& other) noexcept;
 
        XLStyles(const XLStyles& other);
 
        XLStyles& operator=(XLStyles&& other) noexcept;
 
        XLStyles& operator=(const XLStyles& other);
 
        uint32_t createNumberFormat(std::string_view formatCode);
 
        XLNumberFormats& numberFormats() const;
 
        XLFonts& fonts() const;
 
        XLFills& fills() const;
 
        XLBorders& borders() const;
 
        XLCellFormats& cellStyleFormats() const;
 
        XLCellFormats& cellFormats() const;
 
        XLCellStyles& cellStyles() const;
 
        XLDxfs& dxfs() const;
 
        XLDxfs& diffCellFormats() const { return dxfs(); }
 
        XLStyleIndex addDxf(const XLDxf& dxf);
 
        XLStyleIndex addNamedStyle(std::string_view            name,
                                   std::optional<XLStyleIndex> fontId   = std::nullopt,
                                   std::optional<XLStyleIndex> fillId   = std::nullopt,
                                   std::optional<XLStyleIndex> borderId = std::nullopt,
                                   std::optional<XLStyleIndex> numFmtId = std::nullopt);
 
        XLStyleIndex namedStyle(std::string_view name) const;
 
        XLStyleIndex findOrCreateStyle(const XLStyle& style);
 
        // ---------- Protected Member Functions ---------- //
    private:
        bool                             m_suppressWarnings;    // if true, will suppress output of warnings where supported
        std::unique_ptr<XLNumberFormats> m_numberFormats;       // handle to the underlying number formats
        std::unique_ptr<XLFonts>         m_fonts;               // handle to the underlying fonts
        std::unique_ptr<XLFills>         m_fills;               // handle to the underlying fills
        std::unique_ptr<XLBorders>       m_borders;             // handle to the underlying border descriptions
        std::unique_ptr<XLCellFormats>   m_cellStyleFormats;    // handle to the underlying cell style formats descriptions
        std::unique_ptr<XLCellFormats>   m_cellFormats;         // handle to the underlying cell formats descriptions
        std::unique_ptr<XLCellStyles>    m_cellStyles;          // handle to the underlying cell styles
        std::unique_ptr<XLDxfs>          m_dxfs;                // handle to the underlying differential cell formats
    };
}    // 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_XLSTYLES_HPP