index_types.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 <cstdint>
#include <string>

#include <xlnt/xlnt_config.hpp>

// We might want to change these types for various optimizations in the future
// so use typedefs.

namespace xlnt {

using row_t = std::uint32_t;

class XLNT_API column_t
{
public:
    using index_t = std::uint32_t;

    static index_t column_index_from_string(const std::string &column_string);

    static std::string column_string_from_index(index_t column_index);

    column_t();

    column_t(index_t column_index);

    column_t(const std::string &column_string);

    column_t(const char *column_string);

    std::string column_string() const;

    column_t &operator=(const std::string &rhs);

    column_t &operator=(const char *rhs);

    bool operator==(const column_t &other) const;

    bool operator!=(const column_t &other) const;

    bool operator==(int other) const;

    bool operator==(index_t other) const;

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

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

    bool operator!=(int other) const;

    bool operator!=(index_t other) const;

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

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

    bool operator>(const column_t &other) const;

    bool operator>=(const column_t &other) const;

    bool operator<(const column_t &other) const;

    bool operator<=(const column_t &other) const;

    bool operator>(const column_t::index_t &other) const;

    bool operator>=(const column_t::index_t &other) const;

    bool operator<(const column_t::index_t &other) const;

    bool operator<=(const column_t::index_t &other) const;

    column_t &operator++();

    column_t &operator--();

    column_t operator++(int);

    column_t operator--(int);

    friend XLNT_API column_t operator+(column_t lhs, const column_t &rhs);

    friend XLNT_API column_t operator-(column_t lhs, const column_t &rhs);

    column_t &operator+=(const column_t &rhs);

    column_t &operator-=(const column_t &rhs);

    friend XLNT_API bool operator>(const column_t::index_t &left, const column_t &right);

    friend XLNT_API bool operator>=(const column_t::index_t &left, const column_t &right);

    friend XLNT_API bool operator<(const column_t::index_t &left, const column_t &right);

    friend XLNT_API bool operator<=(const column_t::index_t &left, const column_t &right);

    friend XLNT_API void swap(column_t &left, column_t &right);

    index_t index;
};

enum class row_or_col_t : int
{
    row,
    column
};

struct XLNT_API column_hash
{
    std::size_t operator()(const column_t &k) const;
};

} // namespace xlnt

namespace std {

template <>
struct hash<xlnt::column_t>
{
    size_t operator()(const xlnt::column_t &k) const
    {
        static xlnt::column_hash hasher;
        return hasher(k);
    }
};

} // namespace std