Span.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
{
 
template <class ElementType, bool isDataSIMDAligned, bool isStorageSIMDExtended = false>
using SpanStorageInfo = StaticStorageInfo<isDataSIMDAligned, isStorageSIMDExtended, alignof (std::span<ElementType>)>;
 
template <class ElementType>
consteval auto simdAlignedSpanStorageInfo() { return SpanStorageInfo<ElementType, true>(); }
 
// clang-format off
 
template <class ElementType, size_t extent = std::dynamic_extent, class StorageInfoType = StorageInfoWithMemberAlignment<alignof (std::span<ElementType, extent>), StorageInfo<std::span<ElementType, extent> > > > // Extra whitespaces are needed for proper doxygen rendering
class Span : public VctrBase<ElementType, std::span<ElementType, extent>, extent, StorageInfoType>
{
// clang-format on
private:
    //==============================================================================
    using Vctr = VctrBase<ElementType, std::span<ElementType, extent>, extent, StorageInfoType>;
    using StdSpanType = std::span<ElementType, extent>;
 
public:
    //==============================================================================
    using value_type = typename Vctr::value_type;
 
    using element_type = ElementType;
 
    //==============================================================================
    // Constructors
    //==============================================================================
 
    constexpr Span (ElementType* ptr, size_t size)
        : Vctr (StdSpanType (ptr, size))
    {
        VCTR_ASSERT (extent == size || extent == std::dynamic_extent);
 
        if (Vctr::getStorageInfo().dataIsSIMDAligned)
        {
            // If you hit this assertion, you passed a StaticStorageInfo that specifies SIMD aligned
            // memory, but it is not aligned. Required alignment is 32 byte on x64 and 16 byte on ARM.
            VCTR_ASSERT (isPtrAligned (ptr));
        }
    }
 
    template <bool isDataSIMDAligned, bool isStorageSIMDExtended>
    constexpr Span (ElementType* ptr, size_t size, const StaticStorageInfo<isDataSIMDAligned, isStorageSIMDExtended, alignof (StdSpanType)>& info)
        : Vctr (StdSpanType (ptr, size), info)
    {
        VCTR_ASSERT (extent == size || extent == std::dynamic_extent);
 
        if constexpr (isDataSIMDAligned)
        {
            // If you hit this assertion, you passed a StaticStorageInfo that specifies SIMD aligned
            // memory, but it is not aligned. Required alignment is 32 byte on x64 and 16 byte on ARM.
            VCTR_ASSERT (isPtrAligned (ptr));
        }
    }
 
    template <has::sizeAndDataWithElementType<ElementType> Container>
    constexpr Span (Container&& containerToView)
        : Vctr (StdSpanType (containerToView.data(), containerToView.size()), makeStorageInfo (containerToView))
    {
        VCTR_ASSERT (extent == containerToView.size() || extent == std::dynamic_extent);
    }
 
    template <std::same_as<ElementType> T, size_t n>
    requires (n != std::dynamic_extent)
    constexpr Span (T (&cStyleArray)[n])
    requires (n == extent)
        : Vctr (StdSpanType (cStyleArray))
    {
        if (Vctr::getStorageInfo().dataIsSIMDAligned)
        {
            // If you hit this assertion, you passed a StaticStorageInfo that specifies SIMD aligned
            // memory, but it is not aligned. Required alignment is 32 byte on x64 and 16 byte on ARM.
            VCTR_ASSERT (isPtrAligned (cStyleArray));
        }
    }
 
    constexpr Span (ElementType* ptr)
    requires (extent != std::dynamic_extent)
        : Vctr (StdSpanType (ptr, extent))
    {
        if (Vctr::getStorageInfo().dataIsSIMDAligned)
        {
            // If you hit this assertion, you passed a StaticStorageInfo that specifies SIMD aligned
            // memory, but it is not aligned. Required alignment is 32 byte on x64 and 16 byte on ARM.
            VCTR_ASSERT (isPtrAligned (ptr));
        }
    }
 
    //==============================================================================
    // Operators
    //==============================================================================
    // Deleting the default copy operator forces the usage of the intended operator below
    Span& operator= (const Span&) = delete;
 
    template <has::sizeAndDataWithElementType<ElementType> Container>
    constexpr Span& 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 Span& operator= (std::initializer_list<ElementType> elementsToAssign)
    {
        Vctr::assign (std::move (elementsToAssign));
        return *this;
    }
 
    template <is::expression E>
    constexpr void operator= (const E& expression)
    {
        VCTR_ASSERT (expression.size() == Vctr::size());
 
        Vctr::assignExpressionTemplate (expression);
    }
 
    operator const StdSpanType&() { return Vctr::storage; }
 
    //==============================================================================
    template <class DstType>
    constexpr auto castTo()
    {
        using SizeRatio = std::ratio<sizeof (ElementType), sizeof (DstType)>;
        auto* dstData = reinterpret_cast<DstType*> (Vctr::data());
 
        if constexpr (extent == std::dynamic_extent)
        {
            auto dstSize = detail::expectNoRemainderMultiplyBy<SizeRatio> (Vctr::size());
            return Span<DstType> (dstData, dstSize);
        }
        else
        {
            constexpr auto dstSize = detail::expectNoRemainderMultiplyBy<SizeRatio> (Vctr::size());
            return Span<DstType, dstSize> (dstData, dstSize);
        }
    }
 
private:
    //==============================================================================
    template <has::sizeAndData Container>
    static constexpr auto makeStorageInfo (const Container& container)
    {
        constexpr size_t memberAlignment = alignof (StdSpanType);
 
        if constexpr (is::anyVctr<Container>)
        {
            const auto& info = container.getStorageInfo();
            return StorageInfoWithMemberAlignment<memberAlignment, std::remove_cvref_t<decltype (info)>> (info);
        }
        else
        {
            return StorageInfoWithMemberAlignment<memberAlignment, StorageInfo<Container>>().init (container.data(), container.size());
        }
    }
};
 
//==============================================================================
// Deduction guides
//==============================================================================
 
template <class ElementType, bool isDataSIMDAligned, bool isStorageSIMDExtended>
Span (ElementType*, size_t, const StaticStorageInfo<isDataSIMDAligned, isStorageSIMDExtended, alignof (std::span<ElementType>)>&) -> Span<ElementType, std::dynamic_extent, StaticStorageInfo<isDataSIMDAligned, isStorageSIMDExtended, alignof (std::span<ElementType>)>>;
 
template <class Container>
Span (Container&&) -> Span<DataType<Container>, extentOf<Container>, StorageInfoWithMemberAlignment<alignof (std::span<DataType<Container>, extentOf<Container>>), StorageInfoType<Container>>>;
 
template <class ElementType, size_t size>
Span (ElementType (&)[size]) -> Span<ElementType, size, StorageInfoWithMemberAlignment<alignof (std::span<ElementType, size>), StorageInfo<std::span<ElementType, size>>>>;
 
template <class ElementType>
auto makeSimdAlignedSpan (ElementType* data, size_t size)
{
    // If you hit this assertion, you passed a StaticStorageInfo that specifies SIMD aligned
    // memory, but it is not aligned. Required alignment is 32 byte on x64 and 16 byte on ARM.
    VCTR_ASSERT (isPtrAligned (data));
 
    return Span<ElementType, std::dynamic_extent, StaticStorageInfo<true, false, alignof (std::span<ElementType>)>> (data, size);
}
 
template <size_t extent, class ElementType>
requires (extent != std::dynamic_extent)
auto makeSimdAlignedSpan (ElementType* data)
{
    // If you hit this assertion, you passed a StaticStorageInfo that specifies SIMD aligned
    // memory, but it is not aligned. Required alignment is 32 byte on x64 and 16 byte on ARM.
    VCTR_ASSERT (isPtrAligned (data));
 
    return  Span<ElementType, extent, StaticStorageInfo<true, false, alignof (std::span<ElementType>)>> (data, extent);
}
 
} // namespace vctr