mdspec.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/mdspan/concepts.hpp>
 
#include <concepts>
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace uni20
{
 
template <class ElementType, class Extents, class LayoutPolicy, AccessorPolicy Accessor, class DataDescriptor>
  requires std::same_as<ElementType, typename Accessor::element_type>
class mdspec {
  public:
    using element_type = ElementType;
    using value_type = std::remove_cv_t<element_type>;
    using extents_type = Extents;
    using layout_type = LayoutPolicy;
    using mapping_type = typename layout_type::template mapping<extents_type>;
    using accessor_type = Accessor;
    using data_descriptor_type = DataDescriptor;
    using data_handle_type = typename accessor_type::data_handle_type;
    using reference = typename accessor_type::reference;
    using index_type = typename extents_type::index_type;
    using size_type = typename extents_type::size_type;
    using rank_type = typename extents_type::rank_type;
 
    constexpr explicit mdspec(data_descriptor_type descriptor, mapping_type mapping, accessor_type accessor)
        : descriptor_(std::move(descriptor)), mapping_(std::move(mapping)), accessor_(std::move(accessor))
    {}
 
    [[nodiscard]] static constexpr rank_type rank() noexcept { return extents_type::rank(); }
 
    [[nodiscard]] static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
 
    [[nodiscard]] static constexpr std::size_t static_extent(rank_type axis) noexcept
    {
      return extents_type::static_extent(axis);
    }
 
    [[nodiscard]] static constexpr bool is_always_unique() noexcept { return mapping_type::is_always_unique(); }
 
    [[nodiscard]] static constexpr bool is_always_exhaustive() noexcept { return mapping_type::is_always_exhaustive(); }
 
    [[nodiscard]] static constexpr bool is_always_strided() noexcept { return mapping_type::is_always_strided(); }
 
    [[nodiscard]] constexpr auto data_descriptor() noexcept -> data_descriptor_type& { return descriptor_; }
 
    [[nodiscard]] constexpr auto data_descriptor() const noexcept -> data_descriptor_type const& { return descriptor_; }
 
    [[nodiscard]] constexpr auto mapping() const noexcept -> mapping_type const& { return mapping_; }
 
    [[nodiscard]] constexpr auto accessor() const noexcept -> accessor_type const& { return accessor_; }
 
    [[nodiscard]] constexpr auto extents() const noexcept -> extents_type const& { return mapping_.extents(); }
 
    [[nodiscard]] constexpr index_type extent(rank_type axis) const noexcept { return this->extents().extent(axis); }
 
    [[nodiscard]] constexpr bool is_unique() const noexcept { return mapping_.is_unique(); }
 
    [[nodiscard]] constexpr bool is_exhaustive() const noexcept { return mapping_.is_exhaustive(); }
 
    [[nodiscard]] constexpr bool is_strided() const noexcept { return mapping_.is_strided(); }
 
    [[nodiscard]] constexpr index_type stride(rank_type axis) const
      requires requires(mapping_type const& mapping) {
        { mapping.stride(axis) } -> std::convertible_to<index_type>;
      }
    {
      return mapping_.stride(axis);
    }
 
  private:
    [[no_unique_address]] data_descriptor_type descriptor_;
    [[no_unique_address]] mapping_type mapping_;
    [[no_unique_address]] accessor_type accessor_;
};
 
} // namespace uni20