Implement std::span for C++20
2019-09-05 JeanHeyd Meneide <phdofthehouse@gmail.com> * include/Makefile.am: Add <span> header. * include/Makefile.in: Regenerate. * include/bits/range_access.h (__adl_begin, __adl_end, __adl_cbegin) (__adl_cend, __adl_rbegin, __adl_rend, __adl_crbegin, __adl_crend) (__adl_data, __adl_cdata, __adl_size, __adl_empty, __adl_to_address): New functions for performing argument-dependent lookup of range customization points. * include/bits/stl_iterator.h (__normal_iterator): Add _GLIBCXX20_CONSTEXPR to all functions. * include/std/span: New header. * include/std/version (__cpp_lib_span): Define feature test macro. * testsuite/23_containers/span/contiguous_range_neg.cc: New test. * testsuite/23_containers/span/everything.cc: New test. * testsuite/23_containers/span/get_neg.cc: New test. * testsuite/23_containers/span/last_neg.cc: New test. * testsuite/23_containers/span/subspan_neg.cc: New test. * testsuite/23_containers/span/tuple_element_dynamic_neg.cc: New test. * testsuite/23_containers/span/tuple_element_oob_neg.cc: New test. * testsuite/23_containers/span/tuple_size_neg.cc: New test. From-SVN: r275403
This commit is contained in:
JeanHeyd Meneide
Jonathan Wakely
parent
056f95ec95
commit
95e9a7616d
|
|
@ -1,3 +1,25 @@
|
|||
2019-09-05 JeanHeyd Meneide <phdofthehouse@gmail.com>
|
||||
|
||||
* include/Makefile.am: Add <span> header.
|
||||
* include/Makefile.in: Regenerate.
|
||||
* include/bits/range_access.h (__adl_begin, __adl_end, __adl_cbegin)
|
||||
(__adl_cend, __adl_rbegin, __adl_rend, __adl_crbegin, __adl_crend)
|
||||
(__adl_data, __adl_cdata, __adl_size, __adl_empty, __adl_to_address):
|
||||
New functions for performing argument-dependent lookup of range
|
||||
customization points.
|
||||
* include/bits/stl_iterator.h (__normal_iterator): Add
|
||||
_GLIBCXX20_CONSTEXPR to all functions.
|
||||
* include/std/span: New header.
|
||||
* include/std/version (__cpp_lib_span): Define feature test macro.
|
||||
* testsuite/23_containers/span/contiguous_range_neg.cc: New test.
|
||||
* testsuite/23_containers/span/everything.cc: New test.
|
||||
* testsuite/23_containers/span/get_neg.cc: New test.
|
||||
* testsuite/23_containers/span/last_neg.cc: New test.
|
||||
* testsuite/23_containers/span/subspan_neg.cc: New test.
|
||||
* testsuite/23_containers/span/tuple_element_dynamic_neg.cc: New test.
|
||||
* testsuite/23_containers/span/tuple_element_oob_neg.cc: New test.
|
||||
* testsuite/23_containers/span/tuple_size_neg.cc: New test.
|
||||
|
||||
2019-09-05 Jonathan Wakely <jwakely@redhat.com>
|
||||
|
||||
* doc/xml/manual/allocator.xml: Remove URL for bibliography entry.
|
||||
|
|
|
|||
|
|
@ -68,6 +68,7 @@ std_headers = \
|
|||
${std_srcdir}/scoped_allocator \
|
||||
${std_srcdir}/set \
|
||||
${std_srcdir}/shared_mutex \
|
||||
${std_srcdir}/span \
|
||||
${std_srcdir}/sstream \
|
||||
${std_srcdir}/stack \
|
||||
${std_srcdir}/stdexcept \
|
||||
|
|
|
|||
|
|
@ -412,6 +412,7 @@ std_headers = \
|
|||
${std_srcdir}/scoped_allocator \
|
||||
${std_srcdir}/set \
|
||||
${std_srcdir}/shared_mutex \
|
||||
${std_srcdir}/span \
|
||||
${std_srcdir}/sstream \
|
||||
${std_srcdir}/stack \
|
||||
${std_srcdir}/stdexcept \
|
||||
|
|
|
|||
|
|
@ -318,6 +318,78 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
|
||||
#endif // C++17
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
// "why are these in namespace std:: and not __gnu_cxx:: ?"
|
||||
// because if we don't put them here it's impossible to
|
||||
// have implicit ADL with "using std::begin/end/size/data;".
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_begin(_Container& __cont) noexcept(noexcept(begin(__cont)))
|
||||
{ return begin(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_end(_Container& __cont) noexcept(noexcept(end(__cont)))
|
||||
{ return end(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_cbegin(_Container& __cont) noexcept(noexcept(cbegin(__cont)))
|
||||
{ return cbegin(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_cend(_Container& __cont) noexcept(noexcept(cend(__cont)))
|
||||
{ return cend(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_rbegin(_Container& __cont) noexcept(noexcept(rbegin(__cont)))
|
||||
{ return rbegin(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_rend(_Container& __cont) noexcept(noexcept(rend(__cont)))
|
||||
{ return rend(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_crbegin(_Container& __cont) noexcept(noexcept(crbegin(__cont)))
|
||||
{ return crbegin(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_crend(_Container& __cont) noexcept(noexcept(crend(__cont)))
|
||||
{ return crend(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_data(_Container& __cont) noexcept(noexcept(data(__cont)))
|
||||
{ return data(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_cdata(_Container& __cont) noexcept(noexcept(cdata(__cont)))
|
||||
{ return cdata(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_size(_Container& __cont) noexcept(noexcept(size(__cont)))
|
||||
{ return size(__cont); }
|
||||
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_empty(_Container& __cont) noexcept(noexcept(empty(__cont)))
|
||||
{ return empty(__cont); }
|
||||
|
||||
#if defined(_GLIBCXX_P1394) && _GLIBCXX_P1394
|
||||
template <typename _Container>
|
||||
constexpr auto
|
||||
__adl_to_address(_Container& __cont) noexcept(noexcept(to_address(__cont)))
|
||||
{ return to_address(__cont); }
|
||||
#endif // P1394 and new contiguous_iterator requirements [iterator.concept.contiguous]
|
||||
#endif // C++20
|
||||
|
||||
_GLIBCXX_END_NAMESPACE_VERSION
|
||||
} // namespace
|
||||
|
||||
|
|
|
|||
|
|
@ -446,7 +446,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
|
||||
#if __cplusplus >= 201103L
|
||||
template<typename _Iterator>
|
||||
_GLIBCXX20_CONSTEXPR auto
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
auto
|
||||
__niter_base(reverse_iterator<_Iterator> __it)
|
||||
-> decltype(__make_reverse_iterator(__niter_base(__it.base())))
|
||||
{ return __make_reverse_iterator(__niter_base(__it.base())); }
|
||||
|
|
@ -457,7 +458,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ };
|
||||
|
||||
template<typename _Iterator>
|
||||
_GLIBCXX20_CONSTEXPR auto
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
auto
|
||||
__miter_base(reverse_iterator<_Iterator> __it)
|
||||
-> decltype(__make_reverse_iterator(__miter_base(__it.base())))
|
||||
{ return __make_reverse_iterator(__miter_base(__it.base())); }
|
||||
|
|
@ -802,12 +804,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
_GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
|
||||
: _M_current(_Iterator()) { }
|
||||
|
||||
explicit
|
||||
explicit _GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
|
||||
: _M_current(__i) { }
|
||||
|
||||
// Allow iterator to const_iterator conversion
|
||||
template<typename _Iter>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator(const __normal_iterator<_Iter,
|
||||
typename __enable_if<
|
||||
(std::__are_same<_Iter, typename _Container::pointer>::__value),
|
||||
|
|
@ -815,14 +818,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
: _M_current(__i.base()) { }
|
||||
|
||||
// Forward iterator requirements
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
reference
|
||||
operator*() const _GLIBCXX_NOEXCEPT
|
||||
{ return *_M_current; }
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
pointer
|
||||
operator->() const _GLIBCXX_NOEXCEPT
|
||||
{ return _M_current; }
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator&
|
||||
operator++() _GLIBCXX_NOEXCEPT
|
||||
{
|
||||
|
|
@ -830,11 +836,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
return *this;
|
||||
}
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator
|
||||
operator++(int) _GLIBCXX_NOEXCEPT
|
||||
{ return __normal_iterator(_M_current++); }
|
||||
|
||||
// Bidirectional iterator requirements
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator&
|
||||
operator--() _GLIBCXX_NOEXCEPT
|
||||
{
|
||||
|
|
@ -842,31 +850,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
return *this;
|
||||
}
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator
|
||||
operator--(int) _GLIBCXX_NOEXCEPT
|
||||
{ return __normal_iterator(_M_current--); }
|
||||
|
||||
// Random access iterator requirements
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
reference
|
||||
operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
|
||||
{ return _M_current[__n]; }
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator&
|
||||
operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
|
||||
{ _M_current += __n; return *this; }
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator
|
||||
operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
|
||||
{ return __normal_iterator(_M_current + __n); }
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator&
|
||||
operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
|
||||
{ _M_current -= __n; return *this; }
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
__normal_iterator
|
||||
operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
|
||||
{ return __normal_iterator(_M_current - __n); }
|
||||
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
const _Iterator&
|
||||
base() const _GLIBCXX_NOEXCEPT
|
||||
{ return _M_current; }
|
||||
|
|
@ -882,6 +897,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
|
||||
// Forward iterator requirements
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
|
|
@ -889,6 +905,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() == __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
|
|
@ -896,6 +913,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() == __rhs.base(); }
|
||||
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
|
|
@ -903,6 +921,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() != __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
|
|
@ -911,6 +930,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
|
||||
// Random access iterator requirements
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
|
|
@ -918,6 +938,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() < __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
|
|
@ -925,6 +946,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() < __rhs.base(); }
|
||||
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
|
|
@ -932,6 +954,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() > __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
|
|
@ -939,6 +962,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() > __rhs.base(); }
|
||||
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
|
|
@ -946,6 +970,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() <= __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
|
|
@ -953,6 +978,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() <= __rhs.base(); }
|
||||
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
|
|
@ -960,6 +986,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() >= __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline bool
|
||||
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
|
|
@ -973,6 +1000,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
#if __cplusplus >= 201103L
|
||||
// DR 685.
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline auto
|
||||
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
|
||||
|
|
@ -985,6 +1013,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() - __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline typename __normal_iterator<_Iterator, _Container>::difference_type
|
||||
operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
|
|
@ -992,6 +1021,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
{ return __lhs.base() - __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
inline __normal_iterator<_Iterator, _Container>
|
||||
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
|
||||
__n, const __normal_iterator<_Iterator, _Container>& __i)
|
||||
|
|
@ -1006,6 +1036,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
|
|||
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
_Iterator
|
||||
__niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
|
||||
_GLIBCXX_NOEXCEPT_IF(std::is_nothrow_copy_constructible<_Iterator>::value)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,521 @@
|
|||
// Components for manipulating non-owning sequences of objects -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// Under Section 7 of GPL version 3, you are granted additional
|
||||
// permissions described in the GCC Runtime Library Exception, version
|
||||
// 3.1, as published by the Free Software Foundation.
|
||||
|
||||
// You should have received a copy of the GNU General Public License and
|
||||
// a copy of the GCC Runtime Library Exception along with this program;
|
||||
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
/** @file span
|
||||
* This is a Standard C++ Library header.
|
||||
*/
|
||||
|
||||
//
|
||||
// P0122 span library
|
||||
// Contributed by ThePhD
|
||||
//
|
||||
|
||||
#ifndef _GLIBCXX_SPAN
|
||||
#define _GLIBCXX_SPAN 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
|
||||
#include <type_traits>
|
||||
#include <tuple>
|
||||
#include <utility>
|
||||
#include <array>
|
||||
#include <bits/stl_iterator.h>
|
||||
#include <bits/range_access.h>
|
||||
|
||||
namespace std _GLIBCXX_VISIBILITY(default)
|
||||
{
|
||||
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
|
||||
// FIXME: they forgot this feature test macro
|
||||
// get on someone's back about it in Belfast!!!
|
||||
#define __cpp_lib_span 201911
|
||||
|
||||
inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
|
||||
|
||||
namespace __detail
|
||||
{
|
||||
template<typename _Element, typename _ToElement>
|
||||
static constexpr inline bool __is_base_derived_safe_convertible_v
|
||||
= is_convertible_v<_Element (*)[], _ToElement (*)[]>;
|
||||
|
||||
template<typename _Tp>
|
||||
inline constexpr bool __is_std_array_v = false;
|
||||
|
||||
template<typename _Tp, size_t _Num>
|
||||
inline constexpr bool
|
||||
__is_std_array_v<_GLIBCXX_STD_C::array<_Tp, _Num>> = true;
|
||||
|
||||
#ifdef _GLIBCXX_DEBUG
|
||||
template<typename _Tp, size_t _Num>
|
||||
inline constexpr bool
|
||||
__is_std_array_v<std::__debug::array<_Tp, _Num>> = true;
|
||||
#endif // debug/array
|
||||
|
||||
template<size_t _Extent>
|
||||
class __extent_storage
|
||||
{
|
||||
public:
|
||||
constexpr
|
||||
__extent_storage() noexcept = default;
|
||||
|
||||
constexpr
|
||||
__extent_storage(size_t) noexcept
|
||||
{ }
|
||||
|
||||
static constexpr size_t
|
||||
_M_extent() noexcept
|
||||
{ return _Extent; }
|
||||
};
|
||||
|
||||
template<>
|
||||
class __extent_storage<static_cast<size_t>(-1)>
|
||||
{
|
||||
public:
|
||||
constexpr
|
||||
__extent_storage() noexcept : _M_extent_value(0)
|
||||
{ };
|
||||
|
||||
constexpr
|
||||
__extent_storage(size_t __extent) noexcept
|
||||
: _M_extent_value(__extent)
|
||||
{ }
|
||||
|
||||
constexpr size_t
|
||||
_M_extent() const noexcept
|
||||
{ return this->_M_extent_value; }
|
||||
|
||||
private:
|
||||
size_t _M_extent_value;
|
||||
};
|
||||
|
||||
} // namespace __detail
|
||||
|
||||
template<typename _Type, size_t _Extent = dynamic_extent>
|
||||
class span : private __detail::__extent_storage<_Extent>
|
||||
{
|
||||
public:
|
||||
// member types
|
||||
using value_type = remove_cv_t<_Type>;
|
||||
using element_type = _Type;
|
||||
using index_type = size_t;
|
||||
using reference = element_type&;
|
||||
using const_reference = const element_type&;
|
||||
using pointer = _Type*;
|
||||
using const_pointer = const _Type*;
|
||||
using iterator
|
||||
= __gnu_cxx::__normal_iterator<pointer, span>;
|
||||
using const_iterator
|
||||
= __gnu_cxx::__normal_iterator<const_pointer, span>;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
using difference_type = ptrdiff_t;
|
||||
// Official wording has no size_type -- why??
|
||||
// using size_type = size_t;
|
||||
|
||||
// member constants
|
||||
static inline constexpr size_t extent = _Extent;
|
||||
|
||||
private:
|
||||
using __base_t = __detail::__extent_storage<extent>;
|
||||
|
||||
public:
|
||||
// constructors
|
||||
|
||||
template <typename _Dummy = _Type,
|
||||
enable_if_t<is_same_v<_Dummy, _Type>
|
||||
&& (_Extent == dynamic_extent || _Extent == 0)>* = nullptr>
|
||||
constexpr
|
||||
span() noexcept : __base_t(0), _M_ptr(nullptr)
|
||||
{ }
|
||||
|
||||
constexpr
|
||||
span(const span&) noexcept = default;
|
||||
|
||||
template<size_t _ArrayExtent,
|
||||
enable_if_t<
|
||||
(_Extent == dynamic_extent || _ArrayExtent == _Extent)
|
||||
&& __detail::__is_base_derived_safe_convertible_v<
|
||||
remove_pointer_t<decltype(::std::__adl_data(
|
||||
::std::declval<element_type (&)[_ArrayExtent]>()))>,
|
||||
element_type>>* = nullptr>
|
||||
constexpr span(element_type (&__arr)[_ArrayExtent])
|
||||
noexcept(noexcept(::std::__adl_data(__arr)))
|
||||
: span(::std::__adl_data(__arr), _ArrayExtent)
|
||||
{ }
|
||||
|
||||
template<size_t _ArrayExtent,
|
||||
enable_if_t<
|
||||
(_Extent == dynamic_extent || _ArrayExtent == _Extent)
|
||||
&& __detail::__is_base_derived_safe_convertible_v<
|
||||
remove_pointer_t<decltype(::std::__adl_data(
|
||||
::std::declval<const array<value_type, _ArrayExtent>&>()))>,
|
||||
element_type>>* = nullptr>
|
||||
constexpr
|
||||
span(array<value_type, _ArrayExtent>& __arr)
|
||||
noexcept(noexcept(::std::__adl_data(__arr)))
|
||||
: span(::std::__adl_data(__arr), _ArrayExtent)
|
||||
{ }
|
||||
|
||||
template<size_t _ArrayExtent,
|
||||
enable_if_t<
|
||||
(_Extent == dynamic_extent || _ArrayExtent == _Extent)
|
||||
&& __detail::__is_base_derived_safe_convertible_v<
|
||||
remove_pointer_t<decltype(::std::__adl_data(
|
||||
::std::declval<const array<value_type, _ArrayExtent>&>()))>,
|
||||
element_type>>* = nullptr>
|
||||
constexpr
|
||||
span(const array<value_type, _ArrayExtent>& __arr)
|
||||
noexcept(noexcept(::std::__adl_data(__arr)))
|
||||
: span(::std::__adl_data(__arr), _ArrayExtent)
|
||||
{ }
|
||||
|
||||
// NOTE: when the time comes, and P1394 -
|
||||
// range constructors for std::span - ships in
|
||||
// the standard, delete the #else block and remove
|
||||
// the conditional
|
||||
// if the paper fails, delete #if block
|
||||
// and keep the crappy #else block
|
||||
// and then cry that NB comments failed C++20...
|
||||
// but maybe for C++23?
|
||||
#if defined(_GLIBCXX_P1394) && _GLIBCXX_P1394
|
||||
template<typename _Range,
|
||||
enable_if_t<
|
||||
(_Extent == dynamic_extent)
|
||||
&& !is_same_v<remove_cvref_t<_Range>, span>
|
||||
&& !__detail::__is_std_array_v<remove_cvref_t<_Range>>
|
||||
&& !is_array_v<remove_cvref_t<_Range>>
|
||||
&& __detail::__is_base_derived_safe_convertible_v<
|
||||
remove_pointer_t<decltype(
|
||||
::std::__adl_data(::std::declval<_Range&>())
|
||||
+ ::std::__adl_size(::std::declval<_Range&>()))>,
|
||||
element_type>>* = nullptr>
|
||||
constexpr
|
||||
span(_Range&& __range)
|
||||
noexcept(noexcept(::std::__adl_data(__range))
|
||||
&& noexcept(::std::__adl_size(__range)))
|
||||
: span(::std::__adl_data(__range), ::std::__adl_size(__range))
|
||||
{ }
|
||||
|
||||
template<typename _ContiguousIterator, typename _Sentinel,
|
||||
enable_if_t<!is_convertible_v<_Sentinel, index_type>
|
||||
&& __detail::__is_base_derived_safe_convertible_v<
|
||||
remove_reference_t<typename
|
||||
iterator_traits<_ContiguousIterator>::reference>,
|
||||
element_type>>* = nullptr>
|
||||
constexpr
|
||||
span(_ContiguousIterator __first, _Sentinel __last)
|
||||
: span(::std::move(__first), static_cast<index_type>(__last - __first))
|
||||
{ }
|
||||
|
||||
template<typename _ContiguousIterator>
|
||||
constexpr
|
||||
span(_ContiguousIterator __first, index_type __count)
|
||||
noexcept(noexcept(::std::__adl_to_address(__first)))
|
||||
: __base_t(__count), _M_ptr(::std::__adl_to_address(__first))
|
||||
{ __glibcxx_assert(_Extent == dynamic_extent || __count == _Extent); }
|
||||
|
||||
#else
|
||||
|
||||
template<typename _Container,
|
||||
enable_if_t<
|
||||
(_Extent == dynamic_extent)
|
||||
&& !is_same_v<remove_cvref_t<_Container>, span>
|
||||
&& !__detail::__is_std_array_v<remove_cvref_t<_Container>>
|
||||
&& !is_array_v<remove_cvref_t<_Container>>
|
||||
&& __detail::__is_base_derived_safe_convertible_v<
|
||||
remove_pointer_t<decltype(
|
||||
::std::__adl_data(::std::declval<_Container&>())
|
||||
+ ::std::__adl_size(::std::declval<_Container&>()))>,
|
||||
element_type>>* = nullptr>
|
||||
constexpr
|
||||
span(_Container& __range)
|
||||
noexcept(noexcept(::std::__adl_data(__range))
|
||||
&& noexcept(::std::__adl_size(__range)))
|
||||
: span(::std::__adl_data(__range), ::std::__adl_size(__range))
|
||||
{ }
|
||||
|
||||
template<typename _Container,
|
||||
enable_if_t<
|
||||
(_Extent == dynamic_extent)
|
||||
&& !is_same_v<remove_cvref_t<_Container>, span>
|
||||
&& !__detail::__is_std_array_v<remove_cvref_t<_Container>>
|
||||
&& !is_array_v<remove_cvref_t<_Container>>
|
||||
&& __detail::__is_base_derived_safe_convertible_v<
|
||||
remove_pointer_t<decltype(
|
||||
::std::__adl_data(::std::declval<_Container&>())
|
||||
+ ::std::__adl_size(::std::declval<_Container&>()))>,
|
||||
element_type>>* = nullptr>
|
||||
constexpr span(const _Container& __range)
|
||||
noexcept(noexcept(::std::__adl_data(__range))
|
||||
&& noexcept(::std::__adl_size(__range)))
|
||||
: span(::std::__adl_data(__range), ::std::__adl_size(__range))
|
||||
{ }
|
||||
|
||||
constexpr
|
||||
span(pointer __first, index_type __count) noexcept
|
||||
: __base_t(__count), _M_ptr(static_cast<pointer>(__first))
|
||||
{ __glibcxx_assert(_Extent == dynamic_extent || __count == _Extent); }
|
||||
|
||||
constexpr
|
||||
span(pointer __first, pointer __last) noexcept
|
||||
: span(::std::move(__first), static_cast<index_type>(__last - __first))
|
||||
{ }
|
||||
#endif // P1394
|
||||
|
||||
// assignment
|
||||
|
||||
constexpr span&
|
||||
operator=(const span&) noexcept = default;
|
||||
|
||||
// observers: element access
|
||||
|
||||
constexpr reference
|
||||
front() const noexcept
|
||||
{ return *this->begin(); }
|
||||
|
||||
constexpr reference
|
||||
back() const noexcept
|
||||
{
|
||||
iterator __it = this->end();
|
||||
--__it;
|
||||
return *__it;
|
||||
}
|
||||
|
||||
constexpr reference
|
||||
operator[](index_type __idx) const noexcept
|
||||
{ return *(this->_M_ptr + __idx); }
|
||||
|
||||
constexpr pointer
|
||||
data() const noexcept
|
||||
{ return this->_M_ptr; }
|
||||
|
||||
constexpr index_type
|
||||
size() const noexcept
|
||||
{ return this->__base_t::_M_extent(); }
|
||||
|
||||
constexpr index_type
|
||||
size_bytes() const noexcept
|
||||
{ return this->__base_t::_M_extent() * sizeof(element_type); }
|
||||
|
||||
constexpr bool
|
||||
empty() const noexcept
|
||||
{ return size() == 0; }
|
||||
|
||||
// observers: iterator support
|
||||
constexpr iterator
|
||||
begin() const noexcept
|
||||
{ return iterator(this->_M_ptr); }
|
||||
|
||||
constexpr const_iterator
|
||||
cbegin() const noexcept
|
||||
{ return const_iterator(this->_M_ptr); }
|
||||
|
||||
constexpr iterator
|
||||
end() const noexcept
|
||||
{ return iterator(this->_M_ptr + this->size()); }
|
||||
|
||||
constexpr const_iterator
|
||||
cend() const noexcept
|
||||
{ return const_iterator(this->_M_ptr + this->size()); }
|
||||
|
||||
constexpr reverse_iterator
|
||||
rbegin() const noexcept
|
||||
{ return reverse_iterator(this->end()); }
|
||||
|
||||
constexpr const_reverse_iterator
|
||||
crbegin() const noexcept
|
||||
{ return const_reverse_iterator(this->cend()); }
|
||||
|
||||
constexpr reverse_iterator
|
||||
rend() const noexcept
|
||||
{ return reverse_iterator(this->begin()); }
|
||||
|
||||
constexpr const_reverse_iterator
|
||||
crend() const noexcept
|
||||
{ return const_reverse_iterator(this->cbegin()); }
|
||||
|
||||
// observers: subranges
|
||||
template<size_t _Count>
|
||||
constexpr span<element_type, _Count>
|
||||
first() const
|
||||
{
|
||||
__glibcxx_assert(_Count < size());
|
||||
return { this->data(), _Count };
|
||||
}
|
||||
|
||||
constexpr span<element_type, dynamic_extent>
|
||||
first(index_type __count) const
|
||||
{
|
||||
__glibcxx_assert(__count < size());
|
||||
return { this->data(), __count };
|
||||
}
|
||||
|
||||
template<size_t _Count>
|
||||
constexpr span<element_type, _Count>
|
||||
last() const
|
||||
{
|
||||
static_assert(_Count == dynamic_extent ||
|
||||
_Extent == dynamic_extent || _Count <= _Extent,
|
||||
"Count or Extent are dynamic, "
|
||||
"or the Count is less than the static extent");
|
||||
__glibcxx_assert(_Count <= size());
|
||||
return { this->data() + (this->size() - _Count), _Count };
|
||||
}
|
||||
|
||||
constexpr span<element_type, dynamic_extent>
|
||||
last(index_type __count) const
|
||||
{
|
||||
__glibcxx_assert(__count < size());
|
||||
index_type __offset = (this->size() - __count);
|
||||
return { this->data() + __offset, __count };
|
||||
}
|
||||
|
||||
template<size_t _Offset, size_t _Count = dynamic_extent>
|
||||
constexpr auto
|
||||
subspan() const
|
||||
{
|
||||
static_assert(_Count == dynamic_extent ||
|
||||
_Extent == dynamic_extent ||
|
||||
(_Offset + _Count) <= _Extent,
|
||||
"Count or Extent are dynamic, "
|
||||
"or the Count + Offset is less than the static extent");
|
||||
constexpr size_t __span_extent =
|
||||
(_Count != dynamic_extent
|
||||
? _Count
|
||||
: (_Extent != dynamic_extent ? _Extent - _Offset
|
||||
: dynamic_extent));
|
||||
using __span_t = span<element_type, __span_extent>;
|
||||
if constexpr(_Count != dynamic_extent)
|
||||
{
|
||||
__glibcxx_assert((_Offset + _Count) < size());
|
||||
}
|
||||
return __span_t(this->data() + _Offset,
|
||||
(_Count == dynamic_extent ? this->size() - _Offset : _Count));
|
||||
}
|
||||
|
||||
constexpr span<element_type, dynamic_extent>
|
||||
subspan(index_type __offset, index_type __count = dynamic_extent) const
|
||||
{
|
||||
return {this->data() + __offset,
|
||||
__count == dynamic_extent ? this->size() - __offset : __count};
|
||||
}
|
||||
|
||||
// observers: range helpers
|
||||
|
||||
friend constexpr iterator
|
||||
begin(span __sp) noexcept
|
||||
{ return __sp.begin(); }
|
||||
|
||||
friend constexpr iterator
|
||||
end(span __sp) noexcept
|
||||
{ return __sp.end(); }
|
||||
|
||||
private:
|
||||
pointer _M_ptr;
|
||||
};
|
||||
|
||||
// deduction guides
|
||||
template<typename _Type, size_t _ArrayExtent>
|
||||
span(_Type(&)[_ArrayExtent])->span<_Type, _ArrayExtent>;
|
||||
|
||||
template<typename _Type, size_t _ArrayExtent>
|
||||
span(array<_Type, _ArrayExtent>&)->span<_Type, _ArrayExtent>;
|
||||
|
||||
template<typename _Type, size_t _ArrayExtent>
|
||||
span(const array<_Type, _ArrayExtent>&)
|
||||
->span<const _Type, _ArrayExtent>;
|
||||
|
||||
#if defined(_GLIBCXX_P1394) && _GLIBCXX_P1394
|
||||
|
||||
template<typename _ContiguousIterator, typename _Sentinel>
|
||||
span(_ContiguousIterator, _Sentinel)
|
||||
->span<remove_reference_t<
|
||||
typename iterator_traits<_ContiguousIterator>::reference>>;
|
||||
|
||||
template<typename _Range>
|
||||
span(_Range &&)
|
||||
->span<remove_reference_t<typename iterator_traits<decltype(
|
||||
::std::__adl_begin(::std::declval<_Range&>()))>::reference>>;
|
||||
|
||||
#else
|
||||
|
||||
template<typename _Container>
|
||||
span(_Container&)->span<typename _Container::value_type>;
|
||||
|
||||
template<typename _Container>
|
||||
span(const _Container&)->span<const typename _Container::value_type>;
|
||||
|
||||
#endif // P1394
|
||||
|
||||
template<typename _Type, size_t _Extent>
|
||||
span<const byte, _Extent == dynamic_extent
|
||||
? dynamic_extent : _Extent * sizeof(_Type)>
|
||||
inline as_bytes(span<_Type, _Extent> __sp) noexcept
|
||||
{
|
||||
return {reinterpret_cast<const byte*>(__sp.data()), __sp.size_bytes()};
|
||||
}
|
||||
|
||||
template<typename _Type, size_t _Extent>
|
||||
span<byte, _Extent == dynamic_extent
|
||||
? dynamic_extent : _Extent * sizeof(_Type)>
|
||||
as_writable_bytes(span<_Type, _Extent> __sp) noexcept
|
||||
{
|
||||
return {reinterpret_cast<byte*>(__sp.data()), __sp.size_bytes()};
|
||||
}
|
||||
|
||||
// tuple helpers
|
||||
template<size_t _Index, typename _Type, size_t _Extent>
|
||||
constexpr _Type&
|
||||
get(span<_Type, _Extent> __sp) noexcept
|
||||
{
|
||||
static_assert(_Extent != dynamic_extent
|
||||
&& (_Extent > 0) && (_Index < _Extent),
|
||||
"std::get can only be used with a span of non-dynamic (fixed) extent");
|
||||
return __sp[_Index];
|
||||
}
|
||||
|
||||
template<typename _Type, size_t _Extent>
|
||||
struct tuple_size<span<_Type, _Extent>>
|
||||
: public integral_constant<size_t, _Extent>
|
||||
{
|
||||
static_assert(_Extent != dynamic_extent, "tuple_size can only "
|
||||
"be used with a span of non-dynamic (fixed) extent");
|
||||
};
|
||||
|
||||
template<size_t _Index, typename _Type, size_t _Extent>
|
||||
struct tuple_element<_Index, span<_Type, _Extent>>
|
||||
{
|
||||
static_assert(_Extent != dynamic_extent, "tuple_size can only "
|
||||
"be used with a span of non-dynamic (fixed) extent");
|
||||
static_assert(_Index < _Extent, "Index is less than Extent");
|
||||
using type = typename span<_Type, _Extent>::element_type;
|
||||
};
|
||||
|
||||
_GLIBCXX_END_NAMESPACE_VERSION
|
||||
} // namespace std
|
||||
|
||||
#endif // C++20
|
||||
#endif // _GLIBCXX_SPAN
|
||||
|
|
@ -167,6 +167,9 @@
|
|||
#define __cpp_lib_list_remove_return_type 201806L
|
||||
#define __cpp_lib_math_constants 201907L
|
||||
#define __cpp_lib_to_array 201907L
|
||||
// FIXME: they forgot this feature test macro
|
||||
// get on someone's back about it in Belfast!!!
|
||||
#define __cpp_lib_span 201911
|
||||
#endif // C++2a
|
||||
#endif // C++17
|
||||
#endif // C++14
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=c++2a" }
|
||||
// { dg-do compile { target c++2a } }
|
||||
|
||||
#include <span>
|
||||
#include <deque>
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
std::deque<int> d{};
|
||||
std::span<int, std::dynamic_extent> myspan(d); // { dg-error "no match" }
|
||||
}
|
||||
|
||||
// { dg-prune-output "data" }
|
||||
// { dg-prune-output "invalid operands" }
|
||||
|
|
@ -0,0 +1,203 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=c++2a" }
|
||||
// { dg-do run { target c++2a } }
|
||||
|
||||
#include <testsuite_hooks.h>
|
||||
|
||||
#include <span>
|
||||
#include <type_traits>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
struct alignas(256) strawman
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
bool z;
|
||||
int w;
|
||||
};
|
||||
|
||||
struct naked_span
|
||||
{
|
||||
char* p;
|
||||
std::size_t n;
|
||||
};
|
||||
|
||||
struct strawman_span
|
||||
{
|
||||
strawman* p;
|
||||
std::size_t n;
|
||||
};
|
||||
|
||||
static_assert(sizeof(std::span<char, 0>) <= sizeof(char*));
|
||||
static_assert(sizeof(std::span<const char, 0>) <= sizeof(const char*));
|
||||
static_assert(sizeof(std::span<strawman, 0>) <= sizeof(strawman*));
|
||||
static_assert(sizeof(std::span<strawman, 1>) <= sizeof(strawman*));
|
||||
static_assert(sizeof(std::span<char>) <= sizeof(naked_span));
|
||||
static_assert(sizeof(std::span<strawman>) <= sizeof(strawman_span));
|
||||
|
||||
constexpr static std::array<int, 9> arr_data{ 0, 1, 2, 3, 4, 5, 6, 7, 8 };
|
||||
constexpr auto arr_data_span = std::span(arr_data);
|
||||
static_assert(arr_data_span.size() == 9);
|
||||
static_assert(arr_data_span.size_bytes() == 9 * sizeof(int));
|
||||
static_assert(*arr_data_span.begin() == 0);
|
||||
static_assert(*arr_data_span.data() == 0);
|
||||
static_assert(arr_data_span.front() == 0);
|
||||
static_assert(arr_data_span.back() == 8);
|
||||
static_assert(arr_data_span[0] == 0);
|
||||
static_assert(arr_data_span[1] == 1);
|
||||
static_assert(arr_data_span[2] == 2);
|
||||
static_assert(arr_data_span[3] == 3);
|
||||
static_assert(arr_data_span[4] == 4);
|
||||
static_assert(arr_data_span[5] == 5);
|
||||
static_assert(arr_data_span[6] == 6);
|
||||
static_assert(arr_data_span[7] == 7);
|
||||
static_assert(arr_data_span[8] == 8);
|
||||
static_assert(!arr_data_span.empty());
|
||||
static_assert(decltype(arr_data_span)::extent == 9);
|
||||
|
||||
constexpr static int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
|
||||
constexpr auto data_span = std::span(data);
|
||||
static_assert(data_span.size() == 9);
|
||||
static_assert(data_span.size_bytes() == 9 * sizeof(int));
|
||||
static_assert(*data_span.begin() == 0);
|
||||
static_assert(*data_span.data() == 0);
|
||||
static_assert(data_span.front() == 0);
|
||||
static_assert(data_span.back() == 8);
|
||||
static_assert(data_span[0] == 0);
|
||||
static_assert(data_span[1] == 1);
|
||||
static_assert(data_span[2] == 2);
|
||||
static_assert(data_span[3] == 3);
|
||||
static_assert(data_span[4] == 4);
|
||||
static_assert(data_span[5] == 5);
|
||||
static_assert(data_span[6] == 6);
|
||||
static_assert(data_span[7] == 7);
|
||||
static_assert(data_span[8] == 8);
|
||||
static_assert(!data_span.empty());
|
||||
static_assert(decltype(data_span)::extent == 9);
|
||||
|
||||
constexpr auto data_span_first = data_span.first<3>();
|
||||
static_assert(
|
||||
std::is_same_v<std::remove_cv_t<decltype(data_span_first)>, std::span<const int, 3>>);
|
||||
static_assert(decltype(data_span_first)::extent == 3);
|
||||
static_assert(data_span_first.size() == 3);
|
||||
static_assert(data_span_first.front() == 0);
|
||||
static_assert(data_span_first.back() == 2);
|
||||
static_assert(std::tuple_size_v<decltype(data_span_first)> == 3);
|
||||
static_assert(std::is_same_v<std::tuple_element_t<0, decltype(data_span_first)>, const int>);
|
||||
|
||||
constexpr auto data_span_first_dyn = data_span.first(4);
|
||||
static_assert(
|
||||
std::is_same_v<std::remove_cv_t<decltype(data_span_first_dyn)>, std::span<const int>>);
|
||||
static_assert(decltype(data_span_first_dyn)::extent == std::dynamic_extent);
|
||||
static_assert(data_span_first_dyn.size() == 4);
|
||||
static_assert(data_span_first_dyn.front() == 0);
|
||||
static_assert(data_span_first_dyn.back() == 3);
|
||||
|
||||
constexpr auto data_span_last = data_span.last<5>();
|
||||
static_assert(
|
||||
std::is_same_v<std::remove_cv_t<decltype(data_span_last)>, std::span<const int, 5>>);
|
||||
static_assert(decltype(data_span_last)::extent == 5);
|
||||
static_assert(data_span_last.size() == 5);
|
||||
static_assert(data_span_last.front() == 4);
|
||||
static_assert(data_span_last.back() == 8);
|
||||
static_assert(std::tuple_size_v<decltype(data_span_last)> == 5);
|
||||
static_assert(std::is_same_v<std::tuple_element_t<0, decltype(data_span_last)>, const int>);
|
||||
|
||||
constexpr auto data_span_last_dyn = data_span.last(6);
|
||||
static_assert(
|
||||
std::is_same_v<std::remove_cv_t<decltype(data_span_last_dyn)>, std::span<const int>>);
|
||||
static_assert(decltype(data_span_last_dyn)::extent == std::dynamic_extent);
|
||||
static_assert(data_span_last_dyn.size() == 6);
|
||||
static_assert(data_span_last_dyn.front() == 3);
|
||||
static_assert(data_span_last_dyn.back() == 8);
|
||||
|
||||
constexpr auto data_span_subspan = data_span.subspan<1, 3>();
|
||||
static_assert(
|
||||
std::is_same_v<std::remove_cv_t<decltype(data_span_subspan)>, std::span<const int, 3>>);
|
||||
static_assert(decltype(data_span_subspan)::extent == 3);
|
||||
static_assert(data_span_subspan.size() == 3);
|
||||
static_assert(data_span_subspan.front() == 1);
|
||||
static_assert(data_span_subspan.back() == 3);
|
||||
|
||||
constexpr auto data_span_subspan_offset = data_span.subspan<8>();
|
||||
static_assert(
|
||||
std::is_same_v<std::remove_cv_t<decltype(data_span_subspan_offset)>, std::span<const int, 1>>);
|
||||
static_assert(decltype(data_span_subspan_offset)::extent == 1);
|
||||
static_assert(data_span_subspan_offset.size() == 1);
|
||||
static_assert(data_span_subspan_offset.front() == 8);
|
||||
static_assert(data_span_subspan_offset.back() == 8);
|
||||
|
||||
constexpr auto data_span_subspan_empty = data_span.subspan(9, 0);
|
||||
static_assert(
|
||||
std::is_same_v<std::remove_cv_t<decltype(data_span_subspan_empty)>, std::span<const int>>);
|
||||
static_assert(decltype(data_span_subspan_empty)::extent == std::dynamic_extent);
|
||||
static_assert(data_span_subspan_empty.size() == 0);
|
||||
|
||||
constexpr auto data_span_subspan_empty_static = data_span.subspan<9>();
|
||||
static_assert(std::is_same_v<std::remove_cv_t<decltype(data_span_subspan_empty_static)>,
|
||||
std::span<const int, 0>>);
|
||||
static_assert(decltype(data_span_subspan_empty_static)::extent == 0);
|
||||
static_assert(data_span_subspan_empty.size() == 0);
|
||||
|
||||
std::span<short> shorts{};
|
||||
bool really_empty0 = shorts.empty();
|
||||
bool really_empty1 = std::empty(shorts);
|
||||
bool really_empty2 = shorts.data() == nullptr;
|
||||
bool really_empty3 = shorts.begin() == shorts.end();
|
||||
bool really_empty4 = shorts.cbegin() == shorts.cend();
|
||||
bool really_empty =
|
||||
really_empty0 && really_empty1 && really_empty2 && really_empty3 && really_empty4;
|
||||
(void)really_empty;
|
||||
VERIFY(really_empty);
|
||||
|
||||
std::vector<std::int_least32_t> value{ 0 };
|
||||
std::span<int32_t> muh_span(value);
|
||||
VERIFY(muh_span.size() == 1);
|
||||
std::byte* original_bytes = reinterpret_cast<std::byte*>(value.data());
|
||||
original_bytes[0] = static_cast<std::byte>(1);
|
||||
original_bytes[1] = static_cast<std::byte>(2);
|
||||
original_bytes[2] = static_cast<std::byte>(3);
|
||||
original_bytes[3] = static_cast<std::byte>(4);
|
||||
std::span<const std::byte> muh_byte_span = std::as_bytes(muh_span);
|
||||
std::span<std::byte> muh_mutable_byte_span = std::as_writable_bytes(muh_span);
|
||||
std::span<std::byte> muh_original_byte_span(original_bytes, original_bytes + 4);
|
||||
bool definitely_reinterpret_casted0 = std::equal(muh_byte_span.cbegin(), muh_byte_span.cend(),
|
||||
muh_original_byte_span.cbegin(), muh_original_byte_span.cend());
|
||||
bool definitely_reinterpret_casted1 = std::equal(muh_mutable_byte_span.cbegin(),
|
||||
muh_mutable_byte_span.cend(), muh_original_byte_span.cbegin(), muh_original_byte_span.cend());
|
||||
bool definitely_reinterpret_casted =
|
||||
definitely_reinterpret_casted0 && definitely_reinterpret_casted1;
|
||||
(void)definitely_reinterpret_casted;
|
||||
VERIFY(definitely_reinterpret_casted);
|
||||
|
||||
std::span<std::byte> muh_original_byte_span_ptr_size(original_bytes, 4);
|
||||
bool definitely_equivalent =
|
||||
std::equal(muh_original_byte_span_ptr_size.cbegin(), muh_original_byte_span_ptr_size.cend(),
|
||||
muh_original_byte_span.cbegin(), muh_original_byte_span.cend());
|
||||
(void)definitely_equivalent;
|
||||
VERIFY(definitely_equivalent);
|
||||
|
||||
return definitely_equivalent && definitely_reinterpret_casted && really_empty ? 0 : 1;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=c++2a" }
|
||||
// { dg-do compile { target c++2a } }
|
||||
|
||||
#include <span>
|
||||
#include <tuple>
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
std::span<int, std::dynamic_extent> myspan((int*)nullptr, 0ul);
|
||||
std::get<0>(myspan); // { dg-error "here" }
|
||||
}
|
||||
// { dg-error "static assertion failed" "" { target *-*-* } 0 }
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=c++2a" }
|
||||
// { dg-do compile { target c++2a } }
|
||||
|
||||
#include <span>
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
std::span<int, 2> myspan(nullptr, 2);
|
||||
myspan.last<3>(); // { dg-error "here" }
|
||||
}
|
||||
// { dg-error "static assertion failed" "" { target *-*-* } 0 }
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=c++2a" }
|
||||
// { dg-do compile { target c++2a } }
|
||||
|
||||
#include <span>
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
std::span<int, 2> myspan(nullptr, 2);
|
||||
myspan.subspan<3, 1>(); // { dg-error "here" }
|
||||
}
|
||||
// { dg-error "static assertion failed" "" { target *-*-* } 0 }
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=c++2a" }
|
||||
// { dg-do compile { target c++2a } }
|
||||
|
||||
#include <span>
|
||||
#include <tuple>
|
||||
|
||||
std::tuple_element<0, std::span<int, std::dynamic_extent>> ts; // { dg-error "here" }
|
||||
// { dg-error "static assertion failed" "" { target *-*-* } 0 }
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=c++2a" }
|
||||
// { dg-do compile { target c++2a } }
|
||||
|
||||
#include <span>
|
||||
#include <tuple>
|
||||
|
||||
std::tuple_element<3, std::span<int, 2>> te; // { dg-error "here" }
|
||||
// { dg-error "static assertion failed" "" { target *-*-* } 0 }
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=c++2a" }
|
||||
// { dg-do compile { target c++2a } }
|
||||
|
||||
#include <span>
|
||||
#include <tuple>
|
||||
|
||||
std::tuple_size<std::span<int, std::dynamic_extent>> ts; // { dg-error "here" }
|
||||
// { dg-error "static assertion failed" "" { target *-*-* } 0 }
|
||||
Loading…
Reference in New Issue