[libc++] [P0458] Add map::contains and set::contains for heterogenous lookup missed in a17b1aed.

[curdeius]

Summary

Commit rGa17b1aed added bool contains(const key_type& x) const; methods to associative containers, but didn't add template<class K> bool contains(const K& x) const; for heterogenous lookup.

[curdeius]

libcxx/include/map

1419

Hmmm, just looking at other files and wondering. Should I use _EnableIf?

[• Quuxplusone]

LGTM % whitespace nits.

libcxx/include/map

199–200

Nit: add an extra space before // C++20 on line 199 so that all the comments line up. Ditto line 418.

1419

FWIW I'd say yes, but throughout; so in a separate PR if at all. See for example 199d2ebeed8382071809983f016e482b1d013b62 where I went through and _EnableIf'ed all the deduction guides. We could do the same kind of NFC-commit here. Or we could just say "meh, nvm for now."

libcxx/include/set

162–163

Line 162 is missing a space before contains, if you were trying to get the semicolons to line up. (I care about aligning the comments; I don't care about aligning the semicolons.) Ditto line 367.

809–814

Here and throughout, it would be more consistent with the surrounding style to do the function on one line:

template <typename _K2>
_LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,bool>::type
contains(const _K2& __k) const                 {return find(__k) != end();}

[curdeius]

I'll take care of whitespace changes on the next update/landing.
Thanks for the review.

libcxx/include/map

1419

OK. Noted. I'll do it separately.

libcxx/include/set

162–163

The idea was just to put the same text as in the standard.

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "`P0753R2 <https://wg21.link/P0753R2>`__","LWG","Manipulators for C++ Synchronized Buffered Ostream","Jacksonville","",""
 "`P0754R2 <https://wg21.link/P0754R2>`__","LWG","<version>","Jacksonville","|Complete|","7.0"
 "`P0809R0 <https://wg21.link/P0809R0>`__","LWG","Comparing Unordered Containers","Jacksonville","|Nothing To Do|",""
 "`P0858R0 <https://wg21.link/P0858R0>`__","LWG","Constexpr iterator requirements","Jacksonville","",""
 "`P0905R1 <https://wg21.link/P0905R1>`__","CWG","Symmetry for spaceship","Jacksonville","",""
 "`P0966R1 <https://wg21.link/P0966R1>`__","LWG","``string::reserve``\  Should Not Shrink","Jacksonville","|Complete| [#note-P0966]_","12.0"
 "","","","","",""
 "`P0019R8 <https://wg21.link/P0019R8>`__","LWG","Atomic Ref","Rapperswil","",""
-"`P0458R2 <https://wg21.link/P0458R2>`__","LWG","Checking for Existence of an Element in Associative Containers","Rapperswil","|Complete|",""
+"`P0458R2 <https://wg21.link/P0458R2>`__","LWG","Checking for Existence of an Element in Associative Containers","Rapperswil","|Complete|","13.0"
 "`P0475R1 <https://wg21.link/P0475R1>`__","LWG","LWG 2511: guaranteed copy elision for piecewise construction","Rapperswil","|Complete|",""
 "`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","",""
 "`P0528R3 <https://wg21.link/P0528R3>`__","CWG","The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange","Rapperswil","",""
 "`P0542R5 <https://wg21.link/P0542R5>`__","CWG","Support for contract based programming in C++","Rapperswil","*Removed in Cologne*","n/a"
 "`P0556R3 <https://wg21.link/P0556R3>`__","LWG","Integral power-of-2 operations","Rapperswil","|Complete|","9.0"
 "`P0619R4 <https://wg21.link/P0619R4>`__","LWG","Reviewing Deprecated Facilities of C++17 for C++20","Rapperswil","|Partial| [#note-P0619]_",""
 "`P0646R1 <https://wg21.link/P0646R1>`__","LWG","Improving the Return Value of Erase-Like Algorithms","Rapperswil","|Complete|","10.0"
 "`P0722R3 <https://wg21.link/P0722R3>`__","CWG","Efficient sized delete for variable sized classes","Rapperswil","|Complete|","9.0"

libcxx/include/map

~map();
 
     // map operations:
           iterator find(const key_type& k);
     const_iterator find(const key_type& k) const;
     template<typename K>
         iterator find(const K& x);              // C++14
     template<typename K>
         const_iterator find(const K& x) const;  // C++14
+
     template<typename K>
       size_type count(const K& x) const;        // C++14
     size_type      count(const key_type& k) const;
-        bool contains(const key_type& x) const; // C++20
+
+    bool           contains(const key_type& x) const; // C++20
+    template<class K> bool contains(const K& x) const; // C++20
+
           iterator lower_bound(const key_type& k);
     const_iterator lower_bound(const key_type& k) const;
     template<typename K>
         iterator lower_bound(const K& x);              // C++14
     template<typename K>
         const_iterator lower_bound(const K& x) const;  // C++14
 
           iterator upper_bound(const key_type& k);
public:
 
     // map operations:
           iterator find(const key_type& k);
     const_iterator find(const key_type& k) const;
     template<typename K>
         iterator find(const K& x);              // C++14
     template<typename K>
         const_iterator find(const K& x) const;  // C++14
+
     template<typename K>
       size_type count(const K& x) const;        // C++14
     size_type      count(const key_type& k) const;
-        bool contains(const key_type& x) const; // C++20
+
+    bool           contains(const key_type& x) const; // C++20
+    template<class K> bool contains(const K& x) const; // C++20
+
           iterator lower_bound(const key_type& k);
     const_iterator lower_bound(const key_type& k) const;
     template<typename K>
         iterator lower_bound(const K& x);              // C++14
     template<typename K>
         const_iterator lower_bound(const K& x) const;  // C++14
 
           iterator upper_bound(const key_type& k);
#if _LIBCPP_STD_VER > 11
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
     count(const _K2& __k) const {return __tree_.__count_multi(__k);}
 #endif
 
 #if _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY
     bool contains(const key_type& __k) const {return find(__k) != end();}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+        typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+        contains(const _K2& __k) const {
+      return find(__k) != end();
+    }
 #endif // _LIBCPP_STD_VER > 17
 
     _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
         {return __tree_.lower_bound(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
         {return __tree_.lower_bound(__k);}
#if _LIBCPP_STD_VER > 11
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
     count(const _K2& __k) const {return __tree_.__count_multi(__k);}
 #endif
 
 #if _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY
     bool contains(const key_type& __k) const {return find(__k) != end();}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+        typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+        contains(const _K2& __k) const {
+      return find(__k) != end();
+    }
 #endif // _LIBCPP_STD_VER > 17
 
     _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
         {return __tree_.lower_bound(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
             {return __tree_.lower_bound(__k);}

libcxx/include/set

public:
 
     // set operations:
           iterator find(const key_type& k);
     const_iterator find(const key_type& k) const;
     template<typename K>
         iterator find(const K& x);
     template<typename K>
         const_iterator find(const K& x) const;  // C++14
+
     template<typename K>
         size_type count(const K& x) const;        // C++14
     size_type      count(const key_type& k) const;
-        bool contains(const key_type& x) const; // C++20
+
+    bool           contains(const key_type& x) const; // C++20
+    template<class K> bool contains(const K& x) const; // C++20
+
           iterator lower_bound(const key_type& k);
     const_iterator lower_bound(const key_type& k) const;
     template<typename K>
         iterator lower_bound(const K& x);              // C++14
     template<typename K>
         const_iterator lower_bound(const K& x) const;  // C++14
 
           iterator upper_bound(const key_type& k);
public:
 
     // set operations:
           iterator find(const key_type& k);
     const_iterator find(const key_type& k) const;
     template<typename K>
         iterator find(const K& x);
     template<typename K>
         const_iterator find(const K& x) const;  // C++14
+
     template<typename K>
         size_type count(const K& x) const;      // C++14
     size_type      count(const key_type& k) const;
-        bool contains(const key_type& x) const; // C++20
+
+    bool           contains(const key_type& x) const; // C++20
+    template<class K> bool contains(const K& x) const; // C++20
+
           iterator lower_bound(const key_type& k);
     const_iterator lower_bound(const key_type& k) const;
     template<typename K>
         iterator lower_bound(const K& x);              // C++14
     template<typename K>
         const_iterator lower_bound(const K& x) const;  // C++14
 
           iterator upper_bound(const key_type& k);
#if _LIBCPP_STD_VER > 11
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
     count(const _K2& __k) const                    {return __tree_.__count_multi(__k);}
 #endif
 
 #if _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY
     bool contains(const key_type& __k) const {return find(__k) != end();}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+        typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+        contains(const _K2& __k) const {
+      return find(__k) != end();
+    }
 #endif // _LIBCPP_STD_VER > 17
 
     _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
         {return __tree_.lower_bound(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
         {return __tree_.lower_bound(__k);}
#if _LIBCPP_STD_VER > 11
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
     count(const _K2& __k) const            {return __tree_.__count_multi(__k);}
 #endif
 
 #if _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY
     bool contains(const key_type& __k) const {return find(__k) != end();}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+        typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+        contains(const _K2& __k) const {
+      return find(__k) != end();
+    }
 #endif // _LIBCPP_STD_VER > 17
 
     _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
         {return __tree_.lower_bound(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
             {return __tree_.lower_bound(__k);}

libcxx/test/std/containers/associative/map/map.ops/contains.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
 
 #include <cassert>
 #include <map>
 
 // <map>
 
 // bool contains(const key_type& x) const;
 
 template <typename T, typename P, typename B, typename... Pairs>
 void test(B bad, Pairs... args) {
     T map;
     P pairs[] = {args...};
 
     for (auto& p : pairs) map.insert(p);
     for (auto& p : pairs) assert(map.contains(p.first));
 
     assert(!map.contains(bad));
 }
 
 struct E { int a = 1; double b = 1; char c = 1; };
 
 int main(int, char**)
 {
     {
         test<std::map<char, int>, std::pair<char, int> >(
             'e', std::make_pair('a', 10), std::make_pair('b', 11),
             std::make_pair('c', 12), std::make_pair('d', 13));
 
         test<std::map<char, char>, std::pair<char, char> >(
             'e', std::make_pair('a', 'a'), std::make_pair('b', 'a'),
             std::make_pair('c', 'a'), std::make_pair('d', 'b'));
 
         test<std::map<int, E>, std::pair<int, E> >(
             -1, std::make_pair(1, E{}), std::make_pair(2, E{}),
             std::make_pair(3, E{}), std::make_pair(4, E{}));
     }
     {
         test<std::multimap<char, int>, std::pair<char, int> >(
             'e', std::make_pair('a', 10), std::make_pair('b', 11),
             std::make_pair('c', 12), std::make_pair('d', 13));
 
         test<std::multimap<char, char>, std::pair<char, char> >(
             'e', std::make_pair('a', 'a'), std::make_pair('b', 'a'),
             std::make_pair('c', 'a'), std::make_pair('d', 'b'));
 
         test<std::multimap<int, E>, std::pair<int, E> >(
             -1, std::make_pair(1, E{}), std::make_pair(2, E{}),
             std::make_pair(3, E{}), std::make_pair(4, E{}));
     }
 
     return 0;
 }

libcxx/test/std/containers/associative/map/map.ops/contains_transparent.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
+
+#include <cassert>
+#include <map>
+
+// <map>
+
+// template<class K> bool contains(const K& x) const; // C++20
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int>& lhs,
+                  const std::pair<int, int>& rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int>& lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int>& rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+template <typename Container>
+void test() {
+  Container s{{{2, 1}, 1}, {{1, 2}, 2}, {{1, 3}, 3}, {{1, 4}, 4}, {{2, 2}, 5}};
+
+  assert(s.contains(1));
+  assert(!s.contains(-1));
+}
+
+int main(int, char**) {
+  test<std::map<std::pair<int, int>, int, Comp> >();
+  test<std::multimap<std::pair<int, int>, int, Comp> >();
+
+  return 0;
+}

libcxx/test/std/containers/associative/set/contains_transparent.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
+
+// <set>
+
+// class set
+
+// template<typename K> bool contains(const K& x) const; // C++20
+
+#include <cassert>
+#include <set>
+#include <utility>
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int>& lhs,
+                  const std::pair<int, int>& rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int>& lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int>& rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+template <typename Container>
+void test() {
+  Container s{{2, 1}, {1, 2}, {1, 3}, {1, 4}, {2, 2}};
+
+  assert(s.contains(1));
+  assert(!s.contains(-1));
+}
+
+int main(int, char**) {
+  test<std::set<std::pair<int, int>, Comp> >();
+  test<std::multiset<std::pair<int, int>, Comp> >();
+
+  return 0;
+}