XLFormula.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLFORMULA_HPP
#define OPENXLSX_XLFORMULA_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 <iostream>
#include <string>
#include <variant>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLXmlParser.hpp"
 
namespace OpenXLSX
{
    constexpr bool XLResetValue    = true;
    constexpr bool XLPreserveValue = false;
 
    //---------- Forward Declarations ----------//
    class XLFormulaProxy;
    class XLCell;
 
    class OPENXLSX_EXPORT XLFormula
    {
        //---------- Friend Declarations ----------//
 
        friend bool          operator==(const XLFormula& lhs, const XLFormula& rhs);
        friend bool          operator!=(const XLFormula& lhs, const XLFormula& rhs);
        friend std::ostream& operator<<(std::ostream& os, const XLFormula& value);
 
    public:
        XLFormula();
 
        template<
            typename T,
            typename = std::enable_if_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*>>>
        explicit XLFormula(T formula)
        {
            // ===== If the argument is a const char *, use the argument directly; otherwise, assume it has a .c_str() function.
            if constexpr (std::is_same_v<std::decay_t<T>, const char*> or std::is_same_v<std::decay_t<T>, char*>)
                m_formulaString = formula;
            else if constexpr (std::is_same_v<std::decay_t<T>, std::string_view>)
                m_formulaString = std::string(formula);
            else
                m_formulaString = formula.c_str();
        }
 
        XLFormula(const XLFormula& other);
 
        XLFormula(XLFormula&& other) noexcept;
 
        ~XLFormula();
 
        XLFormula& operator=(const XLFormula& other);
 
        XLFormula& operator=(XLFormula&& other) noexcept;
 
        template<
            typename T,
            typename = std::enable_if_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*>>>
        XLFormula& operator=(T formula)
        {
            XLFormula temp(formula);
            std::swap(*this, temp);
            return *this;
        }
 
        template<
            typename T,
            typename = std::enable_if_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*>>>
        void set(T formula)
        { *this = formula; }
 
        std::string get() const;
 
        operator std::string() const;    // NOLINT
 
        XLFormula& clear();
 
    private:
        std::string m_formulaString; 
    };
 
    class OPENXLSX_EXPORT XLFormulaProxy
    {
        friend class XLCell;
        friend class XLFormula;
 
    public:
        ~XLFormulaProxy();
 
        XLFormulaProxy& operator=(const XLFormulaProxy& other);
 
        template<typename T,
                 typename = std::enable_if_t<std::is_same_v<std::decay_t<T>, XLFormula> or std::is_same_v<std::decay_t<T>, std::string> ||
                                             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*>>>
        XLFormulaProxy& operator=(T formula)
        {
            if constexpr (std::is_same_v<std::decay_t<T>, XLFormula>)
                setFormulaString(formula.get().c_str());
            else if constexpr (std::is_same_v<std::decay_t<T>, std::string>)
                setFormulaString(formula.c_str());
            else if constexpr (std::is_same_v<std::decay_t<T>, std::string_view>)
                setFormulaString(std::string(formula).c_str());
            else
                setFormulaString(formula);
 
            return *this;
        }
 
        template<
            typename T,
            typename = std::enable_if_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*>>>
        void set(T formula)
        { *this = formula; }
 
        std::string get() const;
 
        XLFormulaProxy& clear();
 
        operator std::string() const;    // NOLINT
 
        operator XLFormula() const;    // NOLINT
 
    private:
        XLFormulaProxy(XLCell* cell, XMLNode* cellNode);
 
        XLFormulaProxy(const XLFormulaProxy& other);
 
        XLFormulaProxy(XLFormulaProxy&& other) noexcept;
 
        XLFormulaProxy& operator=(XLFormulaProxy&& other) noexcept;
 
        void setFormulaString(const char* formulaString, bool resetValue = XLResetValue);
 
        XLFormula getFormula() const;
 
        //---------- Private Member Variables ---------- //
        XLCell*  m_cell;     
        XMLNode* m_cellNode; 
    };
}    // namespace OpenXLSX
 
namespace OpenXLSX
{
    inline bool operator==(const XLFormula& lhs, const XLFormula& rhs) { return lhs.m_formulaString == rhs.m_formulaString; }
 
    inline bool operator!=(const XLFormula& lhs, const XLFormula& rhs) { return lhs.m_formulaString != rhs.m_formulaString; }
 
    inline std::ostream& operator<<(std::ostream& os, const XLFormula& value) { return os << value.m_formulaString; }
 
    inline std::ostream& operator<<(std::ostream& os, const XLFormulaProxy& value) { return os << value.get(); }
}    // 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_XLFORMULA_HPP