mdspec_tensor_view.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/tensor/concepts.hpp>
#include <uni20/core/runtime_precision.hpp>
 
#include <concepts>
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace uni20
{
 
template <MdspecLike MutableMdspec, MdspecLike ConstMdspec, class StoragePolicy>
  requires(std::same_as<typename MutableMdspec::extents_type, typename ConstMdspec::extents_type> &&
           std::same_as<std::remove_const_t<typename MutableMdspec::element_type>,
                        std::remove_const_t<typename ConstMdspec::element_type>> &&
           std::is_const_v<typename ConstMdspec::element_type> && requires { StoragePolicy::backend_selector(); })
class MdspecTensorView : public detail::precision_default<typename MutableMdspec::value_type> {
  public:
    using mutable_mdspec_type = MutableMdspec;
    using const_mdspec_type = ConstMdspec;
    using storage_policy = StoragePolicy;
    using backend_selector_type = std::remove_cvref_t<decltype(storage_policy::backend_selector())>;
    using element_type = typename mutable_mdspec_type::element_type;
    using value_type = std::remove_cv_t<element_type>;
    using extents_type = typename mutable_mdspec_type::extents_type;
    using index_type = typename extents_type::index_type;
 
    constexpr MdspecTensorView(mutable_mdspec_type mutable_mdspec, const_mdspec_type const_mdspec)
        : mutable_mdspec_(std::move(mutable_mdspec)), const_mdspec_(std::move(const_mdspec))
    {}
 
    [[nodiscard]] static constexpr auto backend_selector() noexcept -> backend_selector_type
    {
      return storage_policy::backend_selector();
    }
 
    [[nodiscard]] constexpr auto mdspec() & -> mutable_mdspec_type { return mutable_mdspec_; }
 
    [[nodiscard]] constexpr auto mdspec() const& -> const_mdspec_type { return const_mdspec_; }
 
    [[nodiscard]] constexpr auto mdspan() & -> mutable_mdspec_type
      requires MdspanLike<mutable_mdspec_type>
    {
      return mutable_mdspec_;
    }
 
    [[nodiscard]] constexpr auto mdspan() const& -> const_mdspec_type
      requires MdspanLike<const_mdspec_type>
    {
      return const_mdspec_;
    }
 
    [[nodiscard]] static constexpr std::size_t rank() noexcept { return extents_type::rank(); }
 
    [[nodiscard]] constexpr auto extents() const noexcept -> extents_type const& { return const_mdspec_.extents(); }
 
    [[nodiscard]] constexpr auto extent(std::size_t axis) const noexcept -> index_type
    {
      return const_mdspec_.extent(axis);
    }
 
    [[nodiscard]] constexpr auto stride(std::size_t axis) const -> index_type
      requires StridedMdspecLike<const_mdspec_type>
    {
      return const_mdspec_.stride(axis);
    }
 
    template <class... Index>
      requires MdspanLike<mutable_mdspec_type> && (sizeof...(Index) == extents_type::rank())
    constexpr decltype(auto) operator[](Index... indices)
    {
      return mutable_mdspec_[indices...];
    }
 
    template <class... Index>
      requires MdspanLike<const_mdspec_type> && (sizeof...(Index) == extents_type::rank())
    constexpr decltype(auto) operator[](Index... indices) const
    {
      return const_mdspec_[indices...];
    }
 
  private:
    [[no_unique_address]] mutable_mdspec_type mutable_mdspec_;
    [[no_unique_address]] const_mdspec_type const_mdspec_;
};
 
} // namespace uni20