1bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 2bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 3f5256e16dfc425c1d466f6308d4026d529ce9e0bHoward Hinnant// The LLVM Compiler Infrastructure 4bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 5b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// This file is dual licensed under the MIT and the University of Illinois Open 6b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// Source Licenses. See LICENSE.TXT for details. 7bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 8bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 9bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 10bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// <unordered_map> 11bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 12bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 13bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// class Alloc = allocator<pair<const Key, T>>> 14bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// class unordered_multimap 15bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 16bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// size_type erase(const key_type& k); 17bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 18bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <unordered_map> 19bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <string> 20bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <cassert> 2198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej#include <cstddef> 22bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 23061d0cc4db18d17bf01ed14c5db0be098205bd47Marshall Clow#include "min_allocator.h" 247a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 25d24c465beaec2fe9a0e365e6379cd5d3acaeb2caEric Fiselier#if TEST_STD_VER >= 11 266dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clowtemplate <typename Unordered> 276dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clowbool only_deletions ( const Unordered &whole, const Unordered &part ) { 286dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow typename Unordered::const_iterator w = whole.begin(); 296dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow typename Unordered::const_iterator p = part.begin(); 3084acb1ec3f7d5e0f37d7176697c2fa876c413407Eric Fiselier 316dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow while ( w != whole.end () && p != part.end()) { 326dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow if ( *w == *p ) 336dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow p++; 346dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow w++; 356dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow } 366dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow 376dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow return p == part.end(); 386dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow} 396dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow#endif 406dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow 41bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantint main() 42bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 43bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 44bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::unordered_multimap<int, std::string> C; 45bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<int, std::string> P; 46bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P a[] = 47bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 48bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "one"), 49bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "two"), 50bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(3, "three"), 51bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(4, "four"), 52bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(1, "four"), 53bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant P(2, "four"), 54bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant }; 55bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C c(a, a + sizeof(a)/sizeof(a[0])); 56bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(5) == 0); 57bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 6); 58bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef std::pair<C::const_iterator, C::const_iterator> Eq; 59bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant Eq eq = c.equal_range(1); 60bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 2); 61bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant C::const_iterator k = eq.first; 62bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 63bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "one"); 64bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++k; 65bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 66bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 67bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(2); 68bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 2); 69bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 70bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 2); 71bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "two"); 72bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++k; 73bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 2); 74bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 75bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 76bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 77bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 78bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 3); 79bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "three"); 80bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(4); 81bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 82bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 83bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 4); 84bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 8598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 8698605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 87bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 88bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(2) == 2); 89bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 4); 90bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(1); 91bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 2); 92bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 93bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 94bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "one"); 95bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++k; 96bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 97bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 98bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 99bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 100bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 101bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 3); 102bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "three"); 103bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(4); 104bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 105bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 106bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 4); 107bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 10898605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 10998605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 110bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 111bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(2) == 0); 112bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 4); 113bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(1); 114bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 2); 115bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 116bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 117bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "one"); 118bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++k; 119bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 120bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 121bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 122bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 123bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 124bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 3); 125bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "three"); 126bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(4); 127bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 128bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 129bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 4); 130bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 13198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 13298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 133bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 134bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(4) == 1); 135bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 3); 136bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(1); 137bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 2); 138bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 139bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 140bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "one"); 141bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++k; 142bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 143bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 144bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 145bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 146bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 147bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 3); 148bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "three"); 14998605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 15098605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 151bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 152bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(4) == 0); 153bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 3); 154bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(1); 155bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 2); 156bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 157bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 158bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "one"); 159bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ++k; 160bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 1); 161bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "four"); 162bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 163bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 164bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 165bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 3); 166bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "three"); 16798605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 16898605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 169bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 170bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(1) == 2); 171bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 1); 172bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 173bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 174bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 175bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 3); 176bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "three"); 17798605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 17898605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 179bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 180bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(1) == 0); 181bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 1); 182bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 183bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 1); 184bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant k = eq.first; 185bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->first == 3); 186bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(k->second == "three"); 18798605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 18898605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 189bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 190bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(3) == 1); 191bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 0); 192bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 193bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 0); 19498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 19598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 196bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 197bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.erase(3) == 0); 198bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(c.size() == 0); 199bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant eq = c.equal_range(3); 200bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(std::distance(eq.first, eq.second) == 0); 20198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 20298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 203bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 204d24c465beaec2fe9a0e365e6379cd5d3acaeb2caEric Fiselier#if TEST_STD_VER >= 11 2057a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 2067a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, 2077a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant min_allocator<std::pair<const int, std::string>>> C; 2087a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::pair<int, std::string> P; 2097a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P a[] = 2107a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant { 2117a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1, "one"), 2127a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2, "two"), 2137a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(3, "three"), 2147a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(4, "four"), 2157a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(1, "four"), 2167a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant P(2, "four"), 2177a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant }; 2187a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C c(a, a + sizeof(a)/sizeof(a[0])); 2197a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(5) == 0); 2207a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 6); 2217a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant typedef std::pair<C::const_iterator, C::const_iterator> Eq; 2227a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant Eq eq = c.equal_range(1); 2237a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 2); 2247a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant C::const_iterator k = eq.first; 2257a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 2267a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "one"); 2277a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant ++k; 2287a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 2297a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 2307a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(2); 2317a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 2); 2327a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2337a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 2); 2347a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "two"); 2357a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant ++k; 2367a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 2); 2377a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 2387a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 2397a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 2407a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2417a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 3); 2427a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "three"); 2437a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(4); 2447a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 2457a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2467a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 4); 2477a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 24898605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 24998605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 2507a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 2517a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(2) == 2); 2527a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 4); 2537a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(1); 2547a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 2); 2557a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2567a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 2577a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "one"); 2587a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant ++k; 2597a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 2607a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 2617a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 2627a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 2637a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2647a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 3); 2657a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "three"); 2667a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(4); 2677a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 2687a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2697a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 4); 2707a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 27198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 27298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 2737a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 2747a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(2) == 0); 2757a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 4); 2767a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(1); 2777a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 2); 2787a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2797a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 2807a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "one"); 2817a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant ++k; 2827a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 2837a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 2847a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 2857a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 2867a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2877a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 3); 2887a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "three"); 2897a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(4); 2907a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 2917a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 2927a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 4); 2937a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 29498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 29598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 2967a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 2977a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(4) == 1); 2987a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 3); 2997a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(1); 3007a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 2); 3017a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 3027a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 3037a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "one"); 3047a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant ++k; 3057a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 3067a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 3077a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 3087a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 3097a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 3107a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 3); 3117a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "three"); 31298605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 31398605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 3147a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 3157a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(4) == 0); 3167a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 3); 3177a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(1); 3187a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 2); 3197a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 3207a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 3217a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "one"); 3227a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant ++k; 3237a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 1); 3247a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "four"); 3257a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 3267a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 3277a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 3287a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 3); 3297a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "three"); 33098605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 33198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 3327a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 3337a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(1) == 2); 3347a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 1); 3357a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 3367a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 3377a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 3387a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 3); 3397a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "three"); 34098605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 34198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 3427a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 3437a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(1) == 0); 3447a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 1); 3457a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 3467a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 1); 3477a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant k = eq.first; 3487a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->first == 3); 3497a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(k->second == "three"); 35098605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 35198605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 3527a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 3537a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(3) == 1); 3547a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 0); 3557a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 3567a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 0); 35798605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 35898605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 3597a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant 3607a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.erase(3) == 0); 3617a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(c.size() == 0); 3627a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant eq = c.equal_range(3); 3637a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant assert(std::distance(eq.first, eq.second) == 0); 36498605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 36598605940df7a54649618c541b972a308cccaade9Stephan T. Lavavej assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 3667a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant } 3676dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow { 3686dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow typedef std::unordered_multimap<int, int> C; 3696dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow C m, m2; 3706dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow for ( int i = 0; i < 10; ++i ) { 3716dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow for (int j = 0; j < 2; ++j ) { 3726dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow m.insert (std::make_pair(i,j)); 3736dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow m2.insert(std::make_pair(i,j)); 3746dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow } 3756dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow } 37684acb1ec3f7d5e0f37d7176697c2fa876c413407Eric Fiselier 3776dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow C::iterator i = m2.begin(); 3786dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow int ctr = 0; 3796dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow while (i != m2.end()) { 3806dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow if (ctr++ % 2 == 0) 3816dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow m2.erase(i++); 3826dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow else 3836dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow ++i; 3846dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow } 3856dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow 3866dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow assert (only_deletions (m, m2)); 3876dbaaa99a880f356277525c8630491b80d6d2e56Marshall Clow } 3887a6b7cedcb3359ad7d77e355b02ab982d9d2b25bHoward Hinnant#endif 389bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 390