XLCell.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLCELL_HPP
#define OPENXLSX_XLCELL_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
 
#include <iostream>    // std::ostream
#include <memory>
#include <ostream>    // std::basic_ostream
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLCellReference.hpp"
#include "XLCellValue.hpp"
#include "XLFormula.hpp"
#include "XLSharedStrings.hpp"
#include "XLStyle.hpp"
#include "XLStyles.hpp"    // XLStyleIndex
 
namespace OpenXLSX
{
    // ===== Flags that can be passed to XLCell::clear as parameter keep, flags can be combined with bitwise OR
    //                                  // Do not clear the cell's:
    constexpr const uint32_t XLKeepCellStyle   = 1;    // style (attribute s)
    constexpr const uint32_t XLKeepCellType    = 2;    // type (attribute t)
    constexpr const uint32_t XLKeepCellValue   = 4;    // value (child node v)
    constexpr const uint32_t XLKeepCellFormula = 8;    // formula (child node f)
 
    class XLCellRange;
 
    class XLWorksheet;
    class XLThreadedComment;
 
    class OPENXLSX_EXPORT XLCell
    {
        friend class XLCellIterator;
        friend class XLCellValueProxy;
        friend class XLFormulaProxy;
        friend class XLRowDataIterator;
        friend bool operator==(const XLCell& lhs, const XLCell& rhs);
        friend bool operator!=(const XLCell& lhs, const XLCell& rhs);
 
    public:
        XLCell();
 
        XLCell(const XMLNode& cellNode, const XLSharedStrings& sharedStrings, XLWorksheet* wks = nullptr);
 
        XLCell(const XLCell& other);
 
        XLCell(XLCell&& other) noexcept;
 
        virtual ~XLCell();
 
        virtual XLCell& operator=(const XLCell& other);
 
        virtual XLCell& operator=(XLCell&& other) noexcept;
 
        void copyFrom(XLCell const& other);
 
        bool empty() const;
 
        explicit operator bool() const;
 
        void clear(uint32_t keep);
 
        XLCellValueProxy& value();
 
        const XLCellValueProxy& value() const;
 
        XLCellReference cellReference() const;
 
        XLCell offset(uint16_t rowOffset, uint16_t colOffset) const;
 
        bool hasFormula() const;
 
        XLFormulaProxy& formula();
 
        const XLFormulaProxy& formula() const;
 
        std::string getString() const { return value().getString(); }
 
        XLStyleIndex cellFormat() const;
 
        XLCell& setCellFormat(XLStyleIndex cellFormatIndex);
 
        XLCell& setStyle(const XLStyle& style);
 
        XLThreadedComment addComment(std::string_view text, std::string_view author = "");
 
        XLCell& addNote(std::string_view text, std::string_view author = "");
 
        void print(std::basic_ostream<char>& ostr) const;
 
    private:
        static bool              isEqual(const XLCell& lhs, const XLCell& rhs);
        XMLNode m_cellNode;      
        XLSharedStringsRef       m_sharedStrings; 
        XLCellValueProxy         m_valueProxy;    
        XLFormulaProxy           m_formulaProxy;  
        XLWorksheet*             m_wks{nullptr};  
    };
 
    class OPENXLSX_EXPORT XLCellAssignable : public XLCell
    {
    public:
        XLCellAssignable() : XLCell() {}
 
        XLCellAssignable(XLCell const& other);
        XLCellAssignable(XLCellAssignable const& other);
 
        XLCellAssignable(XLCell&& other);
        XLCellAssignable(XLCellAssignable&& other) noexcept;
 
        XLCellAssignable& operator=(const XLCell& other) override;
        XLCellAssignable& operator=(const XLCellAssignable& other);
 
        XLCellAssignable& operator=(XLCell&& other) noexcept override;
        XLCellAssignable& operator=(XLCellAssignable&& other) noexcept;
 
        XLCellAssignable& addNote(std::string_view text, std::string_view author = "") {
            XLCell::addNote(text, author);
            return *this;
        }
 
        XLCellAssignable& setCellFormat(XLStyleIndex cellFormatIndex) {
            XLCell::setCellFormat(cellFormatIndex);
            return *this;
        }
 
        XLCellAssignable& setStyle(const XLStyle& style) {
            XLCell::setStyle(style);
            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, XLDateTime>>>
        XLCellAssignable& operator=(T value)
        {
            XLCell::value() = value;    // forward implementation to templated XLCellValue& XLCellValue::operator=(T value)
            return *this;
        }
    };
}    // namespace OpenXLSX
 
namespace OpenXLSX
{
    inline bool operator==(const XLCell& lhs, const XLCell& rhs) { return XLCell::isEqual(lhs, rhs); }
 
    inline bool operator!=(const XLCell& lhs, const XLCell& rhs) { return !XLCell::isEqual(lhs, rhs); }
 
    inline std::ostream& operator<<(std::ostream& os, const XLCell& c)
    {
        XLCellValue val = c.value();
        switch (val.type()) {
            case XLValueType::Integer:
                os << val.get<int64_t>();
                break;
            case XLValueType::Float:
                os << val.get<double>();
                break;
            case XLValueType::Boolean:
                os << (val.get<bool>() ? "true" : "false");
                break;
            case XLValueType::Empty:
                break;
            default:
                os << c.getString();
                break;
        }
        return os;
    }
 
    inline std::ostream& operator<<(std::ostream& os, const XLCellAssignable& c)
    {
        XLCellValue val = c.value();
        switch (val.type()) {
            case XLValueType::Integer:
                os << val.get<int64_t>();
                break;
            case XLValueType::Float:
                os << val.get<double>();
                break;
            case XLValueType::Boolean:
                os << (val.get<bool>() ? "true" : "false");
                break;
            case XLValueType::Empty:
                break;
            default:
                os << c.getString();
                break;
        }
        return os;
    }
}    // 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_XLCELL_HPP