mirror of
https://github.com/love2d/megasource.git
synced 2026-08-20 04:30:45 +02:00
Update OpenAL-soft to 1.23.1-bc7cb17.
This commit is contained in:
Miku AuahDark
+335
-174
@@ -1,165 +1,250 @@
|
||||
#ifndef AL_SPAN_H
|
||||
#define AL_SPAN_H
|
||||
|
||||
#include <array>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <initializer_list>
|
||||
#include <iterator>
|
||||
#include <stdexcept>
|
||||
#include <tuple>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
#include "almalloc.h"
|
||||
#include "altraits.h"
|
||||
|
||||
namespace al {
|
||||
|
||||
/* This is here primarily to help ensure proper behavior for span's iterators,
|
||||
* being an actual object with member functions instead of a raw pointer (which
|
||||
* has requirements like + and - working with ptrdiff_t). This also helps
|
||||
* silence clang-tidy's pointer arithmetic warnings for span and FlexArray
|
||||
* iterators. It otherwise behaves like a plain pointer and should optimize
|
||||
* accordingly.
|
||||
*
|
||||
* Shouldn't be needed once we use std::span in C++20.
|
||||
*/
|
||||
template<typename T>
|
||||
constexpr auto size(const T &cont) noexcept(noexcept(cont.size())) -> decltype(cont.size())
|
||||
{ return cont.size(); }
|
||||
class ptr_wrapper {
|
||||
static_assert(std::is_pointer_v<T>);
|
||||
T mPointer{};
|
||||
|
||||
template<typename T, size_t N>
|
||||
constexpr size_t size(const T (&)[N]) noexcept
|
||||
{ return N; }
|
||||
public:
|
||||
using value_type = std::remove_pointer_t<T>;
|
||||
using size_type = std::size_t;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using pointer = value_type*;
|
||||
using reference = value_type&;
|
||||
using iterator_category = std::random_access_iterator_tag;
|
||||
|
||||
explicit constexpr ptr_wrapper(T ptr) : mPointer{ptr} { }
|
||||
|
||||
/* NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic) */
|
||||
constexpr auto operator++() noexcept -> ptr_wrapper& { ++mPointer; return *this; }
|
||||
constexpr auto operator--() noexcept -> ptr_wrapper& { --mPointer; return *this; }
|
||||
constexpr auto operator++(int) noexcept -> ptr_wrapper
|
||||
{
|
||||
auto temp = *this;
|
||||
++*this;
|
||||
return temp;
|
||||
}
|
||||
constexpr auto operator--(int) noexcept -> ptr_wrapper
|
||||
{
|
||||
auto temp = *this;
|
||||
--*this;
|
||||
return temp;
|
||||
}
|
||||
|
||||
constexpr
|
||||
auto operator+=(std::ptrdiff_t n) noexcept -> ptr_wrapper& { mPointer += n; return *this; }
|
||||
constexpr
|
||||
auto operator-=(std::ptrdiff_t n) noexcept -> ptr_wrapper& { mPointer -= n; return *this; }
|
||||
|
||||
[[nodiscard]] constexpr auto operator*() const noexcept -> value_type& { return *mPointer; }
|
||||
[[nodiscard]] constexpr auto operator->() const noexcept -> value_type* { return mPointer; }
|
||||
[[nodiscard]] constexpr
|
||||
auto operator[](std::size_t idx) const noexcept -> value_type& {return mPointer[idx];}
|
||||
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator+(const ptr_wrapper &lhs, std::ptrdiff_t n) noexcept -> ptr_wrapper
|
||||
{ return ptr_wrapper{lhs.mPointer + n}; }
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator+(std::ptrdiff_t n, const ptr_wrapper &rhs) noexcept -> ptr_wrapper
|
||||
{ return ptr_wrapper{n + rhs.mPointer}; }
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator-(const ptr_wrapper &lhs, std::ptrdiff_t n) noexcept -> ptr_wrapper
|
||||
{ return ptr_wrapper{lhs.mPointer - n}; }
|
||||
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator-(const ptr_wrapper &lhs, const ptr_wrapper &rhs)noexcept->std::ptrdiff_t
|
||||
{ return lhs.mPointer - rhs.mPointer; }
|
||||
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator==(const ptr_wrapper &lhs, const ptr_wrapper &rhs) noexcept -> bool
|
||||
{ return lhs.mPointer == rhs.mPointer; }
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator!=(const ptr_wrapper &lhs, const ptr_wrapper &rhs) noexcept -> bool
|
||||
{ return lhs.mPointer != rhs.mPointer; }
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator<=(const ptr_wrapper &lhs, const ptr_wrapper &rhs) noexcept -> bool
|
||||
{ return lhs.mPointer <= rhs.mPointer; }
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator>=(const ptr_wrapper &lhs, const ptr_wrapper &rhs) noexcept -> bool
|
||||
{ return lhs.mPointer >= rhs.mPointer; }
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator<(const ptr_wrapper &lhs, const ptr_wrapper &rhs) noexcept -> bool
|
||||
{ return lhs.mPointer < rhs.mPointer; }
|
||||
[[nodiscard]] friend constexpr
|
||||
auto operator>(const ptr_wrapper &lhs, const ptr_wrapper &rhs) noexcept -> bool
|
||||
{ return lhs.mPointer > rhs.mPointer; }
|
||||
/* NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic) */
|
||||
};
|
||||
|
||||
|
||||
template<typename T>
|
||||
constexpr auto data(T &cont) noexcept(noexcept(cont.data())) -> decltype(cont.data())
|
||||
{ return cont.data(); }
|
||||
inline constexpr std::size_t dynamic_extent{static_cast<std::size_t>(-1)};
|
||||
|
||||
template<typename T>
|
||||
constexpr auto data(const T &cont) noexcept(noexcept(cont.data())) -> decltype(cont.data())
|
||||
{ return cont.data(); }
|
||||
|
||||
template<typename T, size_t N>
|
||||
constexpr T* data(T (&arr)[N]) noexcept
|
||||
{ return arr; }
|
||||
|
||||
template<typename T>
|
||||
constexpr const T* data(std::initializer_list<T> list) noexcept
|
||||
{ return list.begin(); }
|
||||
|
||||
|
||||
constexpr size_t dynamic_extent{static_cast<size_t>(-1)};
|
||||
|
||||
template<typename T, size_t E=dynamic_extent>
|
||||
template<typename T, std::size_t E=dynamic_extent>
|
||||
class span;
|
||||
|
||||
namespace detail_ {
|
||||
template<typename... Ts>
|
||||
struct make_void { using type = void; };
|
||||
template<typename... Ts>
|
||||
using void_t = typename make_void<Ts...>::type;
|
||||
|
||||
template<typename T>
|
||||
struct is_span_ : std::false_type { };
|
||||
template<typename T, size_t E>
|
||||
template<typename T, std::size_t E>
|
||||
struct is_span_<span<T,E>> : std::true_type { };
|
||||
template<typename T>
|
||||
using is_span = is_span_<std::remove_cv_t<T>>;
|
||||
inline constexpr bool is_span_v = is_span_<std::remove_cv_t<T>>::value;
|
||||
|
||||
template<typename T>
|
||||
struct is_std_array_ : std::false_type { };
|
||||
template<typename T, size_t N>
|
||||
template<typename T, std::size_t N>
|
||||
struct is_std_array_<std::array<T,N>> : std::true_type { };
|
||||
template<typename T>
|
||||
using is_std_array = is_std_array_<std::remove_cv_t<T>>;
|
||||
inline constexpr bool is_std_array_v = is_std_array_<std::remove_cv_t<T>>::value;
|
||||
|
||||
template<typename T, typename = void>
|
||||
struct has_size_and_data : std::false_type { };
|
||||
inline constexpr bool has_size_and_data = false;
|
||||
template<typename T>
|
||||
struct has_size_and_data<T,
|
||||
void_t<decltype(al::size(std::declval<T>())), decltype(al::data(std::declval<T>()))>>
|
||||
: std::true_type { };
|
||||
inline constexpr bool has_size_and_data<T,
|
||||
std::void_t<decltype(std::size(std::declval<T>())),decltype(std::data(std::declval<T>()))>>
|
||||
= true;
|
||||
|
||||
template<typename C>
|
||||
inline constexpr bool is_valid_container_type = !is_span_v<C> && !is_std_array_v<C>
|
||||
&& !std::is_array<C>::value && has_size_and_data<C>;
|
||||
|
||||
template<typename T, typename U>
|
||||
inline constexpr bool is_array_compatible = std::is_convertible<T(*)[],U(*)[]>::value; /* NOLINT(*-avoid-c-arrays) */
|
||||
|
||||
template<typename C, typename T>
|
||||
inline constexpr bool is_valid_container = is_valid_container_type<C>
|
||||
&& is_array_compatible<std::remove_pointer_t<decltype(std::data(std::declval<C&>()))>,T>;
|
||||
} // namespace detail_
|
||||
|
||||
#define REQUIRES(...) bool rt_=true, std::enable_if_t<rt_ && (__VA_ARGS__),bool> = true
|
||||
#define IS_VALID_CONTAINER(C) \
|
||||
!detail_::is_span<C>::value && !detail_::is_std_array<C>::value && \
|
||||
!std::is_array<C>::value && detail_::has_size_and_data<C>::value && \
|
||||
std::is_convertible<std::remove_pointer_t<decltype(al::data(std::declval<C&>()))>(*)[],element_type(*)[]>::value
|
||||
#define REQUIRES(...) std::enable_if_t<(__VA_ARGS__),bool> = true
|
||||
|
||||
template<typename T, size_t E>
|
||||
template<typename T, std::size_t E>
|
||||
class span {
|
||||
public:
|
||||
using element_type = T;
|
||||
using value_type = std::remove_cv_t<T>;
|
||||
using index_type = size_t;
|
||||
using difference_type = ptrdiff_t;
|
||||
using size_type = std::size_t;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
|
||||
using pointer = T*;
|
||||
using const_pointer = const T*;
|
||||
using reference = T&;
|
||||
using const_reference = const T&;
|
||||
|
||||
using iterator = pointer;
|
||||
using const_iterator = const_pointer;
|
||||
using iterator = ptr_wrapper<pointer>;
|
||||
using const_iterator = ptr_wrapper<const_pointer>;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
|
||||
static constexpr size_t extent{E};
|
||||
static constexpr std::size_t extent{E};
|
||||
|
||||
template<REQUIRES(extent==0)>
|
||||
template<bool is0=(extent == 0), REQUIRES(is0)>
|
||||
constexpr span() noexcept { }
|
||||
constexpr span(pointer ptr, index_type /*count*/) : mData{ptr} { }
|
||||
constexpr span(pointer first, pointer /*last*/) : mData{first} { }
|
||||
constexpr span(element_type (&arr)[E]) noexcept : span{al::data(arr), al::size(arr)} { }
|
||||
constexpr span(std::array<value_type,E> &arr) noexcept : span{al::data(arr), al::size(arr)} { }
|
||||
template<REQUIRES(std::is_const<element_type>::value)>
|
||||
constexpr span(const std::array<value_type,E> &arr) noexcept
|
||||
: span{al::data(arr), al::size(arr)}
|
||||
{ }
|
||||
template<typename U, REQUIRES(IS_VALID_CONTAINER(U))>
|
||||
constexpr span(U &cont) : span{al::data(cont), al::size(cont)} { }
|
||||
template<typename U, REQUIRES(IS_VALID_CONTAINER(const U))>
|
||||
constexpr span(const U &cont) : span{al::data(cont), al::size(cont)} { }
|
||||
template<typename U, REQUIRES(!std::is_same<element_type,U>::value
|
||||
&& std::is_convertible<U(*)[],element_type(*)[]>::value)>
|
||||
constexpr span(const span<U,E> &span_) noexcept : span{al::data(span_), al::size(span_)} { }
|
||||
template<typename U>
|
||||
constexpr explicit span(U iter, size_type size_ [[maybe_unused]])
|
||||
: mData{::al::to_address(iter)}
|
||||
{ assert(size_ == extent); }
|
||||
template<typename U, typename V, REQUIRES(!std::is_convertible<V,std::size_t>::value)>
|
||||
constexpr explicit span(U first, V last [[maybe_unused]]) : mData{::al::to_address(first)}
|
||||
{ assert(static_cast<std::size_t>(last-first) == extent); }
|
||||
|
||||
template<std::size_t N>
|
||||
constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept /* NOLINT(*-avoid-c-arrays) */
|
||||
: mData{std::data(arr)}
|
||||
{ static_assert(N == extent); }
|
||||
template<std::size_t N>
|
||||
constexpr span(std::array<value_type,N> &arr) noexcept : mData{std::data(arr)}
|
||||
{ static_assert(N == extent); }
|
||||
template<typename U=T, std::size_t N, REQUIRES(std::is_const<U>::value)>
|
||||
constexpr span(const std::array<value_type,N> &arr) noexcept : mData{std::data(arr)}
|
||||
{ static_assert(N == extent); }
|
||||
|
||||
template<typename U, REQUIRES(detail_::is_valid_container<U, element_type>)>
|
||||
constexpr explicit span(U&& cont) : span{std::data(cont), std::size(cont)} { }
|
||||
|
||||
template<typename U, std::size_t N, REQUIRES(!std::is_same<element_type,U>::value
|
||||
&& detail_::is_array_compatible<U,element_type> && N == dynamic_extent)>
|
||||
constexpr explicit span(const span<U,N> &span_) noexcept : mData{std::data(span_)}
|
||||
{ assert(std::size(span_) == extent); }
|
||||
template<typename U, std::size_t N, REQUIRES(!std::is_same<element_type,U>::value
|
||||
&& detail_::is_array_compatible<U,element_type> && N == extent)>
|
||||
constexpr span(const span<U,N> &span_) noexcept : mData{std::data(span_)} { }
|
||||
constexpr span(const span&) noexcept = default;
|
||||
|
||||
constexpr span& operator=(const span &rhs) noexcept = default;
|
||||
|
||||
constexpr reference front() const { return *mData; }
|
||||
constexpr reference back() const { return *(mData+E-1); }
|
||||
constexpr reference operator[](index_type idx) const { return mData[idx]; }
|
||||
constexpr pointer data() const noexcept { return mData; }
|
||||
[[nodiscard]] constexpr auto front() const -> reference { return mData[0]; }
|
||||
[[nodiscard]] constexpr auto back() const -> reference { return mData[E-1]; }
|
||||
[[nodiscard]] constexpr auto operator[](size_type idx) const -> reference { return mData[idx]; }
|
||||
[[nodiscard]] constexpr auto data() const noexcept -> pointer { return mData; }
|
||||
|
||||
constexpr index_type size() const noexcept { return E; }
|
||||
constexpr index_type size_bytes() const noexcept { return E * sizeof(value_type); }
|
||||
constexpr bool empty() const noexcept { return E == 0; }
|
||||
[[nodiscard]] constexpr auto size() const noexcept -> size_type { return E; }
|
||||
[[nodiscard]] constexpr auto size_bytes() const noexcept -> size_type { return E * sizeof(value_type); }
|
||||
[[nodiscard]] constexpr auto empty() const noexcept -> bool { return E == 0; }
|
||||
|
||||
constexpr iterator begin() const noexcept { return mData; }
|
||||
constexpr iterator end() const noexcept { return mData+E; }
|
||||
constexpr const_iterator cbegin() const noexcept { return mData; }
|
||||
constexpr const_iterator cend() const noexcept { return mData+E; }
|
||||
[[nodiscard]] constexpr auto begin() const noexcept -> iterator { return iterator{mData}; }
|
||||
[[nodiscard]] constexpr auto end() const noexcept -> iterator { return iterator{mData+E}; }
|
||||
[[nodiscard]] constexpr
|
||||
auto cbegin() const noexcept -> const_iterator { return const_iterator{mData}; }
|
||||
[[nodiscard]] constexpr
|
||||
auto cend() const noexcept -> const_iterator { return const_iterator{mData+E}; }
|
||||
|
||||
constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
|
||||
constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }
|
||||
constexpr const_reverse_iterator crbegin() const noexcept
|
||||
{ return const_reverse_iterator{cend()}; }
|
||||
constexpr const_reverse_iterator crend() const noexcept
|
||||
{ return const_reverse_iterator{cbegin()}; }
|
||||
[[nodiscard]] constexpr auto rbegin() const noexcept -> reverse_iterator { return end(); }
|
||||
[[nodiscard]] constexpr auto rend() const noexcept -> reverse_iterator { return begin(); }
|
||||
[[nodiscard]] constexpr
|
||||
auto crbegin() const noexcept -> const_reverse_iterator { return cend(); }
|
||||
[[nodiscard]] constexpr
|
||||
auto crend() const noexcept -> const_reverse_iterator { return cbegin(); }
|
||||
|
||||
template<size_t C>
|
||||
constexpr span<element_type,C> first() const
|
||||
template<std::size_t C>
|
||||
[[nodiscard]] constexpr auto first() const -> span<element_type,C>
|
||||
{
|
||||
static_assert(E >= C, "New size exceeds original capacity");
|
||||
return span<element_type,C>{mData, C};
|
||||
}
|
||||
|
||||
template<size_t C>
|
||||
constexpr span<element_type,C> last() const
|
||||
template<std::size_t C>
|
||||
[[nodiscard]] constexpr auto last() const -> span<element_type,C>
|
||||
{
|
||||
static_assert(E >= C, "New size exceeds original capacity");
|
||||
return span<element_type,C>{mData+(E-C), C};
|
||||
}
|
||||
|
||||
template<size_t O, size_t C>
|
||||
constexpr auto subspan() const -> std::enable_if_t<C!=dynamic_extent,span<element_type,C>>
|
||||
template<std::size_t O, std::size_t C>
|
||||
[[nodiscard]] constexpr
|
||||
auto subspan() const -> std::enable_if_t<C!=dynamic_extent,span<element_type,C>>
|
||||
{
|
||||
static_assert(E >= O, "Offset exceeds extent");
|
||||
static_assert(E-O >= C, "New size exceeds original capacity");
|
||||
return span<element_type,C>{mData+O, C};
|
||||
}
|
||||
|
||||
template<size_t O, size_t C=dynamic_extent>
|
||||
constexpr auto subspan() const -> std::enable_if_t<C==dynamic_extent,span<element_type,E-O>>
|
||||
template<std::size_t O, std::size_t C=dynamic_extent>
|
||||
[[nodiscard]] constexpr
|
||||
auto subspan() const -> std::enable_if_t<C==dynamic_extent,span<element_type,E-O>>
|
||||
{
|
||||
static_assert(E >= O, "Offset exceeds extent");
|
||||
return span<element_type,E-O>{mData+O, E-O};
|
||||
@@ -169,10 +254,12 @@ public:
|
||||
* defining the specialization. As a result, these methods need to be
|
||||
* defined later.
|
||||
*/
|
||||
constexpr span<element_type,dynamic_extent> first(size_t count) const;
|
||||
constexpr span<element_type,dynamic_extent> last(size_t count) const;
|
||||
constexpr span<element_type,dynamic_extent> subspan(size_t offset,
|
||||
size_t count=dynamic_extent) const;
|
||||
[[nodiscard]] constexpr auto first(std::size_t count) const
|
||||
-> span<element_type,dynamic_extent>;
|
||||
[[nodiscard]] constexpr auto last(std::size_t count) const
|
||||
-> span<element_type,dynamic_extent>;
|
||||
[[nodiscard]] constexpr auto subspan(std::size_t offset,
|
||||
std::size_t count=dynamic_extent) const -> span<element_type,dynamic_extent>;
|
||||
|
||||
private:
|
||||
pointer mData{nullptr};
|
||||
@@ -183,7 +270,7 @@ class span<T,dynamic_extent> {
|
||||
public:
|
||||
using element_type = T;
|
||||
using value_type = std::remove_cv_t<T>;
|
||||
using index_type = size_t;
|
||||
using size_type = std::size_t;
|
||||
using difference_type = ptrdiff_t;
|
||||
|
||||
using pointer = T*;
|
||||
@@ -191,115 +278,189 @@ public:
|
||||
using reference = T&;
|
||||
using const_reference = const T&;
|
||||
|
||||
using iterator = pointer;
|
||||
using const_iterator = const_pointer;
|
||||
using iterator = ptr_wrapper<pointer>;
|
||||
using const_iterator = ptr_wrapper<const_pointer>;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
|
||||
static constexpr size_t extent{dynamic_extent};
|
||||
static constexpr std::size_t extent{dynamic_extent};
|
||||
|
||||
constexpr span() noexcept = default;
|
||||
constexpr span(pointer ptr, index_type count) : mData{ptr}, mDataEnd{ptr+count} { }
|
||||
constexpr span(pointer first, pointer last) : mData{first}, mDataEnd{last} { }
|
||||
template<size_t N>
|
||||
constexpr span(element_type (&arr)[N]) noexcept : span{al::data(arr), al::size(arr)} { }
|
||||
template<size_t N>
|
||||
constexpr span(std::array<value_type,N> &arr) noexcept : span{al::data(arr), al::size(arr)} { }
|
||||
template<size_t N, REQUIRES(std::is_const<element_type>::value)>
|
||||
constexpr span(const std::array<value_type,N> &arr) noexcept
|
||||
: span{al::data(arr), al::size(arr)}
|
||||
template<typename U>
|
||||
constexpr span(U iter, size_type count) : mData{::al::to_address(iter)}, mDataLength{count}
|
||||
{ }
|
||||
template<typename U, REQUIRES(IS_VALID_CONTAINER(U))>
|
||||
constexpr span(U &cont) : span{al::data(cont), al::size(cont)} { }
|
||||
template<typename U, REQUIRES(IS_VALID_CONTAINER(const U))>
|
||||
constexpr span(const U &cont) : span{al::data(cont), al::size(cont)} { }
|
||||
template<typename U, size_t N, REQUIRES((!std::is_same<element_type,U>::value || extent != N)
|
||||
&& std::is_convertible<U(*)[],element_type(*)[]>::value)>
|
||||
constexpr span(const span<U,N> &span_) noexcept : span{al::data(span_), al::size(span_)} { }
|
||||
template<typename U, typename V, REQUIRES(!std::is_convertible<V,std::size_t>::value)>
|
||||
constexpr span(U first, V last)
|
||||
: span{::al::to_address(first), static_cast<std::size_t>(last-first)}
|
||||
{ }
|
||||
|
||||
template<std::size_t N>
|
||||
constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept /* NOLINT(*-avoid-c-arrays) */
|
||||
: mData{std::data(arr)}, mDataLength{std::size(arr)}
|
||||
{ }
|
||||
template<std::size_t N>
|
||||
constexpr span(std::array<value_type,N> &arr) noexcept
|
||||
: mData{std::data(arr)}, mDataLength{std::size(arr)}
|
||||
{ }
|
||||
template<std::size_t N, typename U=T, REQUIRES(std::is_const<U>::value)>
|
||||
constexpr span(const std::array<value_type,N> &arr) noexcept
|
||||
: mData{std::data(arr)}, mDataLength{std::size(arr)}
|
||||
{ }
|
||||
|
||||
template<typename U, REQUIRES(detail_::is_valid_container<U, element_type>)>
|
||||
constexpr span(U&& cont) : span{std::data(cont), std::size(cont)} { }
|
||||
|
||||
template<typename U, std::size_t N, REQUIRES(detail_::is_array_compatible<U,element_type>
|
||||
&& (!std::is_same<element_type,U>::value || extent != N))>
|
||||
constexpr span(const span<U,N> &span_) noexcept : span{std::data(span_), std::size(span_)} { }
|
||||
constexpr span(const span&) noexcept = default;
|
||||
|
||||
constexpr span& operator=(const span &rhs) noexcept = default;
|
||||
|
||||
constexpr reference front() const { return *mData; }
|
||||
constexpr reference back() const { return *(mDataEnd-1); }
|
||||
constexpr reference operator[](index_type idx) const { return mData[idx]; }
|
||||
constexpr pointer data() const noexcept { return mData; }
|
||||
[[nodiscard]] constexpr auto front() const -> reference { return mData[0]; }
|
||||
[[nodiscard]] constexpr auto back() const -> reference { return mData[mDataLength-1]; }
|
||||
[[nodiscard]] constexpr auto operator[](size_type idx) const -> reference {return mData[idx];}
|
||||
[[nodiscard]] constexpr auto data() const noexcept -> pointer { return mData; }
|
||||
|
||||
constexpr index_type size() const noexcept { return static_cast<index_type>(mDataEnd-mData); }
|
||||
constexpr index_type size_bytes() const noexcept
|
||||
{ return static_cast<index_type>(mDataEnd-mData) * sizeof(value_type); }
|
||||
constexpr bool empty() const noexcept { return mData == mDataEnd; }
|
||||
[[nodiscard]] constexpr auto size() const noexcept -> size_type { return mDataLength; }
|
||||
[[nodiscard]] constexpr
|
||||
auto size_bytes() const noexcept -> size_type { return mDataLength * sizeof(value_type); }
|
||||
[[nodiscard]] constexpr auto empty() const noexcept -> bool { return mDataLength == 0; }
|
||||
|
||||
constexpr iterator begin() const noexcept { return mData; }
|
||||
constexpr iterator end() const noexcept { return mDataEnd; }
|
||||
constexpr const_iterator cbegin() const noexcept { return mData; }
|
||||
constexpr const_iterator cend() const noexcept { return mDataEnd; }
|
||||
[[nodiscard]] constexpr auto begin() const noexcept -> iterator { return iterator{mData}; }
|
||||
[[nodiscard]] constexpr
|
||||
auto end() const noexcept -> iterator { return iterator{mData+mDataLength}; }
|
||||
[[nodiscard]] constexpr
|
||||
auto cbegin() const noexcept -> const_iterator { return const_iterator{mData}; }
|
||||
[[nodiscard]] constexpr
|
||||
auto cend() const noexcept -> const_iterator { return const_iterator{mData+mDataLength}; }
|
||||
|
||||
constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
|
||||
constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }
|
||||
constexpr const_reverse_iterator crbegin() const noexcept
|
||||
{ return const_reverse_iterator{cend()}; }
|
||||
constexpr const_reverse_iterator crend() const noexcept
|
||||
{ return const_reverse_iterator{cbegin()}; }
|
||||
[[nodiscard]] constexpr auto rbegin() const noexcept -> reverse_iterator { return end(); }
|
||||
[[nodiscard]] constexpr auto rend() const noexcept -> reverse_iterator { return begin(); }
|
||||
[[nodiscard]] constexpr
|
||||
auto crbegin() const noexcept -> const_reverse_iterator { return cend(); }
|
||||
[[nodiscard]] constexpr
|
||||
auto crend() const noexcept -> const_reverse_iterator { return cbegin(); }
|
||||
|
||||
template<size_t C>
|
||||
constexpr span<element_type,C> first() const
|
||||
{ return span<element_type,C>{mData, C}; }
|
||||
|
||||
constexpr span first(size_t count) const
|
||||
{ return (count >= size()) ? *this : span{mData, mData+count}; }
|
||||
|
||||
template<size_t C>
|
||||
constexpr span<element_type,C> last() const
|
||||
{ return span<element_type,C>{mDataEnd-C, C}; }
|
||||
|
||||
constexpr span last(size_t count) const
|
||||
{ return (count >= size()) ? *this : span{mDataEnd-count, mDataEnd}; }
|
||||
|
||||
template<size_t O, size_t C>
|
||||
constexpr auto subspan() const -> std::enable_if_t<C!=dynamic_extent,span<element_type,C>>
|
||||
{ return span<element_type,C>{mData+O, C}; }
|
||||
|
||||
template<size_t O, size_t C=dynamic_extent>
|
||||
constexpr auto subspan() const -> std::enable_if_t<C==dynamic_extent,span<element_type,C>>
|
||||
{ return span<element_type,C>{mData+O, mDataEnd}; }
|
||||
|
||||
constexpr span subspan(size_t offset, size_t count=dynamic_extent) const
|
||||
template<std::size_t C>
|
||||
[[nodiscard]] constexpr auto first() const -> span<element_type,C>
|
||||
{
|
||||
return (offset > size()) ? span{} :
|
||||
(count >= size()-offset) ? span{mData+offset, mDataEnd} :
|
||||
span{mData+offset, mData+offset+count};
|
||||
if(C > mDataLength)
|
||||
throw std::out_of_range{"Subspan count out of range"};
|
||||
return span<element_type,C>{mData, C};
|
||||
}
|
||||
|
||||
[[nodiscard]] constexpr auto first(std::size_t count) const -> span
|
||||
{
|
||||
if(count > mDataLength)
|
||||
throw std::out_of_range{"Subspan count out of range"};
|
||||
return span{mData, count};
|
||||
}
|
||||
|
||||
template<std::size_t C>
|
||||
[[nodiscard]] constexpr auto last() const -> span<element_type,C>
|
||||
{
|
||||
if(C > mDataLength)
|
||||
throw std::out_of_range{"Subspan count out of range"};
|
||||
return span<element_type,C>{mData+mDataLength-C, C};
|
||||
}
|
||||
|
||||
[[nodiscard]] constexpr auto last(std::size_t count) const -> span
|
||||
{
|
||||
if(count > mDataLength)
|
||||
throw std::out_of_range{"Subspan count out of range"};
|
||||
return span{mData+mDataLength-count, count};
|
||||
}
|
||||
|
||||
template<std::size_t O, std::size_t C>
|
||||
[[nodiscard]] constexpr
|
||||
auto subspan() const -> std::enable_if_t<C!=dynamic_extent,span<element_type,C>>
|
||||
{
|
||||
if(O > mDataLength)
|
||||
throw std::out_of_range{"Subspan offset out of range"};
|
||||
if(C > mDataLength-O)
|
||||
throw std::out_of_range{"Subspan length out of range"};
|
||||
return span<element_type,C>{mData+O, C};
|
||||
}
|
||||
|
||||
template<std::size_t O, std::size_t C=dynamic_extent>
|
||||
[[nodiscard]] constexpr
|
||||
auto subspan() const -> std::enable_if_t<C==dynamic_extent,span<element_type,C>>
|
||||
{
|
||||
if(O > mDataLength)
|
||||
throw std::out_of_range{"Subspan offset out of range"};
|
||||
return span<element_type,C>{mData+O, mDataLength-O};
|
||||
}
|
||||
|
||||
[[nodiscard]] constexpr
|
||||
auto subspan(std::size_t offset, std::size_t count=dynamic_extent) const -> span
|
||||
{
|
||||
if(offset > mDataLength)
|
||||
throw std::out_of_range{"Subspan offset out of range"};
|
||||
if(count != dynamic_extent)
|
||||
{
|
||||
if(count > mDataLength-offset)
|
||||
throw std::out_of_range{"Subspan length out of range"};
|
||||
return span{mData+offset, count};
|
||||
}
|
||||
return span{mData+offset, mDataLength-offset};
|
||||
}
|
||||
|
||||
private:
|
||||
pointer mData{nullptr};
|
||||
pointer mDataEnd{nullptr};
|
||||
size_type mDataLength{0};
|
||||
};
|
||||
|
||||
template<typename T, size_t E>
|
||||
constexpr inline auto span<T,E>::first(size_t count) const -> span<element_type,dynamic_extent>
|
||||
template<typename T, std::size_t E>
|
||||
[[nodiscard]] constexpr
|
||||
auto span<T,E>::first(std::size_t count) const -> span<element_type,dynamic_extent>
|
||||
{
|
||||
return (count >= size()) ? span<element_type>{mData, extent} :
|
||||
span<element_type>{mData, count};
|
||||
if(count > size())
|
||||
throw std::out_of_range{"Subspan count out of range"};
|
||||
return span<element_type>{mData, count};
|
||||
}
|
||||
|
||||
template<typename T, size_t E>
|
||||
constexpr inline auto span<T,E>::last(size_t count) const -> span<element_type,dynamic_extent>
|
||||
template<typename T, std::size_t E>
|
||||
[[nodiscard]] constexpr
|
||||
auto span<T,E>::last(std::size_t count) const -> span<element_type,dynamic_extent>
|
||||
{
|
||||
return (count >= size()) ? span<element_type>{mData, extent} :
|
||||
span<element_type>{mData+extent-count, count};
|
||||
if(count > size())
|
||||
throw std::out_of_range{"Subspan count out of range"};
|
||||
return span<element_type>{mData+size()-count, count};
|
||||
}
|
||||
|
||||
template<typename T, size_t E>
|
||||
constexpr inline auto span<T,E>::subspan(size_t offset, size_t count) const
|
||||
template<typename T, std::size_t E>
|
||||
[[nodiscard]] constexpr
|
||||
auto span<T,E>::subspan(std::size_t offset, std::size_t count) const
|
||||
-> span<element_type,dynamic_extent>
|
||||
{
|
||||
return (offset > size()) ? span<element_type>{} :
|
||||
(count >= size()-offset) ? span<element_type>{mData+offset, mData+extent} :
|
||||
span<element_type>{mData+offset, mData+offset+count};
|
||||
if(offset > size())
|
||||
throw std::out_of_range{"Subspan offset out of range"};
|
||||
if(count != dynamic_extent)
|
||||
{
|
||||
if(count > size()-offset)
|
||||
throw std::out_of_range{"Subspan length out of range"};
|
||||
return span<element_type>{mData+offset, count};
|
||||
}
|
||||
return span<element_type>{mData+offset, size()-offset};
|
||||
}
|
||||
|
||||
#undef IS_VALID_CONTAINER
|
||||
|
||||
template<typename T, typename EndOrSize>
|
||||
span(T, EndOrSize) -> span<std::remove_reference_t<decltype(*std::declval<T&>())>>;
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
span(T (&)[N]) -> span<T, N>; /* NOLINT(*-avoid-c-arrays) */
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
span(std::array<T, N>&) -> span<T, N>;
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
span(const std::array<T, N>&) -> span<const T, N>;
|
||||
|
||||
template<typename C, REQUIRES(detail_::is_valid_container_type<C>)>
|
||||
span(C&&) -> span<std::remove_pointer_t<decltype(std::data(std::declval<C&>()))>>;
|
||||
|
||||
#undef REQUIRES
|
||||
|
||||
} // namespace al
|
||||
|
||||
Reference in New Issue
Block a user