cell_reference.hpp

// Copyright (c) 2014-2022 Thomas Fussell
// 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 <xlnt/xlnt_config.hpp>
#include <xlnt/cell/index_types.hpp>

#include <cstdint>
#include <functional>
#include <string>
#include <utility>

namespace xlnt {

class cell_reference;
class range_reference;

struct XLNT_API cell_reference_hash
{
    std::size_t operator()(const cell_reference &k) const;
};

class XLNT_API cell_reference
{
public:
    static std::pair<std::string, row_t> split_reference(const std::string &reference_string);

    static std::pair<std::string, row_t> split_reference(
        const std::string &reference_string, bool &absolute_column, bool &absolute_row);

    // constructors

    cell_reference();

    // TODO: should these be explicit? The implicit conversion is nice sometimes.

    cell_reference(const char *reference_string);

    cell_reference(const std::string &reference_string);

    cell_reference(column_t column, row_t row);

    // absoluteness

    cell_reference &make_absolute(bool absolute_column = true, bool absolute_row = true);

    bool column_absolute() const;

    void column_absolute(bool absolute_column);

    bool row_absolute() const;

    void row_absolute(bool absolute_row);

    // getters/setters

    column_t column() const;

    void column(const std::string &column_string);

    column_t::index_t column_index() const;

    void column_index(column_t column);

    row_t row() const;

    void row(row_t row);

    cell_reference make_offset(int column_offset, int row_offset) const;

    std::string to_string() const;

    range_reference to_range() const;

    // operators

    range_reference operator,(const cell_reference &other) const;

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

    bool operator==(const std::string &reference_string) const;

    bool operator==(const char *reference_string) const;

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

    bool operator!=(const std::string &reference_string) const;

    bool operator!=(const char *reference_string) const;

private:
    column_t column_;

    row_t row_;

    bool absolute_row_;

    bool absolute_column_;
};

} // namespace xlnt

namespace std {
template <>
struct hash<xlnt::cell_reference>
{
    size_t operator()(const xlnt::cell_reference &x) const
    {
        static_assert(std::is_same<decltype(x.row()), std::uint32_t>::value, "this hash function expects both row and column to be 32-bit numbers");
        static_assert(std::is_same<decltype(x.column_index()), std::uint32_t>::value, "this hash function expects both row and column to be 32-bit numbers");
        return hash<std::uint64_t>{}(x.row() | static_cast<std::uint64_t>(x.column_index()) << 32);
    }
};
} // namespace std