Array.h

/*
  ==============================================================================
    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
    Copyright 2022- by sonible GmbH.
 
    This file is part of VCTR - Versatile Container Templates Reconceptualized.
 
    VCTR is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License version 3
    only, as published by the Free Software Foundation.
 
    VCTR is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License version 3 for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    version 3 along with VCTR.  If not, see <https://www.gnu.org/licenses/>.
  ==============================================================================
*/
 
namespace vctr
{
 
namespace detail
{
 
template <class T, size_t e>
struct StorageExtent
{
    static constexpr size_t extent = e;
};
 
template <is::number T, size_t e>
struct StorageExtent<T, e>
{
    static constexpr size_t extent = nextMultipleOf<Config::maxSIMDRegisterSize / sizeof (T)> (e);
};
} // namespace detail
 
template <class ElementType, size_t extent, size_t storageExtent = detail::StorageExtent<ElementType, extent>::extent>
requires (extent != std::dynamic_extent && extent <= storageExtent)
class Array : public VctrBase<ElementType, std::array<ElementType, storageExtent>, extent>
{
protected:
    //==============================================================================
    using Vctr = VctrBase<ElementType, std::array<ElementType, storageExtent>, extent>;
    using StdArrayType = std::array<ElementType, storageExtent>;
 
public:
    //==============================================================================
    using value_type = typename Vctr::value_type;
 
    //==============================================================================
    // Constructors
    //==============================================================================
 
    constexpr Array()
    {
        if constexpr (std::copy_constructible <ElementType>)
        {
            if (std::is_constant_evaluated())
            {
                if constexpr (extent > 0)
                    Vctr::storage.fill (value_type());
            }
        }
    }
 
    constexpr Array (ElementType initialValue)
    requires (extent > 1)
    {
        Vctr::storage.fill (initialValue);
    }
 
    template <std::convertible_to<ElementType> T>
    constexpr Array (T&& initialValue)
    requires (extent == 1)
        : Vctr (StdArrayType { initialValue }) {}
 
    template <is::suitableInitializerForElementType<ElementType>... T>
    requires (sizeof...(T) > 1)
    constexpr Array (T&&... initialValues) : Vctr (StdArrayType { std::forward<T> (initialValues)... })
    {}
 
    template <class OtherElementType, size_t otherSize>
    constexpr Array (std::array<OtherElementType, otherSize>&& other) : Vctr (std::move (other)) {}
 
    template <is::triviallyCopyableWithDataAndSize OtherContainer>
    requires (std::same_as<value_type, ValueType<OtherContainer>> && ! std::same_as<Array, OtherContainer>)
    constexpr Array (const OtherContainer& other)
    {
        if (std::is_constant_evaluated())
        {
            for (size_t i = 0; i < extent; ++i)
                Vctr::storage[i] = other[i];
        }
        else
        {
            Vctr::copyFrom (other.data(), other.size());
        }
    }
 
    template <is::iteratorCopyable OtherContainer>
    constexpr Array (const OtherContainer& other) : Array (other.begin(), other.end()) {}
 
    constexpr Array (const ElementType* data, size_t size)
    {
        Vctr::copyFrom (data, size);
    }
 
    template <is::inputIteratorToConstructValuesOfType<ElementType> Iterator, std::sentinel_for<Iterator> Sentinel>
    constexpr Array (Iterator first, [[maybe_unused]] Sentinel last)
    {
        for (size_t i = 0; i < extent; ++i, ++first)
            Vctr::storage[i] = *first;
 
        if (! std::is_constant_evaluated())
        {
            // If you hit this assertion, the extent of the Array did not match the distance between first and last
            VCTR_ASSERT (first == last);
        }
    }
 
    template <is::suitableInitializerFunctionForElementType<ElementType> Fn>
    constexpr Array (Fn&& initializerFunction) : Array (std::forward<Fn> (initializerFunction), std::make_index_sequence<extent>()) {}
 
    template <is::expression Expression>
    constexpr Array (Expression&& e)
    {
        VCTR_ASSERT (e.size() == extent);
        Vctr::assignExpressionTemplate (std::forward<Expression> (e));
    }
 
    //==============================================================================
    // Operators
    //==============================================================================
    template <has::sizeAndDataWithElementType<ElementType> Container>
    constexpr Array& operator= (Container&& containerToCopyDataFrom)
    {
        if constexpr (Vctr::template shouldMoveFromOtherContainer<Container>)
        {
            VCTR_ASSERT (containerToCopyDataFrom.size() == Vctr::size());
            std::copy (std::make_move_iterator (containerToCopyDataFrom.begin()), std::make_move_iterator (containerToCopyDataFrom.end()), Vctr::storage.begin());
        }
        else
        {
            Vctr::copyFrom (containerToCopyDataFrom.data(), containerToCopyDataFrom.size());
        }
 
        return *this;
    }
 
    constexpr Array& operator= (std::initializer_list<ElementType> elementsToAssign)
    {
        Vctr::assign (std::move (elementsToAssign));
        return *this;
    }
 
    template <is::expression E>
    constexpr void operator= (const E& expression)
    {
        if (! std::is_constant_evaluated())
            VCTR_ASSERT (expression.size() == extent);
 
        Vctr::assignExpressionTemplate (expression);
    }
 
private:
    //==============================================================================
    template <is::suitableInitializerFunction Fn, size_t... i>
    constexpr Array (Fn&& initializerFunction, std::index_sequence<i...>) : Vctr (StdArrayType { initializerFunction (i)... }) {}
};
 
template <class OwnedElementType, size_t extent>
class OwnedArray : public Array<std::unique_ptr<OwnedElementType>, extent>
{
private:
    //==============================================================================
    using ArrayType = Array<std::unique_ptr<OwnedElementType>, extent>;
 
public:
    //==============================================================================
    OwnedArray() = default;
 
    template <is::pointer... Pointer>
    OwnedArray (Pointer... elementsToOwn) : OwnedArray (std::unique_ptr<OwnedElementType> (elementsToOwn)...) {}
 
    template <is::noPointer... Args>
    OwnedArray (Args&&... args) : ArrayType (std::forward<Args> (args)...) {}
};
 
//==============================================================================
// Deduction guides
//==============================================================================
 
template <class OtherElementType, size_t otherSize>
Array (std::array<OtherElementType, otherSize>&&) -> Array<OtherElementType, otherSize, otherSize>;
 
template <class First, is::suitableInitializerForElementType<std::remove_cvref_t<First>>... Other>
Array (First&&, Other&&...) -> Array<std::remove_cvref_t<First>, sizeof...(Other) + 1>;
 
namespace detail
{
 
// Clang failed to respect constrained single template types in deduction guides for some reasons.
// Using this as workaround for the single argument deduction guide below
template <class T>
struct SingleArgDeductionHelper
{
    using Type = std::remove_cvref_t<T>;
    static constexpr size_t extent = 1;
};
 
template <has::size T>
struct SingleArgDeductionHelper<T>
{
    using Type = vctr::ValueType<T>;
    static constexpr size_t extent = extentOf<T>;
};
 
} // namespace detail
 
template <class SingleArg>
Array (SingleArg&&) -> Array<typename detail::SingleArgDeductionHelper<SingleArg>::Type, detail::SingleArgDeductionHelper<SingleArg>::extent>;
 
template <class Pointer, std::same_as<Pointer>... Pointers>
OwnedArray (Pointer*, Pointers*...) -> OwnedArray<Pointer, sizeof...(Pointers) + 1>;
 
} // namespace vctr