10 typename Vec::value_type;
28template<
class T,
size_t N = std::dynamic_extent>
class Span :
public std::span<T, N> {
30 using Base = std::span<T, N>;
31 constexpr static auto D = std::dynamic_extent;
36 explicit(N !=
D)
constexpr Span(std::initializer_list<T> init) noexcept
37 :
Base(std::begin(init), std::ranges::distance(init)) {}
38 constexpr Span(std::span<T, N> span) noexcept
40 template<Vectorlike Vec>
requires(std::is_same_v<typename Vec::value_type, T>)
41 explicit(N !=
D)
constexpr Span(Vec& vec)
noexcept(
noexcept(vec.data()) &&
noexcept(vec.size()))
42 :
Base(vec.data(), vec.size()) {}
43 template<Vectorlike Vec>
requires(std::is_same_v<std::add_const_t<typename Vec::value_type>, std::add_const_t<T>>)
44 explicit(N !=
D)
constexpr Span(
const Vec& vec)
noexcept(
noexcept(vec.data()) &&
noexcept(vec.size()))
45 :
Base(
const_cast<T*
>(vec.data()), vec.size()) {}
46 constexpr explicit Span(
typename Base::pointer p) noexcept
48 static_assert(N !=
D);
58 [[nodiscard]]
constexpr Span<T, D> subspan(
size_t i,
size_t n =
D)
const noexcept {
return Base::subspan(i, n); }
60 template<
size_t i,
size_t n = D>
61 [[nodiscard]]
constexpr Span<T, n !=
D ? n : (N !=
D ? N - i :
D)>
subspan()
const noexcept {
70 return n !=
D ?
subspan(Base::size() - i - n, n) :
subspan(0, Base::size() - i);
74 template<
size_t i,
size_t n = D>
75 [[nodiscard]]
constexpr Span<T, n !=
D ? n : (N !=
D ? N - i :
D)>
rsubspan()
const noexcept {
77 return Span<T, n>(Base::data() + Base::size() - i - n);
78 else if constexpr (N !=
D)
81 return Span<T, D>(Base::data(), Base::size() - i);
86static_assert(std::ranges::contiguous_range<Span<int>>);
101template<
size_t I,
class T,
size_t N>
requires(N != std::dynamic_extent)
103 static_assert(I < N,
"index I out of bound N");
112template<
class T,
size_t N>
requires(N != std::dynamic_extent)
115template<
size_t I,
class T,
size_t N>
requires(N != std::dynamic_extent)
This is a thin wrapper for std::span<T, N> with the following additional features:
constexpr Span< T, D > subspan(size_t i, size_t n=D) const noexcept
constexpr Span(typename Base::pointer p) noexcept
constexpr Span< T, n !=D ? n :(N !=D ? N - i :D)> subspan() const noexcept
constexpr Span< T, D > rsubspan(size_t i, size_t n=D) const noexcept
constexpr Span(std::span< T, N > span) noexcept
constexpr Span< T, n !=D ? n :(N !=D ? N - i :D)> rsubspan() const noexcept
span.rsubspan(3, 5) removes the last 3 elements and picks 5 elements starting before those.
Something which behaves like std::vector or std::array.
Span(I, E) -> Span< std::remove_reference_t< std::iter_reference_t< I > > >
constexpr decltype(auto) get(Span< T, N > span) noexcept
typename mim::Span< T, N >::reference type