1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <unordered_map> 11 12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 13 // class Alloc = allocator<pair<const Key, T>>> 14 // class unordered_multimap 15 16 // local_iterator begin (size_type n); 17 // local_iterator end (size_type n); 18 // const_local_iterator begin (size_type n) const; 19 // const_local_iterator end (size_type n) const; 20 // const_local_iterator cbegin(size_type n) const; 21 // const_local_iterator cend (size_type n) const; 22 23 #include <unordered_map> 24 #include <string> 25 #include <cassert> 26 27 #include "min_allocator.h" 28 29 int main() 30 { 31 { 32 typedef std::unordered_multimap<int, std::string> C; 33 typedef std::pair<int, std::string> P; 34 typedef C::local_iterator I; 35 P a[] = 36 { 37 P(1, "one"), 38 P(2, "two"), 39 P(3, "three"), 40 P(4, "four"), 41 P(1, "four"), 42 P(2, "four"), 43 }; 44 C c(a, a + sizeof(a)/sizeof(a[0])); 45 assert(c.bucket_count() >= 7); 46 C::size_type b = c.bucket(0); 47 I i = c.begin(b); 48 I j = c.end(b); 49 assert(std::distance(i, j) == 0); 50 51 b = c.bucket(1); 52 i = c.begin(b); 53 j = c.end(b); 54 assert(std::distance(i, j) == 2); 55 assert(i->first == 1); 56 assert(i->second == "one"); 57 ++i; 58 assert(i->first == 1); 59 assert(i->second == "four"); 60 61 b = c.bucket(2); 62 i = c.begin(b); 63 j = c.end(b); 64 assert(std::distance(i, j) == 2); 65 assert(i->first == 2); 66 assert(i->second == "two"); 67 ++i; 68 assert(i->first == 2); 69 assert(i->second == "four"); 70 71 b = c.bucket(3); 72 i = c.begin(b); 73 j = c.end(b); 74 assert(std::distance(i, j) == 1); 75 assert(i->first == 3); 76 assert(i->second == "three"); 77 78 b = c.bucket(4); 79 i = c.begin(b); 80 j = c.end(b); 81 assert(std::distance(i, j) == 1); 82 assert(i->first == 4); 83 assert(i->second == "four"); 84 85 b = c.bucket(5); 86 i = c.begin(b); 87 j = c.end(b); 88 assert(std::distance(i, j) == 0); 89 90 b = c.bucket(6); 91 i = c.begin(b); 92 j = c.end(b); 93 assert(std::distance(i, j) == 0); 94 } 95 { 96 typedef std::unordered_multimap<int, std::string> C; 97 typedef std::pair<int, std::string> P; 98 typedef C::const_local_iterator I; 99 P a[] = 100 { 101 P(1, "one"), 102 P(2, "two"), 103 P(3, "three"), 104 P(4, "four"), 105 P(1, "four"), 106 P(2, "four"), 107 }; 108 const C c(a, a + sizeof(a)/sizeof(a[0])); 109 assert(c.bucket_count() >= 7); 110 C::size_type b = c.bucket(0); 111 I i = c.begin(b); 112 I j = c.end(b); 113 assert(std::distance(i, j) == 0); 114 115 b = c.bucket(1); 116 i = c.begin(b); 117 j = c.end(b); 118 assert(std::distance(i, j) == 2); 119 assert(i->first == 1); 120 assert(i->second == "one"); 121 ++i; 122 assert(i->first == 1); 123 assert(i->second == "four"); 124 125 b = c.bucket(2); 126 i = c.begin(b); 127 j = c.end(b); 128 assert(std::distance(i, j) == 2); 129 assert(i->first == 2); 130 assert(i->second == "two"); 131 ++i; 132 assert(i->first == 2); 133 assert(i->second == "four"); 134 135 b = c.bucket(3); 136 i = c.begin(b); 137 j = c.end(b); 138 assert(std::distance(i, j) == 1); 139 assert(i->first == 3); 140 assert(i->second == "three"); 141 142 b = c.bucket(4); 143 i = c.begin(b); 144 j = c.end(b); 145 assert(std::distance(i, j) == 1); 146 assert(i->first == 4); 147 assert(i->second == "four"); 148 149 b = c.bucket(5); 150 i = c.begin(b); 151 j = c.end(b); 152 assert(std::distance(i, j) == 0); 153 154 b = c.bucket(6); 155 i = c.begin(b); 156 j = c.end(b); 157 assert(std::distance(i, j) == 0); 158 } 159 { 160 typedef std::unordered_multimap<int, std::string> C; 161 typedef std::pair<int, std::string> P; 162 typedef C::const_local_iterator I; 163 P a[] = 164 { 165 P(1, "one"), 166 P(2, "two"), 167 P(3, "three"), 168 P(4, "four"), 169 P(1, "four"), 170 P(2, "four"), 171 }; 172 C c(a, a + sizeof(a)/sizeof(a[0])); 173 assert(c.bucket_count() >= 7); 174 C::size_type b = c.bucket(0); 175 I i = c.cbegin(b); 176 I j = c.cend(b); 177 assert(std::distance(i, j) == 0); 178 179 b = c.bucket(1); 180 i = c.cbegin(b); 181 j = c.cend(b); 182 assert(std::distance(i, j) == 2); 183 assert(i->first == 1); 184 assert(i->second == "one"); 185 ++i; 186 assert(i->first == 1); 187 assert(i->second == "four"); 188 189 b = c.bucket(2); 190 i = c.cbegin(b); 191 j = c.cend(b); 192 assert(std::distance(i, j) == 2); 193 assert(i->first == 2); 194 assert(i->second == "two"); 195 ++i; 196 assert(i->first == 2); 197 assert(i->second == "four"); 198 199 b = c.bucket(3); 200 i = c.cbegin(b); 201 j = c.cend(b); 202 assert(std::distance(i, j) == 1); 203 assert(i->first == 3); 204 assert(i->second == "three"); 205 206 b = c.bucket(4); 207 i = c.cbegin(b); 208 j = c.cend(b); 209 assert(std::distance(i, j) == 1); 210 assert(i->first == 4); 211 assert(i->second == "four"); 212 213 b = c.bucket(5); 214 i = c.cbegin(b); 215 j = c.cend(b); 216 assert(std::distance(i, j) == 0); 217 218 b = c.bucket(6); 219 i = c.cbegin(b); 220 j = c.cend(b); 221 assert(std::distance(i, j) == 0); 222 } 223 { 224 typedef std::unordered_multimap<int, std::string> C; 225 typedef std::pair<int, std::string> P; 226 typedef C::const_local_iterator I; 227 P a[] = 228 { 229 P(1, "one"), 230 P(2, "two"), 231 P(3, "three"), 232 P(4, "four"), 233 P(1, "four"), 234 P(2, "four"), 235 }; 236 const C c(a, a + sizeof(a)/sizeof(a[0])); 237 assert(c.bucket_count() >= 7); 238 C::size_type b = c.bucket(0); 239 I i = c.cbegin(b); 240 I j = c.cend(b); 241 assert(std::distance(i, j) == 0); 242 243 b = c.bucket(1); 244 i = c.cbegin(b); 245 j = c.cend(b); 246 assert(std::distance(i, j) == 2); 247 assert(i->first == 1); 248 assert(i->second == "one"); 249 ++i; 250 assert(i->first == 1); 251 assert(i->second == "four"); 252 253 b = c.bucket(2); 254 i = c.cbegin(b); 255 j = c.cend(b); 256 assert(std::distance(i, j) == 2); 257 assert(i->first == 2); 258 assert(i->second == "two"); 259 ++i; 260 assert(i->first == 2); 261 assert(i->second == "four"); 262 263 b = c.bucket(3); 264 i = c.cbegin(b); 265 j = c.cend(b); 266 assert(std::distance(i, j) == 1); 267 assert(i->first == 3); 268 assert(i->second == "three"); 269 270 b = c.bucket(4); 271 i = c.cbegin(b); 272 j = c.cend(b); 273 assert(std::distance(i, j) == 1); 274 assert(i->first == 4); 275 assert(i->second == "four"); 276 277 b = c.bucket(5); 278 i = c.cbegin(b); 279 j = c.cend(b); 280 assert(std::distance(i, j) == 0); 281 282 b = c.bucket(6); 283 i = c.cbegin(b); 284 j = c.cend(b); 285 assert(std::distance(i, j) == 0); 286 } 287 #if __cplusplus >= 201103L 288 { 289 typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, 290 min_allocator<std::pair<const int, std::string>>> C; 291 typedef std::pair<int, std::string> P; 292 typedef C::local_iterator I; 293 P a[] = 294 { 295 P(1, "one"), 296 P(2, "two"), 297 P(3, "three"), 298 P(4, "four"), 299 P(1, "four"), 300 P(2, "four"), 301 }; 302 C c(a, a + sizeof(a)/sizeof(a[0])); 303 assert(c.bucket_count() >= 7); 304 C::size_type b = c.bucket(0); 305 I i = c.begin(b); 306 I j = c.end(b); 307 assert(std::distance(i, j) == 0); 308 309 b = c.bucket(1); 310 i = c.begin(b); 311 j = c.end(b); 312 assert(std::distance(i, j) == 2); 313 assert(i->first == 1); 314 assert(i->second == "one"); 315 ++i; 316 assert(i->first == 1); 317 assert(i->second == "four"); 318 319 b = c.bucket(2); 320 i = c.begin(b); 321 j = c.end(b); 322 assert(std::distance(i, j) == 2); 323 assert(i->first == 2); 324 assert(i->second == "two"); 325 ++i; 326 assert(i->first == 2); 327 assert(i->second == "four"); 328 329 b = c.bucket(3); 330 i = c.begin(b); 331 j = c.end(b); 332 assert(std::distance(i, j) == 1); 333 assert(i->first == 3); 334 assert(i->second == "three"); 335 336 b = c.bucket(4); 337 i = c.begin(b); 338 j = c.end(b); 339 assert(std::distance(i, j) == 1); 340 assert(i->first == 4); 341 assert(i->second == "four"); 342 343 b = c.bucket(5); 344 i = c.begin(b); 345 j = c.end(b); 346 assert(std::distance(i, j) == 0); 347 348 b = c.bucket(6); 349 i = c.begin(b); 350 j = c.end(b); 351 assert(std::distance(i, j) == 0); 352 } 353 { 354 typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, 355 min_allocator<std::pair<const int, std::string>>> C; 356 typedef std::pair<int, std::string> P; 357 typedef C::const_local_iterator I; 358 P a[] = 359 { 360 P(1, "one"), 361 P(2, "two"), 362 P(3, "three"), 363 P(4, "four"), 364 P(1, "four"), 365 P(2, "four"), 366 }; 367 const C c(a, a + sizeof(a)/sizeof(a[0])); 368 assert(c.bucket_count() >= 7); 369 C::size_type b = c.bucket(0); 370 I i = c.begin(b); 371 I j = c.end(b); 372 assert(std::distance(i, j) == 0); 373 374 b = c.bucket(1); 375 i = c.begin(b); 376 j = c.end(b); 377 assert(std::distance(i, j) == 2); 378 assert(i->first == 1); 379 assert(i->second == "one"); 380 ++i; 381 assert(i->first == 1); 382 assert(i->second == "four"); 383 384 b = c.bucket(2); 385 i = c.begin(b); 386 j = c.end(b); 387 assert(std::distance(i, j) == 2); 388 assert(i->first == 2); 389 assert(i->second == "two"); 390 ++i; 391 assert(i->first == 2); 392 assert(i->second == "four"); 393 394 b = c.bucket(3); 395 i = c.begin(b); 396 j = c.end(b); 397 assert(std::distance(i, j) == 1); 398 assert(i->first == 3); 399 assert(i->second == "three"); 400 401 b = c.bucket(4); 402 i = c.begin(b); 403 j = c.end(b); 404 assert(std::distance(i, j) == 1); 405 assert(i->first == 4); 406 assert(i->second == "four"); 407 408 b = c.bucket(5); 409 i = c.begin(b); 410 j = c.end(b); 411 assert(std::distance(i, j) == 0); 412 413 b = c.bucket(6); 414 i = c.begin(b); 415 j = c.end(b); 416 assert(std::distance(i, j) == 0); 417 } 418 { 419 typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, 420 min_allocator<std::pair<const int, std::string>>> C; 421 typedef std::pair<int, std::string> P; 422 typedef C::const_local_iterator I; 423 P a[] = 424 { 425 P(1, "one"), 426 P(2, "two"), 427 P(3, "three"), 428 P(4, "four"), 429 P(1, "four"), 430 P(2, "four"), 431 }; 432 C c(a, a + sizeof(a)/sizeof(a[0])); 433 assert(c.bucket_count() >= 7); 434 C::size_type b = c.bucket(0); 435 I i = c.cbegin(b); 436 I j = c.cend(b); 437 assert(std::distance(i, j) == 0); 438 439 b = c.bucket(1); 440 i = c.cbegin(b); 441 j = c.cend(b); 442 assert(std::distance(i, j) == 2); 443 assert(i->first == 1); 444 assert(i->second == "one"); 445 ++i; 446 assert(i->first == 1); 447 assert(i->second == "four"); 448 449 b = c.bucket(2); 450 i = c.cbegin(b); 451 j = c.cend(b); 452 assert(std::distance(i, j) == 2); 453 assert(i->first == 2); 454 assert(i->second == "two"); 455 ++i; 456 assert(i->first == 2); 457 assert(i->second == "four"); 458 459 b = c.bucket(3); 460 i = c.cbegin(b); 461 j = c.cend(b); 462 assert(std::distance(i, j) == 1); 463 assert(i->first == 3); 464 assert(i->second == "three"); 465 466 b = c.bucket(4); 467 i = c.cbegin(b); 468 j = c.cend(b); 469 assert(std::distance(i, j) == 1); 470 assert(i->first == 4); 471 assert(i->second == "four"); 472 473 b = c.bucket(5); 474 i = c.cbegin(b); 475 j = c.cend(b); 476 assert(std::distance(i, j) == 0); 477 478 b = c.bucket(6); 479 i = c.cbegin(b); 480 j = c.cend(b); 481 assert(std::distance(i, j) == 0); 482 } 483 { 484 typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, 485 min_allocator<std::pair<const int, std::string>>> C; 486 typedef std::pair<int, std::string> P; 487 typedef C::const_local_iterator I; 488 P a[] = 489 { 490 P(1, "one"), 491 P(2, "two"), 492 P(3, "three"), 493 P(4, "four"), 494 P(1, "four"), 495 P(2, "four"), 496 }; 497 const C c(a, a + sizeof(a)/sizeof(a[0])); 498 assert(c.bucket_count() >= 7); 499 C::size_type b = c.bucket(0); 500 I i = c.cbegin(b); 501 I j = c.cend(b); 502 assert(std::distance(i, j) == 0); 503 504 b = c.bucket(1); 505 i = c.cbegin(b); 506 j = c.cend(b); 507 assert(std::distance(i, j) == 2); 508 assert(i->first == 1); 509 assert(i->second == "one"); 510 ++i; 511 assert(i->first == 1); 512 assert(i->second == "four"); 513 514 b = c.bucket(2); 515 i = c.cbegin(b); 516 j = c.cend(b); 517 assert(std::distance(i, j) == 2); 518 assert(i->first == 2); 519 assert(i->second == "two"); 520 ++i; 521 assert(i->first == 2); 522 assert(i->second == "four"); 523 524 b = c.bucket(3); 525 i = c.cbegin(b); 526 j = c.cend(b); 527 assert(std::distance(i, j) == 1); 528 assert(i->first == 3); 529 assert(i->second == "three"); 530 531 b = c.bucket(4); 532 i = c.cbegin(b); 533 j = c.cend(b); 534 assert(std::distance(i, j) == 1); 535 assert(i->first == 4); 536 assert(i->second == "four"); 537 538 b = c.bucket(5); 539 i = c.cbegin(b); 540 j = c.cend(b); 541 assert(std::distance(i, j) == 0); 542 543 b = c.bucket(6); 544 i = c.cbegin(b); 545 j = c.cend(b); 546 assert(std::distance(i, j) == 0); 547 } 548 #endif 549 } 550
