return static_cast<const _Derived&>(*this);
}
+ static constexpr bool
+ _S_bool(bool) noexcept; // not defined
+
+ template<typename _Tp>
+ static constexpr bool
+ _S_empty(_Tp& __t)
+ noexcept(noexcept(_S_bool(ranges::begin(__t) == ranges::end(__t))))
+ { return ranges::begin(__t) == ranges::end(__t); }
+
+ template<typename _Tp>
+ static constexpr auto
+ _S_size(_Tp& __t)
+ noexcept(noexcept(ranges::end(__t) - ranges::begin(__t)))
+ { return ranges::end(__t) - ranges::begin(__t); }
+
public:
constexpr bool
- empty() requires forward_range<_Derived>
- { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); }
+ empty()
+ noexcept(noexcept(_S_empty(_M_derived())))
+ requires forward_range<_Derived>
+ { return _S_empty(_M_derived()); }
constexpr bool
- empty() const requires forward_range<const _Derived>
- { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); }
+ empty() const
+ noexcept(noexcept(_S_empty(_M_derived())))
+ requires forward_range<const _Derived>
+ { return _S_empty(_M_derived()); }
constexpr explicit
- operator bool() requires requires { ranges::empty(_M_derived()); }
+ operator bool() noexcept(noexcept(ranges::empty(_M_derived())))
+ requires requires { ranges::empty(_M_derived()); }
{ return !ranges::empty(_M_derived()); }
constexpr explicit
- operator bool() const requires requires { ranges::empty(_M_derived()); }
+ operator bool() const noexcept(noexcept(ranges::empty(_M_derived())))
+ requires requires { ranges::empty(_M_derived()); }
{ return !ranges::empty(_M_derived()); }
constexpr auto
- data() requires contiguous_iterator<iterator_t<_Derived>>
- { return to_address(ranges::begin(_M_derived())); }
+ data() noexcept(noexcept(ranges::begin(_M_derived())))
+ requires contiguous_iterator<iterator_t<_Derived>>
+ { return std::to_address(ranges::begin(_M_derived())); }
constexpr auto
- data() const
+ data() const noexcept(noexcept(ranges::begin(_M_derived())))
requires range<const _Derived>
&& contiguous_iterator<iterator_t<const _Derived>>
- { return to_address(ranges::begin(_M_derived())); }
+ { return std::to_address(ranges::begin(_M_derived())); }
constexpr auto
- size()
+ size() noexcept(noexcept(_S_size(_M_derived())))
requires forward_range<_Derived>
&& sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
- { return ranges::end(_M_derived()) - ranges::begin(_M_derived()); }
+ { return _S_size(_M_derived()); }
constexpr auto
- size() const
+ size() const noexcept(noexcept(_S_size(_M_derived())))
requires forward_range<const _Derived>
&& sized_sentinel_for<sentinel_t<const _Derived>,
iterator_t<const _Derived>>
- { return ranges::end(_M_derived()) - ranges::begin(_M_derived()); }
+ { return _S_size(_M_derived()); }
constexpr decltype(auto)
front() requires forward_range<_Derived>
constexpr
subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s)
+ noexcept(is_nothrow_constructible_v<_It, decltype(__i)>
+ && is_nothrow_constructible_v<_Sent, _Sent&>)
requires (!_S_store_size)
: _M_begin(std::move(__i)), _M_end(__s)
{ }
constexpr
subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s,
__size_type __n)
+ noexcept(is_nothrow_constructible_v<_It, decltype(__i)>
+ && is_nothrow_constructible_v<_Sent, _Sent&>)
requires (_Kind == subrange_kind::sized)
: _M_begin(std::move(__i)), _M_end(__s)
{
&& __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
&& convertible_to<sentinel_t<_Rng>, _Sent>
constexpr
- subrange(_Rng&& __r) requires _S_store_size && sized_range<_Rng>
+ subrange(_Rng&& __r)
+ noexcept(noexcept(subrange(__r, ranges::size(__r))))
+ requires _S_store_size && sized_range<_Rng>
: subrange(__r, ranges::size(__r))
{ }
&& __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
&& convertible_to<sentinel_t<_Rng>, _Sent>
constexpr
- subrange(_Rng&& __r) requires (!_S_store_size)
+ subrange(_Rng&& __r)
+ noexcept(noexcept(subrange(ranges::begin(__r), ranges::end(__r))))
+ requires (!_S_store_size)
: subrange(ranges::begin(__r), ranges::end(__r))
{ }
&& convertible_to<sentinel_t<_Rng>, _Sent>
constexpr
subrange(_Rng&& __r, __size_type __n)
+ noexcept(noexcept(subrange(ranges::begin(__r), ranges::end(__r), __n)))
requires (_Kind == subrange_kind::sized)
: subrange{ranges::begin(__r), ranges::end(__r), __n}
{ }
constexpr explicit
single_view(const _Tp& __t)
+ noexcept(is_nothrow_copy_constructible_v<_Tp>)
: _M_value(__t)
{ }
constexpr explicit
single_view(_Tp&& __t)
+ noexcept(is_nothrow_move_constructible_v<_Tp>)
: _M_value(std::move(__t))
{ }
requires constructible_from<_Tp, _Args...>
constexpr explicit
single_view(in_place_t, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
: _M_value{in_place, std::forward<_Args>(__args)...}
{ }
template<typename _Tp>
constexpr auto
operator()(_Tp&& __e) const
+ noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
{ return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
};
&& requires { _S_fun(declval<_Tp>()); }
constexpr
ref_view(_Tp&& __t)
+ noexcept(noexcept(static_cast<_Range&>(std::declval<_Tp>())))
: _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
{ }
struct _All : __adaptor::_RangeAdaptorClosure
{
+ template<typename _Range>
+ static constexpr bool
+ _S_noexcept()
+ {
+ if constexpr (view<decay_t<_Range>>)
+ return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
+ else if constexpr (__detail::__can_ref_view<_Range>)
+ return true;
+ else
+ return noexcept(subrange{std::declval<_Range>()});
+ }
+
template<viewable_range _Range>
requires view<decay_t<_Range>>
|| __detail::__can_ref_view<_Range>
|| __detail::__can_subrange<_Range>
constexpr auto
operator()(_Range&& __r) const
+ noexcept(_S_noexcept<_Range>())
{
if constexpr (view<decay_t<_Range>>)
return std::forward<_Range>(__r);