cell.hpp

// Copyright (c) 2014-2022 Thomas Fussell
// Copyright (c) 2010-2015 openpyxl
// Copyright (c) 2024-2025 xlnt-community
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE
//
// @license: http://www.opensource.org/licenses/mit-license.php
// @author: see AUTHORS file

#pragma once

#include <string>
#include <unordered_map>

#include <xlnt/xlnt_config.hpp>
#include <xlnt/cell/cell_type.hpp>
#include <xlnt/cell/index_types.hpp>
#include <xlnt/cell/rich_text.hpp>

namespace xlnt {

enum class calendar;

class alignment;
class base_format;
class border;
class cell_reference;
class comment;
class fill;
class font;
class format;
class number_format;
class protection;
class range;
class relationship;
class style;
class workbook;
class worksheet;
class xlsx_consumer;
class xlsx_producer;
class phonetic_pr;

struct date;
struct datetime;
struct time;
struct timedelta;

namespace detail {

class xlsx_consumer;
class xlsx_producer;

struct cell_impl;

} // namespace detail

class XLNT_API cell
{
public:
    using type = cell_type;

    static const std::unordered_map<std::string, int> &error_codes();

    cell(const cell &) = default;

    // value

    bool has_value() const;

    template <typename T>
    T value() const;

    void clear_value();

    void value(std::nullptr_t);

    void value(bool boolean_value);

    void value(int int_value);

    void value(unsigned int int_value);

    void value(long long int int_value);

    void value(unsigned long long int int_value);

    void value(float float_value);

    void value(double float_value);

    void value(const date &date_value);

    void value(const time &time_value);

    void value(const datetime &datetime_value);

    void value(const timedelta &timedelta_value);

    void value(const std::string &string_value);

    void value(const char *string_value);

    void value(const rich_text &text_value);

    void value(const cell other_cell);

    void value(const std::string &string_value, bool infer_type);

    type data_type() const;

    void data_type(type t);

    // properties

    bool garbage_collectible() const;

    bool is_date() const;

    // position

    cell_reference reference() const;

    column_t column() const;

    column_t::index_t column_index() const;

    row_t row() const;

    std::pair<int, int> anchor() const;

    // hyperlink

    class hyperlink hyperlink() const;

    void hyperlink(const std::string &url, const std::string &display = "");

    void hyperlink(xlnt::cell target, const std::string &display = "");

    void hyperlink(xlnt::range target, const std::string &display = "");

    bool has_hyperlink() const;

    // computed formatting

    class alignment computed_alignment() const;

    class border computed_border() const;

    class fill computed_fill() const;

    class font computed_font() const;

    class number_format computed_number_format() const;

    class protection computed_protection() const;

    // format

    bool has_format() const;

    const class format format() const;

    void format(const class format new_format);

    void clear_format();

    class number_format number_format() const;

    void number_format(const class number_format &format);

    class font font() const;

    void font(const class font &font_);

    class fill fill() const;

    void fill(const class fill &fill_);

    class border border() const;

    void border(const class border &border_);

    class alignment alignment() const;

    void alignment(const class alignment &alignment_);

    class protection protection() const;

    void protection(const class protection &protection_);

    // style

    bool has_style() const;

    class style style();

    const class style style() const;

    void style(const class style &new_style);

    void style(const std::string &style_name);

    void clear_style();

    // formula

    std::string formula() const;

    void formula(const std::string &formula);

    void clear_formula();

    bool has_formula() const;

    // printing

    std::string to_string() const;

    // merging

    bool is_merged() const;

    void merged(bool merged);

    // phonetics

    bool phonetics_visible() const;

    void show_phonetics(bool phonetics);

    std::string error() const;

    void error(const std::string &error);

    cell offset(int column, int row);

    class worksheet worksheet();

    const class worksheet worksheet() const;

    class workbook workbook();

    const class workbook workbook() const;

    calendar base_date() const;

    std::string check_string(const std::string &to_check);

    // comment

    bool has_comment() const;

    void clear_comment();

    class comment comment() const;

    void comment(const std::string &text,
        const std::string &author = "Microsoft Office User");

    void comment(const std::string &comment_text,
        const class font &comment_font,
        const std::string &author = "Microsoft Office User");

    void comment(const class comment &new_comment);

    double width() const;

    double height() const;

    // comparisons

    bool compare(const cell &other, bool compare_by_reference) const;

    // operators

    cell &operator=(const cell &rhs);

    bool operator==(const cell &comparand) const;

    bool operator!=(const cell &comparand) const;

private:
    friend class style;
    friend class worksheet;
    friend class detail::xlsx_consumer;
    friend class detail::xlsx_producer;
    friend struct detail::cell_impl;

    void value_no_check(const rich_text &text);

    void copy_from_other_workbook(const cell &source);

    void copy_format_from_other_workbook(const class format &source_format);

    class format modifiable_format();

    cell() = delete;

    cell(detail::cell_impl *d);

    detail::cell_impl *d_ = nullptr;
};

XLNT_API bool operator==(std::nullptr_t, const cell &cell);

XLNT_API bool operator==(const cell &cell, std::nullptr_t);

XLNT_API bool operator!=(std::nullptr_t, const cell &cell);

XLNT_API bool operator!=(const cell &cell, std::nullptr_t);

XLNT_API std::ostream &operator<<(std::ostream &stream, const xlnt::cell &cell);

template <>
XLNT_API bool cell::value<bool>() const;

template <>
XLNT_API int cell::value<int>() const;

template <>
XLNT_API unsigned int cell::value<unsigned int>() const;

template <>
XLNT_API long long int cell::value<long long int>() const;

template <>
XLNT_API unsigned long long cell::value<unsigned long long int>() const;

template <>
XLNT_API float cell::value<float>() const;

template <>
XLNT_API double cell::value<double>() const;

template <>
XLNT_API date cell::value<date>() const;

template <>
XLNT_API time cell::value<time>() const;

template <>
XLNT_API datetime cell::value<datetime>() const;

template <>
XLNT_API timedelta cell::value<timedelta>() const;

template <>
XLNT_API std::string cell::value<std::string>() const;

template <>
XLNT_API rich_text cell::value<rich_text>() const;

} // namespace xlnt