{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_span 201902L
+#define __cpp_lib_span 202002L
inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
template<contiguous_iterator _It>
requires __is_compatible_ref<iter_reference_t<_It>>::value
- constexpr
+ constexpr explicit(extent != dynamic_extent)
span(_It __first, size_type __count)
noexcept
: _M_extent(__count), _M_ptr(std::to_address(__first))
- { __glibcxx_assert(_Extent == dynamic_extent || __count == _Extent); }
+ {
+ if constexpr (_Extent != dynamic_extent)
+ {
+ __glibcxx_assert(__count == _Extent);
+ }
+ }
template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
requires __is_compatible_ref<iter_reference_t<_It>>::value
&& (!is_convertible_v<_End, size_type>)
- constexpr
+ constexpr explicit(extent != dynamic_extent)
span(_It __first, _End __last)
noexcept(noexcept(__last - __first))
: _M_extent(static_cast<size_type>(__last - __first)),
_M_ptr(std::to_address(__first))
{
- if (_Extent != dynamic_extent)
- __glibcxx_assert((__last - __first) == _Extent);
+ if constexpr (_Extent != dynamic_extent)
+ {
+ __glibcxx_assert((__last - __first) == _Extent);
+ }
}
template<typename _Tp, size_t _ArrayExtent>
{ }
template<typename _Range>
- requires (_Extent == dynamic_extent)
- && ranges::contiguous_range<_Range> && ranges::sized_range<_Range>
+ requires ranges::contiguous_range<_Range> && ranges::sized_range<_Range>
&& (ranges::safe_range<_Range> || is_const_v<element_type>)
&& (!__detail::__is_std_span<remove_cvref_t<_Range>>::value)
&& (!__detail::__is_std_array<remove_cvref_t<_Range>>::value)
&& (!is_array_v<remove_cvref_t<_Range>>)
&& __is_compatible_ref<ranges::range_reference_t<_Range>>::value
- constexpr
+ constexpr explicit(extent != dynamic_extent)
span(_Range&& __range)
noexcept(noexcept(ranges::data(__range))
&& noexcept(ranges::size(__range)))
: span(ranges::data(__range), ranges::size(__range))
- { }
+ {
+ if constexpr (extent != dynamic_extent)
+ {
+ __glibcxx_assert(ranges::size(__range) == extent);
+ }
+ }
constexpr
span(const span&) noexcept = default;
template<typename _OType, size_t _OExtent>
- requires (_Extent == dynamic_extent || _Extent == _OExtent)
+ requires (_Extent == dynamic_extent || _OExtent == dynamic_extent
+ || _Extent == _OExtent)
&& (__is_array_convertible<_Type, _OType>::value)
constexpr
+ explicit(extent != dynamic_extent && _OExtent == dynamic_extent)
span(const span<_OType, _OExtent>& __s) noexcept
: _M_extent(__s.size()), _M_ptr(__s.data())
- { }
+ {
+ if constexpr (extent != dynamic_extent)
+ {
+ __glibcxx_assert(__s.size() == extent);
+ }
+ }
~span() noexcept = default;
__glibcxx_assert(_Count <= size());
else
static_assert(_Count <= extent);
- return { this->data(), _Count };
+ using _Sp = span<element_type, _Count>;
+ return _Sp{ this->data(), _Count };
}
constexpr span<element_type, dynamic_extent>
__glibcxx_assert(_Count <= size());
else
static_assert(_Count <= extent);
- return { this->data() + (this->size() - _Count), _Count };
+ using _Sp = span<element_type, _Count>;
+ return _Sp{ this->data() + (this->size() - _Count), _Count };
}
constexpr span<element_type, dynamic_extent>
-> span<element_type, _S_subspan_extent<_Offset, _Count>()>
{
if constexpr (_Extent == dynamic_extent)
- __glibcxx_assert(_Offset <= size());
+ {
+ __glibcxx_assert(_Offset <= size());
+ }
else
static_assert(_Offset <= extent);
+ using _Sp = span<element_type, _S_subspan_extent<_Offset, _Count>()>;
+
if constexpr (_Count == dynamic_extent)
- return { this->data() + _Offset, this->size() - _Offset };
+ return _Sp{ this->data() + _Offset, this->size() - _Offset };
else
{
if constexpr (_Extent == dynamic_extent)
static_assert(_Count <= extent);
static_assert(_Count <= (extent - _Offset));
}
- return { this->data() + _Offset, _Count };
+ return _Sp{ this->data() + _Offset, _Count };
}
}
? dynamic_extent : _Extent * sizeof(_Type)>
as_bytes(span<_Type, _Extent> __sp) noexcept
{
- return {reinterpret_cast<const byte*>(__sp.data()), __sp.size_bytes()};
+ auto data = reinterpret_cast<const byte*>(__sp.data());
+ auto size = __sp.size_bytes();
+ constexpr auto extent = _Extent == dynamic_extent
+ ? dynamic_extent : _Extent * sizeof(_Type);
+ return span<const byte, extent>{data, size};
}
template<typename _Type, size_t _Extent>
? dynamic_extent : _Extent * sizeof(_Type)>
as_writable_bytes(span<_Type, _Extent> __sp) noexcept
{
- return {reinterpret_cast<byte*>(__sp.data()), __sp.size_bytes()};
+ auto data = reinterpret_cast<byte*>(__sp.data());
+ auto size = __sp.size_bytes();
+ constexpr auto extent = _Extent == dynamic_extent
+ ? dynamic_extent : _Extent * sizeof(_Type);
+ return span<byte, extent>{data, size};
}
namespace ranges
--- /dev/null
+// Copyright (C) 2020 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=gnu++2a" }
+// { dg-do compile { target c++2a } }
+
+#include <span>
+
+struct Range
+{
+ int* begin();
+ int* end();
+ unsigned size() const;
+} r;
+
+auto first = std::begin(r), last = std::end(r);
+
+// span(It, size_type)
+std::span<int> s1 = {first, 2};
+std::span<int, 2> s2 = {first, 2}; // { dg-error "could not convert" }
+
+// span(It, End)
+std::span<int> s3 = {first, last};
+std::span<int, 2> s4 = {first, last}; // { dg-error "could not convert" }
+
+// span(R&&)
+std::span<int> s5 = r;
+std::span<int, 2> s6 = r; // { dg-error "conversion from" }
+
+// span(const span<OtherElement, OtherExtent>&)
+std::span<const int> s7 = s5;
+std::span<const int> s8 = s6;
+std::span<const int, 1> s9 = s5.first(1); // { dg-error "conversion from" }
+std::span<const int, 1> s10 = s7.first(1); // { dg-error "conversion from" }
projects / platform / upstream / gcc.git / commitdiff