array.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_CONTAINER_ARRAY_H
#define pRC_CORE_CONTAINER_ARRAY_H
 
#include <prc/core/basic/range.hpp>
#include <prc/core/basic/sequence.hpp>
#include <prc/core/container/array_heap.hpp>
#include <prc/core/container/array_scalar.hpp>
#include <prc/core/container/array_stack.hpp>
#include <prc/core/container/declarations.hpp>
#include <prc/core/container/subscripts.hpp>
 
namespace pRC
{
    template<Allocation A, class T, Size N, Size... Ns>
        requires requires { Sizes<N, Ns...>::size(); }
    class CommonArray<A, T, N, Ns...>
    {
    public:
        static constexpr auto Allocation = A;
        using Type = T;
        using Sizes = pRC::Sizes<N, 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);
        }
 
        static constexpr auto indexToSubscripts(Index const index)
            requires IsConstructible<Subscripts<N, Ns...>, Index>
        {
            return Subscripts<N, Ns...>(index);
        }
 
        template<IsConvertible<Index>... Is>
            requires IsConstructible<Subscripts<N, Ns...>, Index> &&
            IsConstructible<Index, Subscripts<N, Ns...>> &&
            (sizeof...(Is) == Dimension)
        static constexpr auto subscriptsToIndex(Is const... subscripts)
        {
            return Index(Subscripts<N, Ns...>(subscripts...));
        }
 
        static constexpr auto subscriptsToIndex(
            Subscripts<N, Ns...> const &subscripts)
            requires IsConstructible<Index, Subscripts<N, Ns...>>
        {
            return Index(subscripts);
        }
 
    private:
        static consteval auto flattenable()
        {
            return (sizeof(StackArray<StackArray<T, N>, Ns...>) ==
                           sizeof(StackArray<T, size()>) ||
                       size() == 0) &&
                IsStandardLayout<CommonArray<A, StackArray<T, N>, Ns...>> &&
                IsStandardLayout<StackArray<T, size()>> &&
                offsetof(CommonArray, mData) == 0;
        }
 
    public:
        ~CommonArray() = default;
        constexpr CommonArray() = default;
 
        constexpr CommonArray(CommonArray const &other)
        {
            *this = other;
        }
 
        constexpr CommonArray(StackArray<T, N, Ns...> &&other)
            requires(Allocation == pRC::Allocation::Stack)
        {
            operator= <Allocation, T>(other);
        }
 
        constexpr CommonArray(HeapArray<T, N, Ns...> &&other)
            requires(Allocation == pRC::Allocation::Heap)
            : mData(move(other.mData))
        {
        }
 
        template<pRC::Allocation B, IsConvertible<T> R>
        constexpr CommonArray(CommonArray<B, R, N, Ns...> const &other)
        {
            *this = other;
        }
 
        constexpr CommonArray &operator=(CommonArray const &rhs) &
        {
            return operator= <A, T>(rhs);
        }
 
        constexpr CommonArray &operator=(CommonArray &&rhs) &
            requires(Allocation == pRC::Allocation::Stack) {
                range<size()>(
                    [this, &rhs](auto const i)
                    {
                        (*this)[i] = move(rhs[i]);
                    });
                return *this;
            }
 
            constexpr CommonArray &
            operator=(CommonArray &&rhs) &
            requires(Allocation == pRC::Allocation::Heap) {
                mData = move(rhs.mData);
                return *this;
            }
 
            template<pRC::Allocation B, IsConvertible<T> R>
            constexpr auto &operator=(CommonArray<B, R, N, Ns...> const &rhs) &
        {
            range<size()>(
                [this, &rhs](auto const i)
                {
                    (*this)[i] = rhs[i];
                });
            return *this;
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == sizeof...(Ns))
        constexpr decltype(auto) operator()(Index const subscript,
            Is const... subscripts) &&
        {
            return move(mData)(subscripts...)[subscript];
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == sizeof...(Ns))
        constexpr decltype(auto) operator()(Index const subscript,
            Is const... subscripts) const &&
        {
            return move(mData)(subscripts...)[subscript];
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == sizeof...(Ns))
        constexpr decltype(auto) operator()(Index const subscript,
            Is const... subscripts) &
        {
            return mData(subscripts...)[subscript];
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == sizeof...(Ns))
        constexpr decltype(auto) operator()(Index const subscript,
            Is const... subscripts) const &
        {
            return mData(subscripts...)[subscript];
        }
 
        constexpr decltype(auto) operator()(
            Subscripts<N, Ns...> const &subscripts) &&
        {
            return expand(
                makeSeries<Index, Dimension>(),
                [this](auto const &subscripts,
                    auto const... seq) -> decltype(auto)
                {
                    return move(*this)(subscripts[seq]...);
                },
                subscripts);
        }
 
        constexpr decltype(auto) operator()(
            Subscripts<N, Ns...> const &subscripts) const &&
        {
            return expand(
                makeSeries<Index, Dimension>(),
                [this](auto const &subscripts,
                    auto const... seq) -> decltype(auto)
                {
                    return move(*this)(subscripts[seq]...);
                },
                subscripts);
        }
 
        constexpr decltype(auto) operator()(
            Subscripts<N, Ns...> const &subscripts) &
        {
            return expand(
                makeSeries<Index, Dimension>(),
                [this](auto const &subscripts,
                    auto const... seq) -> decltype(auto)
                {
                    return this->operator()(subscripts[seq]...);
                },
                subscripts);
        }
 
        constexpr decltype(auto) operator()(
            Subscripts<N, Ns...> const &subscripts) const &
        {
            return expand(
                makeSeries<Index, Dimension>(),
                [this](auto const &subscripts,
                    auto const... seq) -> decltype(auto)
                {
                    return this->operator()(subscripts[seq]...);
                },
                subscripts);
        }
 
        constexpr decltype(auto) operator[](Index const index) &&
            requires(flattenable())
        {
            return move(
                *reinterpret_cast<StackArray<T, size()> *>(data()))[index];
        }
 
        constexpr decltype(auto) operator[](Index const index) const &&
            requires(flattenable())
        {
            return move(*reinterpret_cast<StackArray<T, size()> const *>(
                data()))[index];
        }
 
        constexpr decltype(auto) operator[](Index const index) &
            requires(flattenable())
        {
            return (*reinterpret_cast<StackArray<T, size()> *>(data()))[index];
        }
 
        constexpr decltype(auto) operator[](Index const index) const &
            requires(flattenable())
        {
            return (*reinterpret_cast<StackArray<T, size()> const *>(
                data()))[index];
        }
 
        constexpr auto data() && = delete;
        constexpr auto data() const && = delete;
 
        constexpr auto data() &
        {
            return mData.data();
        }
 
        constexpr auto data() const &
        {
            return mData.data();
        }
 
    private:
        BEGIN_IGNORE_DIAGNOSTIC_GCC("-Wpedantic")
        CommonArray<A, StackArray<T, N>, Ns...> mData;
        END_IGNORE_DIAGNOSTIC_GCC
    };
 
    template<class T>
    concept IsArray = !IsReference<T> && requires {
        {
            []<Allocation A, class U, Size... Ns>(
                CommonArray<A, U, Ns...> const &&)
            {
            }(std::declval<T>())
        };
    };
}
#endif // pRC_CORE_CONTAINER_ARRAY_H