array_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 <vector>
 
namespace vitrio
{
 
class array_descriptor
{
public:
    VITRIO_API
    array_descriptor() noexcept;
 
    VITRIO_API
    array_descriptor(
        std::vector<std::size_t> extents,
        std::vector<std::ptrdiff_t> strides,
        std::ptrdiff_t offset,
        numerical_type data_type
    );
 
    VITRIO_API
    array_descriptor(const array_descriptor &other);
    VITRIO_API
    array_descriptor(array_descriptor &&other) noexcept;
    VITRIO_API
    ~array_descriptor();
 
    VITRIO_API
    array_descriptor& operator=(const array_descriptor &other);
    VITRIO_API
    array_descriptor& operator=(array_descriptor &&other) noexcept;
 
    VITRIO_API
    span<const std::size_t> get_extents() const noexcept;
 
    VITRIO_API
    span<const std::ptrdiff_t> get_strides() const noexcept;
 
    VITRIO_API
    std::ptrdiff_t get_offset() const noexcept;
 
    VITRIO_API
    numerical_type get_data_type() const noexcept;
 
    friend bool operator==(
        const array_descriptor &lhs,
        const array_descriptor &rhs
    ) noexcept
    {
        return
            lhs.m_offset == rhs.m_offset &&
            lhs.m_data_type == rhs.m_data_type &&
            lhs.m_extents == rhs.m_extents &&
            lhs.m_strides == rhs.m_strides;
    }
 
    friend bool operator!=(
        const array_descriptor &lhs,
        const array_descriptor &rhs
    ) noexcept
    {
        return !(lhs == rhs);
    }
 
private:
    std::vector<std::size_t> m_extents;
    std::vector<std::ptrdiff_t> m_strides;
    std::ptrdiff_t m_offset;
    numerical_type m_data_type;
};
 
VITRIO_API
array_descriptor make_contiguous_array_descriptor(
    span<const std::size_t> extents,
    numerical_type data_type
);
 
VITRIO_API
bool is_initialized(const array_descriptor &descriptor) noexcept;
 
} // namespace vitrio