view.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_TENSOR_VIEWS_VIEW_H
#define pRC_CORE_TENSOR_VIEWS_VIEW_H
 
#include <prc/core/basic/crtp.hpp>
#include <prc/core/basic/sequence.hpp>
#include <prc/core/container/subscripts.hpp>
#include <prc/core/functors/subscript.hpp>
#include <prc/core/tensor/declarations.hpp>
 
namespace pRC::TensorViews
{
    template<class T, Size... Ns, class F>
        requires IsDefined<Tensor<T, Ns...>>
    class View<T, Sizes<Ns...>, F> : public CRTP<F>
    {
    public:
        using Type = T;
        template<class C>
        using ChangeType = Tensor<C, Ns...>;
 
        using Sizes = pRC::Sizes<Ns...>;
        template<Size... Ss>
        using ChangeSizes = Tensor<T, Ss...>;
 
        using Subscripts = pRC::Subscripts<Ns...>;
 
        static constexpr auto Dimension = Sizes::Dimension;
 
        static constexpr auto size()
        {
            return Sizes::size();
        }
 
        static constexpr auto size(Index const dimension)
        {
            return Sizes::size(dimension);
        }
 
        template<class X, IsConvertible<Index>... Is>
            requires IsConstructible<T, X> && (sizeof...(Is) == Dimension)
        static constexpr auto Single(X &&value, Is const... indices)
        {
            return Tensor<T, Ns...>::Single(forward<X>(value), indices...);
        }
 
        template<class X>
            requires IsConstructible<T, X>
        static constexpr auto Single(X &&value, Subscripts const &subscripts)
        {
            return Tensor<T, Ns...>::Single(forward<X>(value), subscripts);
        }
 
    public:
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) operator()(Is const... indices)
        {
            return (this->self())(indices...);
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) operator()(Is const... indices) const
        {
            return (this->self())(indices...);
        }
 
        constexpr decltype(auto) operator()(Subscripts const &subscripts)
        {
            return (this->self())(subscripts);
        }
 
        constexpr decltype(auto) operator()(Subscripts const &subscripts) const
        {
            return (this->self())(subscripts);
        }
 
        constexpr decltype(auto) operator[](Index const index)
            requires IsSubscriptable<F>
        {
            return (this->self())[index];
        }
 
        constexpr decltype(auto) operator[](Index const index) const
            requires IsSubscriptable<F>
        {
            return (this->self())[index];
        }
 
        explicit constexpr operator T()
            requires(Dimension == 0)
        {
            return operator()();
        }
 
        explicit constexpr operator T() const
            requires(Dimension == 0)
        {
            return operator()();
        }
 
        explicit constexpr operator Bool()
            requires IsSame<T, Bool> && (Dimension > 0)
        {
            return static_cast<Bool>(eval(*this));
        }
 
        explicit constexpr operator Bool() const
            requires IsSame<T, Bool> && (Dimension > 0)
        {
            return static_cast<Bool>(eval(*this));
        }
 
    protected:
        ~View() = default;
        constexpr View(View const &) = default;
        constexpr View(View &&) = default;
        constexpr View &operator=(View const &) = delete;
        constexpr View &operator=(View &&) = delete;
        constexpr View() = default;
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) call(Is const... indices)
        {
            return (*this)(Subscripts(indices...));
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) call(Is const... indices) const
        {
            return (*this)(Subscripts(indices...));
        }
 
        constexpr decltype(auto) call(Subscripts const &subscripts)
        {
            return expand(
                makeSeriesFor<Index, Ns...>(),
                [this](auto const &subscripts,
                    auto const... seq) -> decltype(auto)
                {
                    return (*this)(subscripts[seq]...);
                },
                subscripts);
        }
 
        constexpr decltype(auto) call(Subscripts const &subscripts) const
        {
            return expand(
                makeSeriesFor<Index, Ns...>(),
                [this](auto const &subscripts,
                    auto const... seq) -> decltype(auto)
                {
                    return (*this)(subscripts[seq]...);
                },
                subscripts);
        }
    };
}
#endif // pRC_CORE_TENSOR_VIEWS_VIEW_H