From Jason Turner

[unord.map.syn]

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpdevi4nfg/{from.md → to.md} +17 -13
tmp/tmpdevi4nfg/{from.md → to.md} RENAMED
@@ -1,9 +1,10 @@
1
  ### Header `<unordered_map>` synopsis <a id="unord.map.syn">[[unord.map.syn]]</a>
2
 
3
  ``` cpp
4
- #include <initializer_list>
 
5
 
6
  namespace std {
7
  // [unord.map], class template unordered_map
8
  template<class Key,
9
  class T,
@@ -18,32 +19,35 @@ namespace std {
18
  class Hash = hash<Key>,
19
  class Pred = equal_to<Key>,
20
  class Alloc = allocator<pair<const Key, T>>>
21
  class unordered_multimap;
22
 
 
 
 
 
 
 
 
 
23
  template<class Key, class T, class Hash, class Pred, class Alloc>
24
  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
25
  unordered_map<Key, T, Hash, Pred, Alloc>& y)
26
  noexcept(noexcept(x.swap(y)));
27
 
28
  template<class Key, class T, class Hash, class Pred, class Alloc>
29
  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
30
  unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
31
  noexcept(noexcept(x.swap(y)));
32
 
33
- template <class Key, class T, class Hash, class Pred, class Alloc>
34
- bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
35
- const unordered_map<Key, T, Hash, Pred, Alloc>& b);
36
- template <class Key, class T, class Hash, class Pred, class Alloc>
37
- bool operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
38
- const unordered_map<Key, T, Hash, Pred, Alloc>& b);
39
- template <class Key, class T, class Hash, class Pred, class Alloc>
40
- bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
41
- const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
42
- template <class Key, class T, class Hash, class Pred, class Alloc>
43
- bool operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
44
- const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
45
 
46
  namespace pmr {
47
  template<class Key,
48
  class T,
49
  class Hash = hash<Key>,
 
1
  ### Header `<unordered_map>` synopsis <a id="unord.map.syn">[[unord.map.syn]]</a>
2
 
3
  ``` cpp
4
+ #include <compare> // see [compare.syn]
5
+ #include <initializer_list> // see [initializer.list.syn]
6
 
7
  namespace std {
8
  // [unord.map], class template unordered_map
9
  template<class Key,
10
  class T,
 
19
  class Hash = hash<Key>,
20
  class Pred = equal_to<Key>,
21
  class Alloc = allocator<pair<const Key, T>>>
22
  class unordered_multimap;
23
 
24
+ template<class Key, class T, class Hash, class Pred, class Alloc>
25
+ bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
26
+ const unordered_map<Key, T, Hash, Pred, Alloc>& b);
27
+
28
+ template<class Key, class T, class Hash, class Pred, class Alloc>
29
+ bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
30
+ const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
31
+
32
  template<class Key, class T, class Hash, class Pred, class Alloc>
33
  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
34
  unordered_map<Key, T, Hash, Pred, Alloc>& y)
35
  noexcept(noexcept(x.swap(y)));
36
 
37
  template<class Key, class T, class Hash, class Pred, class Alloc>
38
  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
39
  unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
40
  noexcept(noexcept(x.swap(y)));
41
 
42
+ template<class K, class T, class H, class P, class A, class Predicate>
43
+ typename unordered_map<K, T, H, P, A>::size_type
44
+ erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
45
+
46
+ template<class K, class T, class H, class P, class A, class Predicate>
47
+ typename unordered_multimap<K, T, H, P, A>::size_type
48
+ erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
 
 
 
 
 
49
 
50
  namespace pmr {
51
  template<class Key,
52
  class T,
53
  class Hash = hash<Key>,