image_descriptor.hpp

// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <vitrio/array/numerical_type.hpp>
#include <vitrio/export.hpp>
#include <vitrio/span.hpp>
 
#include <cstddef>
#include <functional>
#include <vector>
 
namespace vitrio
{
 
class image_descriptor
{
public:
    VITRIO_API
    image_descriptor(
        span<const std::size_t> extents,
        std::size_t core_rank,
        numerical_type data_type
    );
 
    VITRIO_API
    image_descriptor(const image_descriptor &other);
    VITRIO_API
    image_descriptor(image_descriptor &&other) noexcept;
    VITRIO_API
    ~image_descriptor();
 
    VITRIO_API
    image_descriptor& operator=(const image_descriptor &other);
    VITRIO_API
    image_descriptor& operator=(image_descriptor &&other) noexcept;
 
    VITRIO_API
    std::size_t hash() const noexcept;
 
    VITRIO_API
    span<const std::size_t> get_extents() const noexcept;
 
    VITRIO_API
    std::size_t get_core_rank() const noexcept;
 
    VITRIO_API
    numerical_type get_data_type() const noexcept;
 
    friend bool operator==(
        const image_descriptor &lhs,
        const image_descriptor &rhs
    ) noexcept
    {
        return
            lhs.m_core_rank == rhs.m_core_rank &&
            lhs.m_data_type == rhs.m_data_type &&
            lhs.m_extents == rhs.m_extents;
    }
 
    friend bool operator!=(
        const image_descriptor &lhs,
        const image_descriptor &rhs
    ) noexcept
    {
        return !(lhs == rhs);
    }
 
private:
    std::vector<std::size_t> m_extents;
    std::size_t m_core_rank;
    numerical_type m_data_type;
};
 
VITRIO_API
span<const std::size_t>
get_core_extents(const image_descriptor &descriptor) noexcept;
 
} // namespace vitrio
 
namespace std
{
 
template<>
struct hash<vitrio::image_descriptor>
{
    std::size_t operator()(
        const vitrio::image_descriptor &descriptor
    ) const noexcept
    {
        return descriptor.hash();
    }
};
 
} // namespace std