image_location.hpp

// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <vitrio/export.hpp>
 
#include <cstddef>
#include <limits>
#include <ostream>
#include <string>
 
namespace vitrio
{
 
class image_location
{
public:
    VITRIO_API
    static constexpr std::size_t no_stack_index =
        std::numeric_limits<std::size_t>::max();
 
    VITRIO_API
    explicit image_location(
        std::string key,
        std::size_t index_in_stack = no_stack_index
    );
 
    VITRIO_API
    image_location() noexcept;
    VITRIO_API
    image_location(const image_location &other);
    VITRIO_API
    image_location(image_location &&other) noexcept;
    VITRIO_API
    ~image_location();
 
    VITRIO_API
    image_location& operator=(const image_location &other);
    VITRIO_API
    image_location& operator=(image_location &&other) noexcept;
 
    VITRIO_API
    std::size_t hash() const noexcept;
 
    VITRIO_API
    const std::string& get_key() const noexcept;
 
    VITRIO_API
    std::size_t get_index_in_stack() const noexcept;
 
    VITRIO_API
    bool has_index_in_stack() const noexcept;
 
    friend bool
    operator==(const image_location &lhs, const image_location &rhs) noexcept
    {
        return
            lhs.get_index_in_stack() == rhs.get_index_in_stack() &&
            lhs.get_key() == rhs.get_key();
    }
 
    friend bool
    operator!=(const image_location &lhs, const image_location &rhs) noexcept
    {
        return !(lhs == rhs);
    }
 
    friend bool
    operator<(const image_location &lhs, const image_location &rhs) noexcept
    {
        if (lhs.get_key() < rhs.get_key())
        {
            return true;
        }
        else if (lhs.get_key() == rhs.get_key())
        {
            return lhs.get_index_in_stack() < rhs.get_index_in_stack();
        }
        return false;
    }
 
    friend bool
    operator<=(const image_location &lhs, const image_location &rhs) noexcept
    {
        return !(rhs < lhs);
    }
 
    friend bool
    operator>(const image_location &lhs, const image_location &rhs) noexcept
    {
        return rhs < lhs;
    }
 
    friend bool
    operator>=(const image_location &lhs, const image_location &rhs) noexcept
    {
        return !(lhs < rhs);
    }
 
    friend std::ostream&
    operator<<(std::ostream &os, const image_location &location)
    {
        if (location.has_index_in_stack())
        {
            os << (location.get_index_in_stack() + 1) << '@';
        }
        return os << location.get_key();
    }
 
private:
    std::string m_key;
    std::size_t m_index_in_stack;
};
 
VITRIO_API
bool parse_image_location(const std::string &text, image_location &result);
 
VITRIO_API
std::string to_string(const image_location &location);
 
} // namespace vitrio
 
namespace std
{
 
template<>
struct hash<vitrio::image_location>
{
    std::size_t operator()(
        const vitrio::image_location &location
    ) const noexcept
    {
        return location.hash();
    }
};
 
} // namespace std