XLCellValue.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLCELLVALUE_HPP
#define OPENXLSX_XLCELLVALUE_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 <cmath>
#include <cstdint>
#include <fast_float/fast_float.h>
#include <fmt/base.h>
#include <fmt/format.h>
#include <iostream>
#include <string>
#include <variant>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLDateTime.hpp"
#include "XLException.hpp"
#include "XLRichText.hpp"
#include "XLXmlParser.hpp"
 
typedef std::variant<std::string, int64_t, double, bool, OpenXLSX::XLRichText> XLCellValueType;
 
namespace OpenXLSX
{
    class XLCellValueProxy;
    class XLCell;
 
    enum class XLValueType { Empty, Boolean, Integer, Float, Error, String, RichText };
 
    //---------- Private Struct to enable XLValueType conversion to double ---------- //
    struct VisitXLCellValueTypeToDouble
    {
        std::string packageName = "VisitXLCellValueTypeToDouble";
        double      operator()(int64_t v) const { return static_cast<double>(v); }
        double      operator()(double v) const { return v; }
        double      operator()(bool v) const { return v; }
        // double operator()( struct timestamp v ) { /* to be implemented if this type ever gets supported */ }
        double operator()([[maybe_unused]] const OpenXLSX::XLRichText& v) const
        {
            throw XLValueTypeError("RichText is not convertible to double.");
            return 0.0;
        }
        double operator()(std::string v) const
        {
            throw XLValueTypeError(
                "string is not convertible to double.");    // disable if implicit conversion of string to double shall be allowed
            double val;
            auto [ptr, ec] = fast_float::from_chars(v.data(), v.data() + v.size(), val);
            if (ec != std::errc()) throw XLValueTypeError("string is not convertible to double.");
            return val;
        }
    };
 
    //---------- Private Struct to enable XLValueType conversion to std::string ---------- //
    struct VisitXLCellValueTypeToString
    {
        std::string packageName = "VisitXLCellValueTypeToString";
        std::string operator()(int64_t v) const { return fmt::format("{}", v); }
        std::string operator()(double v) const { return fmt::format("{}", v); }
        std::string operator()(bool v) const { return v ? "true" : "false"; }
        // std::string operator()( struct timestamp v ) { return timestampString( v.seconds, v.microseconds, WITH_MS ); }
        std::string operator()(const XLRichText& v) const { return v.plainText(); }
        std::string operator()(std::string v) const { return v; }
    };
 
    class OPENXLSX_EXPORT XLCellValue
    {
        friend class XLCellValueProxy;    // to allow access to m_value
 
        // Comparison operators between XLCellValue objects
        friend bool          operator==(const XLCellValue& lhs, const XLCellValue& rhs);
        friend bool          operator!=(const XLCellValue& lhs, const XLCellValue& rhs);
        friend bool          operator<(const XLCellValue& lhs, const XLCellValue& rhs);
        friend bool          operator>(const XLCellValue& lhs, const XLCellValue& rhs);
        friend bool          operator<=(const XLCellValue& lhs, const XLCellValue& rhs);
        friend bool          operator>=(const XLCellValue& lhs, const XLCellValue& rhs);
        friend std::ostream& operator<<(std::ostream& os, const XLCellValue& value);
        friend std::hash<OpenXLSX::XLCellValue>;
 
#define OPENXLSX_XLCELLVALUE_FRIEND_STRING_OP(OP, FUNCTOR)                                                           \
    friend bool operator OP(const XLCellValue& lhs, std::string_view rhs)                                            \
    {                                                                                                                \
        if (std::holds_alternative<std::string>(lhs.m_value))                                                        \
            return FUNCTOR<>{}(std::string_view(std::get<std::string>(lhs.m_value)), rhs);                           \
        return false;                                                                                                \
    }                                                                                                                \
    friend bool operator OP(std::string_view lhs, const XLCellValue& rhs)                                            \
    {                                                                                                                \
        if (std::holds_alternative<std::string>(rhs.m_value))                                                        \
            return FUNCTOR<>{}(lhs, std::string_view(std::get<std::string>(rhs.m_value)));                           \
        return false;                                                                                                \
    }                                                                                                                \
    friend bool operator OP(const XLCellValue& lhs, const char* rhs) { return lhs OP std::string_view(rhs); }        \
    friend bool operator OP(const char* lhs, const XLCellValue& rhs) { return std::string_view(lhs) OP rhs; }        \
    friend bool operator OP(const XLCellValue& lhs, const std::string& rhs) { return lhs OP std::string_view(rhs); } \
    friend bool operator OP(const std::string& lhs, const XLCellValue& rhs) { return std::string_view(lhs) OP rhs; }
 
        OPENXLSX_XLCELLVALUE_FRIEND_STRING_OP(==, std::equal_to)
        OPENXLSX_XLCELLVALUE_FRIEND_STRING_OP(!=, std::not_equal_to)
        OPENXLSX_XLCELLVALUE_FRIEND_STRING_OP(<, std::less)
        OPENXLSX_XLCELLVALUE_FRIEND_STRING_OP(>, std::greater)
        OPENXLSX_XLCELLVALUE_FRIEND_STRING_OP(<=, std::less_equal)
        OPENXLSX_XLCELLVALUE_FRIEND_STRING_OP(>=, std::greater_equal)
 
#undef OPENXLSX_XLCELLVALUE_FRIEND_STRING_OP
 
    public:
        XLCellValue();
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, OpenXLSX::XLRichText> or std::is_same_v<T, XLDateTime>>>
        XLCellValue(const T& value)    // NOLINT
        {
            // ===== If the argument is a bool, set the m_type attribute to Boolean.
            if constexpr (std::is_integral_v<T> and std::is_same_v<T, bool>) {
                m_type  = XLValueType::Boolean;
                m_value = value;
            }
 
            // ===== If the argument is an integral type, set the m_type attribute to Integer.
            else if constexpr (std::is_integral_v<T> and !std::is_same_v<T, bool>) {
                m_type  = XLValueType::Integer;
                m_value = static_cast<int64_t>(value);
            }
 
            // ===== If the argument is a string type (i.e. is constructable from *char),
            // ===== set the m_type attribute to String.
            else if constexpr (std::is_same_v<std::decay_t<T>, std::string> or std::is_same_v<std::decay_t<T>, std::string_view> ||
                               std::is_same_v<std::decay_t<T>, const char*> ||
                               (std::is_same_v<std::decay_t<T>, char*> and !std::is_same_v<T, bool>))
            {
                m_type  = XLValueType::String;
                m_value = std::string(value);
            }
 
            // ===== If the argument is an XLDateTime, set the value to the date/time serial number.
            else if constexpr (std::is_same_v<T, XLDateTime>) {
                m_type  = XLValueType::Float;
                m_value = value.serial();
            }
 
            // ===== If the argument is an XLRichText, set the m_type attribute to RichText.
            else if constexpr (std::is_same_v<T, XLRichText>) {
                m_type  = XLValueType::RichText;
                m_value = value;
            }
 
            // ===== If the argument is a floating point type, set the m_type attribute to Float.
            // ===== If not, a static_assert will result in compilation error.
            else {
                static_assert(std::is_floating_point_v<T>, "Invalid argument for constructing XLCellValue object");
                if (std::isfinite(value)) {
                    m_type  = XLValueType::Float;
                    m_value = static_cast<double>(value);
                }
                else {
                    m_type  = XLValueType::Error;
                    m_value = std::string("#NUM!");
                }
            }
        }
 
        XLCellValue(const XLCellValue& other);
 
        XLCellValue(XLCellValue&& other) noexcept;
 
        ~XLCellValue();
 
        XLCellValue& operator=(const XLCellValue& other);
 
        XLCellValue& operator=(XLCellValue&& other) noexcept;
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, OpenXLSX::XLRichText> or std::is_same_v<T, XLDateTime>>>
        XLCellValue& operator=(T value)
        {
            // ===== Implemented using copy-and-swap.
            XLCellValue temp(value);
            std::swap(*this, temp);
            return *this;
        }
 
        template<
            typename T,
            typename = std::enable_if_t<std::is_same_v<T, XLCellValue> or std::is_integral_v<T> or std::is_floating_point_v<T> ||
                                        std::is_same_v<std::decay_t<T>, std::string> or std::is_same_v<std::decay_t<T>, std::string_view> ||
                                        std::is_same_v<std::decay_t<T>, const char*> or std::is_same_v<std::decay_t<T>, char*> ||
                                        std::is_same_v<T, OpenXLSX::XLRichText> or std::is_same_v<T, XLDateTime>>>
        void set(T numberValue)
        {
            // ===== Implemented using the assignment operator.
            *this = numberValue;
        }
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, XLDateTime> or std::is_same_v<T, OpenXLSX::XLRichText>>>
        T get() const
        {
            try {
                return privateGet<T>();
            }
 
            catch (const std::bad_variant_access&) {
                throw XLValueTypeError("XLCellValue object does not contain the requested type.");
            }
        }
 
    private:
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, OpenXLSX::XLRichText> or std::is_same_v<T, XLDateTime>>>
        T privateGet() const
        {
            try {
                if constexpr (std::is_integral_v<T> and std::is_same_v<T, bool>) return std::get<bool>(m_value);
 
                if constexpr (std::is_integral_v<T> and !std::is_same_v<T, bool>) return static_cast<T>(std::get<int64_t>(m_value));
 
                if constexpr (std::is_floating_point_v<T>) {
                    return static_cast<T>(getDouble());    // 2025-01-10: allow implicit conversion of int and bool to double (string
                                                           // conversion disabled for now)
                    // if (m_type == XLValueType::Error) return static_cast<T>(std::nan("1"));
                    // return static_cast<T>(std::get<double>(m_value));
                }
 
                if constexpr (std::is_same_v<std::decay_t<T>, std::string> or std::is_same_v<std::decay_t<T>, std::string_view> ||
                              std::is_same_v<std::decay_t<T>, const char*> ||
                              (std::is_same_v<std::decay_t<T>, char*> and !std::is_same_v<T, bool>))
                    return std::get<std::string>(m_value).c_str();
 
                if constexpr (std::is_same_v<T, OpenXLSX::XLRichText>) return std::get<OpenXLSX::XLRichText>(m_value);
 
                if constexpr (std::is_same_v<T, XLDateTime>)
                    return XLDateTime(getDouble());    // 2025-01-10: allow implicit conversion of int and bool to double (string conversion
                                                       // disabled for now)
            }
 
            catch (const std::bad_variant_access&) {
                throw XLValueTypeError("XLCellValue object does not contain the requested type.");
            }
        }
 
    public:
        double getDouble() const
        {
            if (m_type == XLValueType::Error) return static_cast<double>(std::nan("1"));
            try {
                return std::visit(VisitXLCellValueTypeToDouble(), m_value);
            }
            catch (...) {
                throw XLValueTypeError("XLCellValue object is not convertible to double.");
            }
        }
 
        std::string getString()    // pull request #158 is covered by this
        {
            try {
                return std::visit(VisitXLCellValueTypeToString(), m_value);
            }
            catch (...) {    // 2024-05-27: was catch( string s ) - must have been a typo, currently nothing throws a string here
                throw XLValueTypeError("XLCellValue object is not convertible to string.");
            }
        }
 
        const XLCellValueType& getVariant() const    // pull request #127
        { return m_value; }
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, OpenXLSX::XLRichText> or std::is_same_v<T, XLDateTime>>>
        operator T() const
        { return this->get<T>(); }
 
        XLCellValue& clear();
 
        XLCellValue& setError(const std::string& error);
 
        XLValueType type() const;
 
        const char* typeAsString() const;
 
    private:
        XLCellValueType m_value{std::string("")};   
        XLValueType     m_type{XLValueType::Empty}; 
    };
 
    class OPENXLSX_EXPORT XLCellValueProxy
    {
        friend class XLCell;
        friend class XLCellValue;
        friend class XLDocument;    // for reindexing shared strings
 
    public:
        ~XLCellValueProxy();
 
        XLCellValueProxy& operator=(const XLCellValueProxy& other);
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, XLCellValue> or std::is_same_v<T, XLDateTime> or
                     std::is_same_v<T, OpenXLSX::XLRichText>>>
        XLCellValueProxy& operator=(const T& value)
        {    // NOLINT
 
            if constexpr (std::is_integral_v<T> and std::is_same_v<T, bool>)    // if bool
                setBoolean(value);
 
            else if constexpr (std::is_integral_v<T> and !std::is_same_v<T, bool>)    // if integer
                setInteger(value);
 
            else if constexpr (std::is_floating_point_v<T>)    // if floating point
                setFloat(value);
 
            else if constexpr (std::is_same_v<T, XLDateTime>)
                setFloat(value.serial());
 
            else if constexpr (std::is_same_v<T, OpenXLSX::XLRichText>)
                setRichText(value);
 
            else if constexpr (std::is_same_v<std::decay_t<T>, std::string> or std::is_same_v<std::decay_t<T>, std::string_view> ||
                               std::is_same_v<std::decay_t<T>, const char*> ||
                               (std::is_same_v<std::decay_t<T>, char*> and !std::is_same_v<T, bool> and !std::is_same_v<T, XLCellValue>))
            {
                setString(value);
            }
 
            if constexpr (std::is_same_v<T, XLCellValue>) {
                switch (value.type()) {
                    case XLValueType::Boolean:
                        setBoolean(value.template get<bool>());
                        break;
                    case XLValueType::Integer:
                        setInteger(value.template get<int64_t>());
                        break;
                    case XLValueType::Float:
                        setFloat(value.template get<double>());
                        break;
                    case XLValueType::String:
                        setString(value.template privateGet<const char*>());
                        break;
                    case XLValueType::RichText:
                        setRichText(value.template get<OpenXLSX::XLRichText>());
                        break;
                    case XLValueType::Empty:
                        clear();
                        break;
                    default:
                        setError("#N/A");
                        break;
                }
            }
 
            return *this;
        }
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, XLCellValue> or std::is_same_v<T, XLDateTime> or
                     std::is_same_v<T, OpenXLSX::XLRichText>>>
        void set(const T& value)
        { *this = value; }
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, OpenXLSX::XLRichText> or std::is_same_v<T, XLDateTime>>>
        T get() const
        {
            if constexpr (std::is_same_v<std::decay_t<T>, std::string_view> || std::is_same_v<std::decay_t<T>, const char*>) {
                auto view = getStringView();
                if constexpr (std::is_same_v<std::decay_t<T>, const char*>) return view.data();
                else return view;
            }
            else if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
                return std::string(getStringView());
            }
            else {
                return getValue().get<T>();
            }
        }
 
        XLCellValueProxy& clear();
 
        XLCellValueProxy& setError(const std::string& error);
 
        XLValueType type() const;
 
        const char* typeAsString() const;
 
        operator XLCellValue() const;    // NOLINT
 
        template<typename T,
                 typename = std::enable_if_t<
                     std::is_integral_v<T> or std::is_floating_point_v<T> or std::is_same_v<std::decay_t<T>, std::string> ||
                     std::is_same_v<std::decay_t<T>, std::string_view> or std::is_same_v<std::decay_t<T>, const char*> ||
                     std::is_same_v<std::decay_t<T>, char*> or std::is_same_v<T, OpenXLSX::XLRichText> or std::is_same_v<T, XLDateTime>>>
        operator T() const
        { return getValue().get<T>(); }
 
        std::string_view getStringView() const;
        std::string getString() const    // pull request #158 is covered by this
        {
            try {
                return std::visit(VisitXLCellValueTypeToString(), getValue().m_value);
            }
            catch (std::string s) {
                throw XLValueTypeError("XLCellValue object is not convertible to string.");
            }
        }
 
    private:
        XLCellValueProxy(XLCell* cell, XMLNode* cellNode);
 
        XLCellValueProxy(const XLCellValueProxy& other);
 
        XLCellValueProxy(XLCellValueProxy&& other) noexcept;
 
        XLCellValueProxy& operator=(XLCellValueProxy&& other) noexcept;
 
        void setInteger(int64_t numberValue);
 
        void setBoolean(bool numberValue);
 
        void setFloat(double numberValue);
 
        void setString(std::string_view stringValue);
 
        void setRichText(const XLRichText& richTextValue);
 
        XLCellValue getValue() const;
 
        int32_t stringIndex() const;
 
        bool     setStringIndex(int32_t newIndex);
        XLCell*  m_cell;     
        XMLNode* m_cellNode; 
    };
 
}    // namespace OpenXLSX
 
#include <functional>
 
namespace OpenXLSX
{
    // Utility for cross-type comparison
    template<typename Op>
    struct XLCompareVisitor
    {
        template<typename T, typename U>
        bool operator()(const T& lhs, const U& rhs) const
        {
            if constexpr (std::is_arithmetic_v<T> && std::is_arithmetic_v<U> && !std::is_same_v<T, bool> && !std::is_same_v<U, bool>) {
                return Op{}(lhs, rhs);
            }
            else if constexpr (std::is_same_v<T, bool> && std::is_same_v<U, bool>) {
                return Op{}(lhs, rhs);
            }
            else if constexpr (std::is_same_v<T, std::string> && std::is_same_v<U, std::string>) {
                return Op{}(lhs, rhs);
            }
            else {
                return false;
            }
        }
    };
 
    inline bool operator==(const XLCellValue& lhs, const XLCellValue& rhs)
    { return std::visit(XLCompareVisitor<std::equal_to<>>{}, lhs.m_value, rhs.m_value); }
 
    inline bool operator!=(const XLCellValue& lhs, const XLCellValue& rhs)
    { return std::visit(XLCompareVisitor<std::not_equal_to<>>{}, lhs.m_value, rhs.m_value); }
 
    inline bool operator<(const XLCellValue& lhs, const XLCellValue& rhs)
    { return std::visit(XLCompareVisitor<std::less<>>{}, lhs.m_value, rhs.m_value); }
 
    inline bool operator>(const XLCellValue& lhs, const XLCellValue& rhs)
    { return std::visit(XLCompareVisitor<std::greater<>>{}, lhs.m_value, rhs.m_value); }
 
    inline bool operator<=(const XLCellValue& lhs, const XLCellValue& rhs)
    { return std::visit(XLCompareVisitor<std::less_equal<>>{}, lhs.m_value, rhs.m_value); }
 
    inline bool operator>=(const XLCellValue& lhs, const XLCellValue& rhs)
    { return std::visit(XLCompareVisitor<std::greater_equal<>>{}, lhs.m_value, rhs.m_value); }
 
    inline std::ostream& operator<<(std::ostream& os, const XLCellValue& value)
    {
        switch (value.type()) {
            case XLValueType::Empty:
                return os << "";
            case XLValueType::Boolean:
                return os << value.get<bool>();
            case XLValueType::Integer:
                return os << value.get<int64_t>();
            case XLValueType::Float:
                return os << value.get<double>();
            case XLValueType::String:
                return os << value.get<std::string>();    // 2025-01-10 BUGFIX: for temporary value objects, this was undefined behavior due
                                                          // to returning a string_view
            case XLValueType::RichText:
                return os << value.get<OpenXLSX::XLRichText>().plainText();
            default:
                return os << "";
        }
    }
 
    inline std::ostream& operator<<(std::ostream& os, const XLCellValueProxy& value)
    {
        switch (value.type()) {
            case XLValueType::Empty:
                return os << "";
            case XLValueType::Boolean:
                return os << value.get<bool>();
            case XLValueType::Integer:
                return os << value.get<int64_t>();
            case XLValueType::Float:
                return os << value.get<double>();
            case XLValueType::String:
                return os << value.get<std::string>();    // 2025-01-10 BUGFIX: for temporary value objects, this was undefined behavior due
                                                          // to returning a string_view
            case XLValueType::RichText:
                return os << value.getString();    // getString() for proxy calls VisitXLCellValueTypeToString which handles RichText
            default:
                return os << "";
        }
    }
 
}    // namespace OpenXLSX
 
namespace std
{
    template<>
    struct hash<OpenXLSX::XLRichTextRun>
    {
        std::size_t operator()(const OpenXLSX::XLRichTextRun& run) const noexcept
        {
            std::size_t h = std::hash<std::string>{}(run.text());
            if (run.bold()) h ^= std::hash<bool>{}(*run.bold()) + 0x9e3779b9 + (h << 6) + (h >> 2);
            if (run.italic()) h ^= std::hash<bool>{}(*run.italic()) + 0x9e3779b9 + (h << 6) + (h >> 2);
            return h;
        }
    };
 
    template<>
    struct hash<OpenXLSX::XLRichText>
    {
        std::size_t operator()(const OpenXLSX::XLRichText& rt) const noexcept
        {
            std::size_t h = 0;
            for (const auto& run : rt.runs()) { h ^= std::hash<OpenXLSX::XLRichTextRun>{}(run) + 0x9e3779b9 + (h << 6) + (h >> 2); }
            return h;
        }
    };
 
    template<>
    struct hash<OpenXLSX::XLCellValue>    // NOLINT
    {
        std::size_t operator()(const OpenXLSX::XLCellValue& value) const noexcept
        {
            return std::visit([](const auto& v) { return std::hash<std::decay_t<decltype(v)>>{}(v); }, value.getVariant());
        }
    };
}    // namespace std
 
#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
#    pragma warning(pop)
#endif    // _MSC_VER
 
#endif    // OPENXLSX_XLCELLVALUE_HPP