[libcxx] Implement P1679r3 'string contains function' for c++2b

[tschuett]

see https://reviews.llvm.org/D93912

[Fabio]

libcxx/include/string

327

I did not know what the consistency story here should be ... string_view below had constexpr in the synopsis, string didn't. I went with leaving it in, seemed more forward looking

1441–1451

I took the design of forwarding to the string_view functionality from ends_with above

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp

57

I "reused" adapted starts_with tests and added a few contains specific cases

[Fabio]

@tschuett, I see sorry for the noise

[ldionne]

Thanks for your contribution! We need to document how to search for open reviews. I've created some Differential queries that allow seeing everything open for libc++, but I'm unable to make them global (so you can see them too) because I'm not an admin. I'll resume work on that because this duplication of effort is not acceptable.

Can you please abandon the patch so we clear up the queue? Thanks and sorry this happened.

[Fabio]

Of course

[tschuett]

I just wanted to help you!

[ldionne]

We should now have Differential queries that allow searching for open libc++ reviews. If you go to https://reviews.llvm.org/differential/, in the sidebar to the left, you should see Libc++ Open Reviews and Libc++ Open Reviews - Reviews Needed. This should make it easier to find existing work. I'll document it now.

libcxx/include/string

// types:
 
     bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++20
     bool starts_with(charT c) const noexcept;                             // C++20
     bool starts_with(const charT* s) const;                               // C++20
     bool ends_with(basic_string_view<charT, traits> sv) const noexcept;   // C++20
     bool ends_with(charT c) const noexcept;                               // C++20
     bool ends_with(const charT* s) const;                                 // C++20
 
+    constexpr bool contains(basic_string_view sv) const noexcept;         // C++23
+    constexpr bool contains(charT c) const noexcept;                      // C++23
+    constexpr bool contains(const charT* s) const;                        // C++23
+
     bool __invariants() const;
 };
 
 template<class InputIterator,
          class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 basic_string(InputIterator, InputIterator, Allocator = Allocator())
    -> basic_string<typename iterator_traits<InputIterator>::value_type,
                   char_traits<typename iterator_traits<InputIterator>::value_type>,
#if _LIBCPP_STD_VER > 17
     bool ends_with(value_type __c) const _NOEXCEPT
     { return !empty() && _Traits::eq(back(), __c); }
 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool ends_with(const value_type* __s) const _NOEXCEPT
     { return ends_with(__self_view(__s)); }
 #endif
 
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool contains(__self_view __sv) const _NOEXCEPT
+    { return __self_view(data(), size()).contains( __sv); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool contains(_CharT __c) const _NOEXCEPT
+    { return __self_view(data(), size()).contains( __c); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool contains(const _CharT* __s) const _NOEXCEPT
+    { return contains(__self_view(__s)); }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
 
     _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY void __shrink_or_extend(size_type __target_capacity);
 
     _LIBCPP_INLINE_VISIBILITY
     bool __is_long() const _NOEXCEPT

libcxx/include/string_view

class basic_string_view {
 
       constexpr bool starts_with(basic_string_view s) const noexcept; // C++20
       constexpr bool starts_with(charT c) const noexcept;             // C++20
       constexpr bool starts_with(const charT* s) const;               // C++20
       constexpr bool ends_with(basic_string_view s) const noexcept;   // C++20
       constexpr bool ends_with(charT c) const noexcept;               // C++20
       constexpr bool ends_with(const charT* s) const;                 // C++20
 
+      constexpr bool contains(basic_string_view s) const noexcept;    // C++23
+      constexpr bool contains(charT c) const noexcept;                // C++23
+      constexpr bool contains(const charT* s) const;                  // C++23
+
      private:
       const_pointer data_;  // exposition only
       size_type     size_;  // exposition only
     };
 
   // 7.11, Hash support
   template <class T> struct hash;
   template <> struct hash<string_view>;
#if _LIBCPP_STD_VER > 17
     bool ends_with(value_type __c) const _NOEXCEPT
     { return !empty() && _Traits::eq(back(), __c); }
 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool ends_with(const value_type* __s) const _NOEXCEPT
     { return ends_with(basic_string_view(__s)); }
 #endif
 
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool contains(basic_string_view __s) const _NOEXCEPT
+    { return find(__s) != npos; }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool contains(_CharT __c) const _NOEXCEPT
+    { return find(__c) != npos; }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool contains(const _CharT* __s) const _NOEXCEPT
+    { return contains(basic_string_view(__s)); }
+#endif
+
+
 private:
     const   value_type* __data;
     size_type           __size;
 };
 
 
 // [string.view.comparison]
 // operator ==

libcxx/include/version

 #   define __cpp_lib_math_constants                     201907L
 # endif
 // # define __cpp_lib_ranges                               201811L
 # define __cpp_lib_span                                 202002L
 // # define __cpp_lib_three_way_comparison                 201711L
 # define __cpp_lib_to_array                             201907L
 #endif
 
+#if _LIBCPP_STD_VER > 20
+# define __cpp_lib_string_contains                      202101L
+#endif 
+
 #endif // _LIBCPP_VERSIONH

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++2a
+
+// <string>
+
+//   bool contains(charT x) const noexcept;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    typedef std::string S;
+    S s1{};
+    S s2{"abcde", 5};
+
+    ASSERT_NOEXCEPT(s1.contains('e'));
+
+    assert(!s1.contains('a'));
+    assert(!s1.contains('x'));
+    
+    assert( s2.contains('a'));
+    assert( s2.contains('c'));
+    assert( s2.contains('e'));
+    assert(!s2.contains('x'));
+  }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++2a
+
+// <string>
+
+//   bool contains(const CharT *x) const;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    typedef std::string S;
+    const char* s = "abcde";
+    S s0{};
+    S s1{s, 1};
+    S s2{s, 2};
+    //     S  s3 { s, 3 };
+    //     S  s4 { s, 4 };
+    S s5{s, 5};
+    S sNot{"def", 3};
+
+    LIBCPP_ASSERT_NOEXCEPT(s0.contains(""));
+
+    assert( s0.contains(""));
+    assert(!s0.contains("a"));
+
+    assert( s1.contains(""));
+    assert( s1.contains("a"));
+    assert(!s1.contains("ab"));
+    assert(!s1.contains("abc"));
+    assert(!s1.contains("abcd"));
+    assert(!s1.contains("abcde"));
+    assert(!s1.contains("def"));
+
+    assert( s2.contains(""));
+    assert( s2.contains("a"));
+    assert( s2.contains("b"));
+    assert( s2.contains("ab"));
+    assert(!s2.contains("abc"));
+    assert(!s2.contains("abcd"));
+    assert(!s2.contains("abcde"));
+    assert(!s2.contains("def"));
+
+    assert( s5.contains(""));
+    assert( s5.contains("a"));
+    assert( s5.contains("b"));
+    assert( s5.contains("ab"));
+    assert( s5.contains("bc"));
+    assert( s5.contains("abc"));
+    assert( s5.contains("bcd"));
+    assert( s5.contains("cde"));
+    assert( s5.contains("abcd"));
+    assert( s5.contains("bcde"));
+    assert( s5.contains("abcde"));
+    assert(!s5.contains("def"));
+
+    assert( sNot.contains(""));
+    assert(!sNot.contains("a"));
+    assert(!sNot.contains("ab"));
+    assert(!sNot.contains("abc"));
+    assert(!sNot.contains("abcd"));
+    assert(!sNot.contains("abcde"));
+    assert( sNot.contains("def"));
+  }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++2a
+
+// <string>
+
+//   bool contains(string_view x) const noexcept;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    typedef std::string S;
+    typedef std::string_view SV;
+    const char* s = "abcde";
+
+    S s0;
+    S s1{s, 1};
+    S s2{s, 2};
+    //  S   s3  { s, 3 };
+    //  S   s4  { s, 4 };
+    S s5{s, 5};
+    S sNot{"def", 3};
+
+    SV sv0;
+    SV sv1{s, 1};
+    SV sv2{s, 2};
+    SV sv3{s, 3};
+    SV sv4{s, 4};
+    SV sv5{s, 5};
+
+    SV sv3_s0 = sv5.substr(0, 3);
+    SV sv3_s1 = sv5.substr(1, 3);
+    SV sv3_s2 = sv5.substr(2, 3);
+
+    SV svNot{"def", 3};
+
+    ASSERT_NOEXCEPT(s0.contains(sv0));
+
+    assert( s0.contains(sv0));
+    assert(!s0.contains(sv1));
+
+    assert( s1.contains(sv0));
+    assert( s1.contains(sv1));
+    assert(!s1.contains(sv2));
+    assert(!s1.contains(sv3));
+    assert(!s1.contains(sv4));
+    assert(!s1.contains(sv5));
+    assert(!s1.contains(svNot));
+
+    assert( s2.contains(sv0));
+    assert( s2.contains(sv1));
+    assert( s2.contains(sv2));
+    assert(!s2.contains(sv3));
+    assert(!s2.contains(sv4));
+    assert(!s2.contains(sv5));
+    assert(!s2.contains(svNot));
+
+    assert( s5.contains(sv3_s0));
+    assert( s5.contains(sv3_s1));
+    assert( s5.contains(sv3_s2));
+
+    assert( sNot.contains(sv0));
+    assert(!sNot.contains(sv1));
+    assert(!sNot.contains(sv2));
+    assert(!sNot.contains(sv3));
+    assert(!sNot.contains(sv4));
+    assert(!sNot.contains(sv5));
+    assert( sNot.contains(svNot));
+  }
+
+  return 0;
+}

libcxx/test/std/strings/string.view/string_view.contains/contains.ptr.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++2a
+
+// <string_view>
+
+//   bool contains(const CharT *x) const;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    typedef std::string_view SV;
+    const char* s = "abcde";
+    SV s0{};
+    SV s1{s, 1};
+    SV s2{s, 2};
+    SV s5{s, 5};
+    SV sNot{"def", 3};
+
+    LIBCPP_ASSERT_NOEXCEPT(s0.contains(""));
+
+    assert(s0.contains(""));
+    assert(!s0.contains("a"));
+
+    assert( s1.contains(""));
+    assert( s1.contains("a"));
+    assert(!s1.contains("ab"));
+    assert(!s1.contains("abc"));
+    assert(!s1.contains("abcd"));
+    assert(!s1.contains("abcde"));
+    assert(!s1.contains("def"));
+
+    assert( s2.contains(""));
+    assert( s2.contains("a"));
+    assert( s2.contains("b"));
+    assert( s2.contains("ab"));
+    assert(!s2.contains("abc"));
+    assert(!s2.contains("abcd"));
+    assert(!s2.contains("abcde"));
+    assert(!s2.contains("def"));
+
+    assert( s5.contains(""));
+    assert( s5.contains("a"));
+    assert( s5.contains("b"));
+    assert( s5.contains("ab"));
+    assert( s5.contains("bc"));
+    assert( s5.contains("abc"));
+    assert( s5.contains("bcd"));
+    assert( s5.contains("cde"));
+    assert( s5.contains("abcd"));
+    assert( s5.contains("bcde"));
+    assert( s5.contains("abcde"));
+    assert(!s5.contains("def"));
+
+    assert( sNot.contains(""));
+    assert(!sNot.contains("a"));
+    assert(!sNot.contains("ab"));
+    assert(!sNot.contains("abc"));
+    assert(!sNot.contains("abcd"));
+    assert(!sNot.contains("abcde"));
+    assert( sNot.contains("def"));
+  }
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_string_udls",
     "values": { "c++14": 201304 },
     "headers": ["string"],
   }, {
     "name": "__cpp_lib_string_view",
     "values": { "c++17": 201606 },
     "headers": ["string", "string_view"],
   }, {
+    "name": "__cpp_lib_string_contains",
+    "values": { "c++23": 202101 },
+    "headers": ["string", "string_view"],
+  }, {
     "name": "__cpp_lib_three_way_comparison",
     "values": { "c++20": 201711 },
     "headers": ["compare"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_to_array",
     "values": { "c++20": 201907 },
     "headers": ["array"],

libcxx/utils/libcxx/test/params.py

 #===----------------------------------------------------------------------===##
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
 from libcxx.test.dsl import *
 
-_allStandards = ['c++03', 'c++11', 'c++14', 'c++17', 'c++2a']
+_allStandards = ['c++03', 'c++11', 'c++14', 'c++17', 'c++2a', 'c++2b']
 _warningFlags = [
   '-Werror',
   '-Wall',
   '-Wextra',
   '-Wshadow',
   '-Wno-unused-command-line-argument',
   '-Wno-attributes',
   '-Wno-pessimizing-move',