# include <string_view>
#endif
+#if __glibcxx_ranges_to_container // C++ >= 23
+# include <bits/ranges_algobase.h> // ranges::copy
+# include <bits/ranges_util.h> // ranges::subrange
+#endif
+
#if __cplusplus > 202302L
# include <charconv>
#endif
_GLIBCXX_NOEXCEPT
{ _S_copy(__p, __k1, __k2 - __k1); }
+#if __glibcxx_ranges_to_container // C++ >= 23
+ // pre: __n == ranges::distance(__rg). __p+[0,__n) is a valid range.
+ template<typename _Rg>
+ static constexpr void
+ _S_copy_range(pointer __p, _Rg&& __rg, size_type __n)
+ {
+ if constexpr (ranges::contiguous_range<_Rg>
+ && is_same_v<ranges::range_value_t<_Rg>, _CharT>)
+ _S_copy(__p, ranges::data(std::forward<_Rg>(__rg)), __n);
+ else
+ for (auto&& __e : __rg)
+ traits_type::assign(*__p++, std::forward<decltype(__e)>(__e));
+ }
+#endif
+
_GLIBCXX20_CONSTEXPR
static int
_S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
__str._M_set_length(0);
}
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Construct a string from a range.
+ * @since C++23
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ constexpr
+ basic_string(from_range_t, _Rg&& __rg, const _Alloc& __a = _Alloc())
+ : basic_string(__a)
+ {
+ if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
+ {
+ const auto __n = static_cast<size_type>(ranges::distance(__rg));
+ reserve(__n);
+ _S_copy_range(_M_data(), std::forward<_Rg>(__rg), __n);
+ _M_set_length(__n);
+ }
+ else
+ {
+ auto __first = ranges::begin(__rg);
+ const auto __last = ranges::end(__rg);
+ for (; __first != __last; ++__first)
+ push_back(*__first);
+ }
+ }
+#endif
+
/**
* @brief Construct string from an initializer %list.
* @param __l std::initializer_list of characters.
append(size_type __n, _CharT __c)
{ return _M_replace_aux(this->size(), size_type(0), __n, __c); }
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Append a range to the string.
+ * @param __rg A range of values that are convertible to `value_type`.
+ * @since C++23
+ *
+ * The range `__rg` is allowed to overlap with `*this`.
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ constexpr basic_string&
+ append_range(_Rg&& __rg)
+ {
+ // N.B. __rg may overlap with *this, so we must copy from __rg before
+ // existing elements or iterators referring to *this are invalidated.
+ // e.g. in s.append_range(views::concat(s, str)), rg overlaps s.
+ if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
+ {
+ const auto __len = size_type(ranges::distance(__rg));
+
+ // Don't care if this addition wraps around, we check it below:
+ const size_type __newlen = size() + __len;
+
+ if ((capacity() - size()) >= __len)
+ _S_copy_range(_M_data() + size(), std::forward<_Rg>(__rg),
+ __len);
+ else
+ {
+ _M_check_length(0, __len, "basic_string::append_range");
+ basic_string __s(_M_get_allocator());
+ __s.reserve(__newlen);
+ _S_copy_range(__s._M_data() + size(), std::forward<_Rg>(__rg),
+ __len);
+ _S_copy(__s._M_data(), _M_data(), size());
+ if (!_M_is_local())
+ _M_destroy(_M_allocated_capacity);
+ _M_data(__s._M_data());
+ _M_capacity(__s._M_allocated_capacity);
+ __s._M_data(__s._M_local_data());
+ __s._M_length(0);
+ }
+ _M_set_length(__newlen); // adds null-terminator
+ }
+ else
+ {
+ basic_string __s(from_range, std::forward<_Rg>(__rg),
+ _M_get_allocator());
+ append(__s);
+ }
+ return *this;
+ }
+#endif
+
#if __cplusplus >= 201103L
/**
* @brief Append an initializer_list of characters.
{ return this->replace(begin(), end(), __first, __last); }
#endif
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Assign a range to the string.
+ * @param __rg A range of values that are convertible to `value_type`.
+ * @since C++23
+ *
+ * The range `__rg` is allowed to overlap with `*this`.
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ constexpr basic_string&
+ assign_range(_Rg&& __rg)
+ {
+ basic_string __s(from_range, std::forward<_Rg>(__rg),
+ _M_get_allocator());
+ assign(std::move(__s));
+ return *this;
+ }
+#endif
+
#if __cplusplus >= 201103L
/**
* @brief Set value to an initializer_list of characters.
{ this->replace(__p, __p, __beg, __end); }
#endif
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Insert a range into the string.
+ * @param __rg A range of values that are convertible to `value_type`.
+ * @since C++23
+ *
+ * The range `__rg` is allowed to overlap with `*this`.
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ constexpr iterator
+ insert_range(const_iterator __p, _Rg&& __rg)
+ {
+ auto __pos = __p - cbegin();
+
+ if constexpr (ranges::forward_range<_Rg>)
+ if (ranges::empty(__rg))
+ return begin() + __pos;
+
+
+ if (__p == cend())
+ append_range(std::forward<_Rg>(__rg));
+ else
+ {
+ basic_string __s(from_range, std::forward<_Rg>(__rg),
+ _M_get_allocator());
+ insert(__pos, __s);
+ }
+ return begin() + __pos;
+ }
+#endif
+
#if __cplusplus >= 201103L
/**
* @brief Insert an initializer_list of characters.
__k1.base(), __k2 - __k1);
}
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Replace part of the string with a range.
+ * @param __rg A range of values that are convertible to `value_type`.
+ * @since C++23
+ *
+ * The range `__rg` is allowed to overlap with `*this`.
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ constexpr basic_string&
+ replace_with_range(const_iterator __i1, const_iterator __i2, _Rg&& __rg)
+ {
+ if (__i1 == cend())
+ append_range(std::forward<_Rg>(__rg));
+ else
+ {
+ basic_string __s(from_range, std::forward<_Rg>(__rg),
+ _M_get_allocator());
+ replace(__i1, __i2, __s);
+ }
+ return *this;
+ }
+#endif
+
#if __cplusplus >= 201103L
/**
* @brief Replace range of characters with initializer_list.
typename basic_string<_CharT, _Traits, _Allocator>::size_type,
const _Allocator& = _Allocator())
-> basic_string<_CharT, _Traits, _Allocator>;
+
+#if __glibcxx_ranges_to_container // C++ >= 23
+ template<ranges::input_range _Rg,
+ typename _Allocator = allocator<ranges::range_value_t<_Rg>>>
+ basic_string(from_range_t, _Rg&&, _Allocator = _Allocator())
+ -> basic_string<ranges::range_value_t<_Rg>,
+ char_traits<ranges::range_value_t<_Rg>>,
+ _Allocator>;
+#endif
_GLIBCXX_END_NAMESPACE_CXX11
#endif
#endif
}
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Construct a string from a range.
+ * @since C++23
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ basic_string(from_range_t, _Rg&& __rg, const _Alloc& __a = _Alloc())
+ : basic_string(__a)
+ {
+ if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
+ {
+ const auto __n = static_cast<size_type>(ranges::distance(__rg));
+ if (__n == 0)
+ return;
+
+ reserve(__n);
+ pointer __p = _M_data();
+ if constexpr (ranges::contiguous_range<_Rg>
+ && is_same_v<ranges::range_value_t<_Rg>, _CharT>)
+ _M_copy(__p, ranges::data(std::forward<_Rg>(__rg)), __n);
+ else
+ for (auto&& __e : __rg)
+ traits_type::assign(*__p++, std::forward<decltype(__e)>(__e));
+ _M_rep()->_M_set_length_and_sharable(__n);
+ }
+ else
+ {
+ auto __first = ranges::begin(__rg);
+ const auto __last = ranges::end(__rg);
+ for (; __first != __last; ++__first)
+ push_back(*__first);
+ }
+ }
+#endif
+
/**
* @brief Construct string from an initializer %list.
* @param __l std::initializer_list of characters.
basic_string&
append(size_type __n, _CharT __c);
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Append a range to the string.
+ * @since C++23
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ basic_string&
+ append_range(_Rg&& __rg)
+ {
+ basic_string __s(from_range, std::forward<_Rg>(__rg),
+ get_allocator());
+ append(__s);
+ return *this;
+ }
+#endif
+
#if __cplusplus >= 201103L
/**
* @brief Append an initializer_list of characters.
assign(_InputIterator __first, _InputIterator __last)
{ return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Set value to a range of characters.
+ * @since C++23
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ basic_string&
+ assign_range(_Rg&& __rg)
+ {
+ basic_string __s(from_range, std::forward<_Rg>(__rg),
+ get_allocator());
+ assign(std::move(__s));
+ return *this;
+ }
+#endif
+
#if __cplusplus >= 201103L
/**
* @brief Set value to an initializer_list of characters.
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
{ this->replace(__p, __p, __beg, __end); }
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Insert a range into the string.
+ * @since C++23
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ iterator
+ insert_range(const_iterator __p, _Rg&& __rg)
+ {
+ auto __pos = __p - cbegin();
+
+ if constexpr (ranges::forward_range<_Rg>)
+ if (ranges::empty(__rg))
+ return begin() + __pos;
+
+ if (__p == cend())
+ append_range(std::forward<_Rg>(__rg));
+ else
+ {
+ basic_string __s(from_range, std::forward<_Rg>(__rg),
+ get_allocator());
+ insert(__pos, __s);
+ }
+ return begin() + __pos;
+ }
+#endif
+
#if __cplusplus >= 201103L
/**
* @brief Insert an initializer_list of characters.
__k1.base(), __k2 - __k1);
}
+#if __glibcxx_ranges_to_container // C++ >= 23
+ /**
+ * @brief Replace part of the string with a range.
+ * @since C++23
+ */
+ template<__detail::__container_compatible_range<_CharT> _Rg>
+ basic_string&
+ replace_with_range(const_iterator __i1, const_iterator __i2, _Rg&& __rg)
+ {
+ if (__i1 == cend())
+ append_range(std::forward<_Rg>(__rg));
+ else
+ {
+ basic_string __s(from_range, std::forward<_Rg>(__rg),
+ get_allocator());
+ replace(__i1 - cbegin(), __i2 - __i1, __s);
+ }
+ return *this;
+ }
+#endif
+
#if __cplusplus >= 201103L
/**
* @brief Replace range of characters with initializer_list.
--- /dev/null
+// { dg-do run { target c++23 } }
+
+#include <string>
+#include <span>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+#include <testsuite_allocator.h>
+
+void
+test_deduction_guide(char* p)
+{
+ __gnu_test::test_input_range<char> r(nullptr, nullptr);
+ std::basic_string v(std::from_range, r);
+ static_assert(std::is_same_v<decltype(v), std::string>);
+
+ using Alloc = __gnu_test::SimpleAllocator<char>;
+ Alloc alloc;
+ std::basic_string v2(std::from_range, r, alloc);
+ static_assert(std::is_same_v<decltype(v2), std::basic_string<char, std::char_traits<char>, Alloc>>);
+
+ __gnu_test::test_input_range<wchar_t> wr(nullptr, nullptr);
+ std::basic_string w(std::from_range, wr);
+ static_assert(std::is_same_v<decltype(w), std::wstring>);
+
+ using WAlloc = __gnu_test::SimpleAllocator<wchar_t>;
+ WAlloc walloc;
+ std::basic_string w2(std::from_range, wr, walloc);
+ static_assert(std::is_same_v<decltype(w2), std::basic_string<wchar_t, std::char_traits<wchar_t>, WAlloc>>);
+}
+
+template<typename Range, typename Alloc>
+constexpr void
+do_test(Alloc alloc)
+{
+ // The basic_string's value_type.
+ using V = typename std::allocator_traits<Alloc>::value_type;
+ using CT = std::char_traits<V>;
+
+ // The range's value_type.
+ using T = std::ranges::range_value_t<Range>;
+ T a[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
+
+ auto eq = [](const std::basic_string<V, CT, Alloc>& l, std::span<T> r) {
+ if (l.size() != r.size())
+ return false;
+ for (auto i = 0u; i < l.size(); ++i)
+ if (l[i] != r[i])
+ return false;
+ return true;
+ };
+
+ std::basic_string<V, CT, Alloc> v0(std::from_range, Range(a, a+0));
+ VERIFY( v0.empty() );
+ VERIFY( v0.get_allocator() == Alloc() );
+
+ std::basic_string<V, CT, Alloc> v4(std::from_range, Range(a, a+4));
+ VERIFY( eq(v4, {a, 4}) );
+ VERIFY( v4.get_allocator() == Alloc() );
+
+ std::basic_string<V, CT, Alloc> v9(std::from_range, Range(a, a+9), alloc);
+ VERIFY( eq(v9, {a, 9}) );
+ VERIFY( v9.get_allocator() == alloc );
+
+ std::basic_string<V, CT, Alloc> v20(std::from_range, Range(a, a+20), alloc);
+ VERIFY( eq(v20, {a, 20}) );
+ VERIFY( v20.get_allocator() == alloc );
+}
+
+template<typename Range>
+void
+do_test_a()
+{
+ do_test<Range>(std::allocator<char>());
+ do_test<Range>(__gnu_test::uneq_allocator<char>(42));
+ do_test<Range>(std::allocator<wchar_t>());
+ do_test<Range>(__gnu_test::uneq_allocator<wchar_t>(42));
+}
+
+bool
+test_ranges()
+{
+ using namespace __gnu_test;
+
+ do_test_a<test_forward_range<char>>();
+ do_test_a<test_forward_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, forward_iterator_wrapper>>();
+
+ do_test_a<test_input_range<char>>();
+ do_test_a<test_input_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper>>();
+
+ do_test_a<test_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper_nocopy>>();
+
+ // Not lvalue-convertible to char
+ struct C {
+ C(char v) : val(v) { }
+ operator char() && { return val; }
+ bool operator==(char b) const { return b == val; }
+ char val;
+ };
+ using rvalue_input_range = test_range<C, input_iterator_wrapper_rval>;
+ do_test<rvalue_input_range>(std::allocator<char>());
+
+ return true;
+}
+
+constexpr bool
+test_constexpr()
+{
+#if _GLIBCXX_USE_CXX11_ABI
+ // XXX: this doesn't test the non-forward_range code paths are constexpr.
+ do_test<std::string_view>(std::allocator<char>());
+#endif // _GLIBCXX_USE_CXX11_ABI
+ return true;
+}
+
+int main()
+{
+ test_ranges();
+ static_assert( test_constexpr() );
+}
--- /dev/null
+// { dg-do run { target c++23 } }
+
+#include <span>
+#include <string>
+#include <testsuite_allocator.h>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+template<typename Range, typename Alloc>
+constexpr void
+do_test()
+{
+ // The vector's value_type.
+ using V = typename std::allocator_traits<Alloc>::value_type;
+ using CT = std::char_traits<V>;
+
+ // The range's value_type.
+ using T = std::ranges::range_value_t<Range>;
+ T a[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
+
+ auto eq = [](const std::basic_string<V, CT, Alloc>& l, std::span<T> r) {
+ if (l.size() != r.size())
+ return false;
+ for (auto i = 0u; i < l.size(); ++i)
+ if (l[i] != r[i])
+ return false;
+ return true;
+ };
+
+ Range r4(a, a+4);
+ Range r5(a+4, a+9);
+ Range r11(a+9, a+20);
+
+ std::basic_string<V, CT, Alloc> v;
+ v.append_range(r4);
+ VERIFY( eq(v, {a, 4}) );
+ v.append_range(r5);
+ VERIFY( eq(v, {a, 9}) );
+
+ std::basic_string<V, CT, Alloc> const s = v;
+ v.append_range(r11);
+ VERIFY( eq(v, a) );
+ v.append_range(Range(a, a));
+ VERIFY( eq(v, a) );
+ v.clear();
+ v.append_range(Range(a, a));
+ VERIFY( v.empty() );
+}
+
+template<typename Range>
+void
+do_test_a()
+{
+ do_test<Range, std::allocator<char>>();
+ do_test<Range, __gnu_test::SimpleAllocator<char>>();
+ do_test<Range, std::allocator<wchar_t>>();
+ do_test<Range, __gnu_test::SimpleAllocator<wchar_t>>();
+}
+
+bool
+test_ranges()
+{
+ using namespace __gnu_test;
+
+ do_test_a<test_forward_range<char>>();
+ do_test_a<test_forward_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, forward_iterator_wrapper>>();
+
+ do_test_a<test_input_range<char>>();
+ do_test_a<test_input_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper>>();
+
+ do_test_a<test_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper_nocopy>>();
+
+ // Not lvalue-convertible to char
+ struct C {
+ C(char v) : val(v) { }
+ operator char() && { return val; }
+ bool operator==(char b) const { return b == val; }
+ char val;
+ };
+ using rvalue_input_range = test_range<C, input_iterator_wrapper_rval>;
+ do_test<rvalue_input_range, std::allocator<char>>();
+
+ return true;
+}
+
+void
+test_overlapping()
+{
+ std::string const s = "1234abcd";
+
+ std::string c = s;
+ c.append_range(std::string_view(c));
+ VERIFY( c == "1234abcd1234abcd" );
+
+ c = s;
+ c.append_range(std::string_view(c).substr(4, 4));
+ VERIFY( c == "1234abcdabcd" );
+
+ c = s;
+ c.reserve(12);
+ c.append_range(std::string_view(c).substr(0, 4));
+ VERIFY( c == "1234abcd1234" );
+}
+
+constexpr bool
+test_constexpr()
+{
+#if _GLIBCXX_USE_CXX11_ABI
+ // XXX: this doesn't test the non-forward_range code paths are constexpr.
+ do_test<std::string_view, std::allocator<char>>();
+#endif // _GLIBCXX_USE_CXX11_ABI
+ return true;
+}
+
+int main()
+{
+ test_ranges();
+ test_overlapping();
+ static_assert( test_constexpr() );
+}
--- /dev/null
+// { dg-do run { target c++23 } }
+
+#include <vector>
+#include <span>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+#include <testsuite_allocator.h>
+
+template<typename Range, typename Alloc>
+constexpr void
+do_test()
+{
+ // The vector's value_type.
+ using V = typename std::allocator_traits<Alloc>::value_type;
+ using CT = std::char_traits<V>;
+
+ // The range's value_type.
+ using T = std::ranges::range_value_t<Range>;
+ T a[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
+
+ auto eq = [](const std::basic_string<V, CT, Alloc>& l, std::span<T> r) {
+ if (l.size() != r.size())
+ return false;
+ for (auto i = 0u; i < l.size(); ++i)
+ if (l[i] != r[i])
+ return false;
+ return true;
+ };
+
+ std::basic_string<V, CT, Alloc> v;
+ v.assign_range(Range(a, a));
+ VERIFY( v.empty() );
+ v.assign_range(Range(a, a+4));
+ VERIFY( eq(v, {a, 4}) );
+ v.assign_range(Range(a, a+9));
+ VERIFY( eq(v, {a, 9}) );
+ std::basic_string<V, CT, Alloc> const s = v;
+ v.assign_range(Range(a, a+20));
+ VERIFY( eq(v, {a, 20}) );
+}
+
+template<typename Range>
+void
+do_test_a()
+{
+ do_test<Range, std::allocator<char>>();
+ do_test<Range, __gnu_test::SimpleAllocator<char>>();
+ do_test<Range, std::allocator<wchar_t>>();
+ do_test<Range, __gnu_test::SimpleAllocator<wchar_t>>();
+}
+
+bool
+test_ranges()
+{
+ using namespace __gnu_test;
+
+ do_test_a<test_forward_range<char>>();
+ do_test_a<test_forward_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, forward_iterator_wrapper>>();
+
+ do_test_a<test_input_range<char>>();
+ do_test_a<test_input_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper>>();
+
+ do_test_a<test_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper_nocopy>>();
+
+ // Not lvalue-convertible to char
+ struct C {
+ C(char v) : val(v) { }
+ operator char() && { return val; }
+ bool operator==(char b) const { return b == val; }
+ char val;
+ };
+ using rvalue_input_range = test_range<C, input_iterator_wrapper_rval>;
+ do_test<rvalue_input_range, std::allocator<char>>();
+
+ return true;
+}
+
+void
+test_overlapping()
+{
+ std::string const s = "1234abcd";
+
+ std::string c = s;
+ c.assign_range(std::string_view(c));
+ VERIFY( c == "1234abcd" );
+
+ c = s;
+ c.assign_range(std::string_view(c).substr(4, 4));
+ VERIFY( c == "abcd" );
+
+ c = s;
+ c.assign_range(std::string_view(c).substr(0, 4));
+ VERIFY( c == "1234" );
+}
+
+constexpr bool
+test_constexpr()
+{
+#if _GLIBCXX_USE_CXX11_ABI
+ // XXX: this doesn't test the non-forward_range code paths are constexpr.
+ do_test<std::string_view, std::allocator<char>>();
+#endif // _GLIBCXX_USE_CXX11_ABI
+ return true;
+}
+
+int main()
+{
+ test_ranges();
+ test_overlapping();
+ static_assert( test_constexpr() );
+}
--- /dev/null
+// { dg-do run { target c++23 } }
+
+#include <span>
+#include <string>
+#include <testsuite_allocator.h>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+template<typename Range, typename Alloc>
+constexpr void
+do_test()
+{
+ // The vector's value_type.
+ using V = typename std::allocator_traits<Alloc>::value_type;
+ using CT = std::char_traits<V>;
+
+ // The range's value_type.
+ using T = std::ranges::range_value_t<Range>;
+ T a[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
+
+ auto eq = [](const std::basic_string<V, CT, Alloc>& l, std::span<T> r) {
+ if (l.size() != r.size())
+ return false;
+ for (auto i = 0u; i < l.size(); ++i)
+ if (l[i] != r[i])
+ return false;
+ return true;
+ };
+
+ std::basic_string<V, CT, Alloc> v;
+ auto it = v.insert_range(v.end(), Range(a, a));
+ VERIFY( v.empty() );
+ VERIFY( it == v.begin() );
+ it = v.insert_range(v.end(), Range(a, a+4));
+ VERIFY( eq(v, {a, 4}) );
+ VERIFY( it == v.begin() );
+ it = v.insert_range(v.end(), Range(a+4, a+9));
+ VERIFY( eq(v, {a, 9}) );
+ VERIFY( it == v.begin()+4 );
+
+ std::basic_string<V, CT, Alloc> s = v;
+ it = v.insert_range(v.end(), Range(a+9, a+20));
+ VERIFY( eq(v, {a, 20}) );
+ VERIFY( it == v.begin()+9 );
+
+ v = std::basic_string<V, CT, Alloc>();
+ it = v.insert_range(v.begin(), Range(a, a+5));
+ VERIFY( it == v.begin() );
+ s = v;
+ it = v.insert_range(v.begin() + 5, Range(a+5, a+20));
+ VERIFY( eq(v, {a, 20}) );
+ VERIFY( it == v.begin()+5 );
+}
+
+template<typename Range>
+void
+do_test_a()
+{
+ do_test<Range, std::allocator<char>>();
+ do_test<Range, __gnu_test::SimpleAllocator<char>>();
+ do_test<Range, std::allocator<wchar_t>>();
+ do_test<Range, __gnu_test::SimpleAllocator<wchar_t>>();
+}
+
+bool
+test_ranges()
+{
+ using namespace __gnu_test;
+
+ do_test_a<test_forward_range<char>>();
+ do_test_a<test_forward_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, forward_iterator_wrapper>>();
+
+ do_test_a<test_input_range<char>>();
+ do_test_a<test_input_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper>>();
+
+ do_test_a<test_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper_nocopy>>();
+
+ // Not lvalue-convertible to char
+ struct C {
+ C(char v) : val(v) { }
+ operator char() && { return val; }
+ bool operator==(char b) const { return b == val; }
+ char val;
+ };
+ using rvalue_input_range = test_range<C, input_iterator_wrapper_rval>;
+ do_test<rvalue_input_range, std::allocator<char>>();
+
+ return true;
+}
+
+void
+test_overlapping()
+{
+ std::string const s = "1234abcd";
+
+ std::string c = s;
+ c.insert_range(c.end(), std::string_view(c));
+ VERIFY( c == "1234abcd1234abcd" );
+
+ c = s;
+ c.insert_range(c.begin()+4, std::string_view(c).substr(4, 4));
+ VERIFY( c == "1234abcdabcd" );
+
+ c = s;
+ c.reserve(12);
+ c.insert_range(c.begin()+2, std::string_view(c).substr(0, 4));
+ VERIFY( c == "12123434abcd" );
+}
+
+constexpr bool
+test_constexpr()
+{
+#if _GLIBCXX_USE_CXX11_ABI
+ // XXX: this doesn't test the non-forward_range code paths are constexpr.
+ do_test<std::string_view, std::allocator<char>>();
+#endif // _GLIBCXX_USE_CXX11_ABI
+ return true;
+}
+
+int main()
+{
+ test_ranges();
+ test_overlapping();
+ static_assert( test_constexpr() );
+}
--- /dev/null
+// { dg-do run { target c++23 } }
+
+#include <span>
+#include <string>
+#include <testsuite_allocator.h>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+template<typename Range, typename Alloc>
+constexpr void
+do_test()
+{
+ // The vector's value_type.
+ using V = typename std::allocator_traits<Alloc>::value_type;
+ using CT = std::char_traits<V>;
+
+ // The range's value_type.
+ using T = std::ranges::range_value_t<Range>;
+ T a[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
+
+ auto eq = [](const std::basic_string<V, CT, Alloc>& l, std::span<T> r) {
+ if (l.size() != r.size())
+ return false;
+ for (auto i = 0u; i < l.size(); ++i)
+ if (l[i] != r[i])
+ return false;
+ return true;
+ };
+
+ std::basic_string<V, CT, Alloc> v;
+ v.replace_with_range(v.end(), v.end(), Range(a, a));
+ VERIFY( v.empty() );
+ v.replace_with_range(v.end(), v.end(), Range(a, a+4));
+ VERIFY( eq(v, {a, 4}) );
+ v.replace_with_range(v.end(), v.end(), Range(a+4, a+9));
+ VERIFY( eq(v, {a, 9}) );
+ std::basic_string<V, CT, Alloc> s = v;
+ v.replace_with_range(v.end(), v.end(), Range(a+9, a+20));
+ VERIFY( eq(v, {a, 20}) );
+
+ v.replace_with_range(v.begin()+10, v.begin()+20, Range(a+5, a+10));
+ VERIFY( v.size() == 15 );
+ v.replace_with_range(v.begin(), v.begin()+10, Range(a, a+5));
+ VERIFY( eq(v, {a, 10}) );
+
+ s = v;
+ v.replace_with_range(v.begin(), v.begin()+4, Range(a, a+8));
+ VERIFY( v.size() == 14 );
+ v.replace_with_range(v.begin()+8, v.begin()+12, Range(a+8, a+16));
+ VERIFY( v.size() == 18 );
+ v.replace_with_range(v.begin()+16, v.begin()+18, Range(a+16, a+20));
+ VERIFY( eq(v, {a, 20}) );
+}
+
+template<typename Range>
+void
+do_test_a()
+{
+ do_test<Range, std::allocator<char>>();
+ do_test<Range, __gnu_test::SimpleAllocator<char>>();
+ do_test<Range, std::allocator<wchar_t>>();
+ do_test<Range, __gnu_test::SimpleAllocator<wchar_t>>();
+}
+
+bool
+test_ranges()
+{
+ using namespace __gnu_test;
+
+ do_test_a<test_forward_range<char>>();
+ do_test_a<test_forward_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, forward_iterator_wrapper>>();
+
+ do_test_a<test_input_range<char>>();
+ do_test_a<test_input_sized_range<char>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper>>();
+
+ do_test_a<test_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range<char, input_iterator_wrapper_nocopy>>();
+ do_test_a<test_sized_range_sized_sent<char, input_iterator_wrapper_nocopy>>();
+
+ // Not lvalue-convertible to char
+ struct C {
+ C(char v) : val(v) { }
+ operator char() && { return val; }
+ bool operator==(char b) const { return b == val; }
+ char val;
+ };
+ using rvalue_input_range = test_range<C, input_iterator_wrapper_rval>;
+ do_test<rvalue_input_range, std::allocator<char>>();
+
+ return true;
+}
+
+void
+test_overlapping()
+{
+ std::string const s = "1234abcd";
+
+ std::string c = s;
+ c.replace_with_range(c.end(), c.end(), std::string_view(c));
+ VERIFY( c == "1234abcd1234abcd" );
+
+ c = s;
+ c.replace_with_range(c.begin(), c.begin()+4, std::string_view(c).substr(4, 4));
+ VERIFY( c == "abcdabcd" );
+
+ c = s;
+ c.replace_with_range(c.begin()+2, c.begin()+4, std::string_view(c).substr(0, 4));
+ VERIFY( c == "121234abcd" );
+
+ c = s;
+ c.replace_with_range(c.begin()+2, c.begin()+2, std::string_view(c).substr(0, 4));
+ VERIFY( c == "12123434abcd" );
+}
+
+constexpr bool
+test_constexpr()
+{
+#if _GLIBCXX_USE_CXX11_ABI
+ // XXX: this doesn't test the non-forward_range code paths are constexpr.
+ do_test<std::string_view, std::allocator<char>>();
+#endif // _GLIBCXX_USE_CXX11_ABI
+ return true;
+}
+
+int main()
+{
+ test_ranges();
+ test_overlapping();
+ static_assert( test_constexpr() );
+}
projects / thirdparty / gcc.git / commitdiff
