1 // -*- C++ -*- 2 3 // Copyright (C) 2005-2018 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the terms 7 // of the GNU General Public License as published by the Free Software 8 // Foundation; either version 3, or (at your option) any later 9 // version. 10 11 // This library is distributed in the hope that it will be useful, but 12 // WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 // General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. 26 27 // Permission to use, copy, modify, sell, and distribute this software 28 // is hereby granted without fee, provided that the above copyright 29 // notice appears in all copies, and that both that copyright notice 30 // and this permission notice appear in supporting documentation. None 31 // of the above authors, nor IBM Haifa Research Laboratories, make any 32 // representation about the suitability of this software for any 33 // purpose. It is provided "as is" without express or implied 34 // warranty. 35 36 /** 37 * @file cc_hash_table_map_/cc_ht_map_.hpp 38 * Contains an implementation class for cc_ht_map_. 39 */ 40 41 #include <utility> 42 #include <iterator> 43 #include <ext/pb_ds/detail/cond_dealtor.hpp> 44 #include <ext/pb_ds/tag_and_trait.hpp> 45 #include <ext/pb_ds/detail/hash_fn/ranged_hash_fn.hpp> 46 #include <ext/pb_ds/detail/types_traits.hpp> 47 #include <ext/pb_ds/exception.hpp> 48 #include <ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp> 49 #ifdef _GLIBCXX_DEBUG 50 #include <ext/pb_ds/detail/debug_map_base.hpp> 51 #endif 52 #ifdef PB_DS_HT_MAP_TRACE_ 53 #include <iostream> 54 #endif 55 #include <debug/debug.h> 56 57 namespace __gnu_pbds 58 { 59 namespace detail 60 { 61 #ifdef PB_DS_DATA_TRUE_INDICATOR 62 #define PB_DS_CC_HASH_NAME cc_ht_map 63 #endif 64 65 #ifdef PB_DS_DATA_FALSE_INDICATOR 66 #define PB_DS_CC_HASH_NAME cc_ht_set 67 #endif 68 69 #define PB_DS_CLASS_T_DEC \ 70 template<typename Key, typename Mapped, typename Hash_Fn, \ 71 typename Eq_Fn, typename _Alloc, bool Store_Hash, \ 72 typename Comb_Hash_Fn, typename Resize_Policy> 73 74 #define PB_DS_CLASS_C_DEC \ 75 PB_DS_CC_HASH_NAME<Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, \ 76 Store_Hash, Comb_Hash_Fn, Resize_Policy> 77 78 #define PB_DS_HASH_EQ_FN_C_DEC \ 79 hash_eq_fn<Key, Eq_Fn, _Alloc, Store_Hash> 80 81 #define PB_DS_RANGED_HASH_FN_C_DEC \ 82 ranged_hash_fn<Key, Hash_Fn, _Alloc, Comb_Hash_Fn, Store_Hash> 83 84 #define PB_DS_CC_HASH_TRAITS_BASE \ 85 types_traits<Key, Mapped, _Alloc, Store_Hash> 86 87 #ifdef _GLIBCXX_DEBUG 88 #define PB_DS_DEBUG_MAP_BASE_C_DEC \ 89 debug_map_base<Key, Eq_Fn, \ 90 typename _Alloc::template rebind<Key>::other::const_reference> 91 #endif 92 93 94 /** 95 * A collision-chaining hash-based container. 96 * 97 * 98 * @ingroup hash-detail 99 * 100 * @tparam Key Key type. 101 * 102 * @tparam Mapped Map type. 103 * 104 * @tparam Hash_Fn Hashing functor. 105 * Default is __gnu_cxx::hash. 106 * 107 * @tparam Eq_Fn Equal functor. 108 * Default std::equal_to<Key> 109 * 110 * @tparam _Alloc Allocator type. 111 * 112 * @tparam Store_Hash If key type stores extra metadata. 113 * Defaults to false. 114 * 115 * @tparam Comb_Hash_Fn Combining hash functor. 116 * If Hash_Fn is not null_type, then this 117 * is the ranged-hash functor; otherwise, 118 * this is the range-hashing functor. 119 * XXX(See Design::Hash-Based Containers::Hash Policies.) 120 * Default direct_mask_range_hashing. 121 * 122 * @tparam Resize_Policy Resizes hash. 123 * Defaults to hash_standard_resize_policy, 124 * using hash_exponential_size_policy and 125 * hash_load_check_resize_trigger. 126 * 127 * 128 * Bases are: detail::hash_eq_fn, Resize_Policy, detail::ranged_hash_fn, 129 * detail::types_traits. (Optional: detail::debug_map_base.) 130 */ 131 template<typename Key, 132 typename Mapped, 133 typename Hash_Fn, 134 typename Eq_Fn, 135 typename _Alloc, 136 bool Store_Hash, 137 typename Comb_Hash_Fn, 138 typename Resize_Policy > 139 class PB_DS_CC_HASH_NAME: 140 #ifdef _GLIBCXX_DEBUG 141 protected PB_DS_DEBUG_MAP_BASE_C_DEC, 142 #endif 143 public PB_DS_HASH_EQ_FN_C_DEC, 144 public Resize_Policy, 145 public PB_DS_RANGED_HASH_FN_C_DEC, 146 public PB_DS_CC_HASH_TRAITS_BASE 147 { 148 private: 149 typedef PB_DS_CC_HASH_TRAITS_BASE traits_base; 150 typedef typename traits_base::comp_hash comp_hash; 151 typedef typename traits_base::value_type value_type_; 152 typedef typename traits_base::pointer pointer_; 153 typedef typename traits_base::const_pointer const_pointer_; 154 typedef typename traits_base::reference reference_; 155 typedef typename traits_base::const_reference const_reference_; 156 157 struct entry : public traits_base::stored_data_type 158 { 159 typename _Alloc::template rebind<entry>::other::pointer m_p_next; 160 }; 161 162 typedef cond_dealtor<entry, _Alloc> cond_dealtor_t; 163 164 typedef typename _Alloc::template rebind<entry>::other entry_allocator; 165 typedef typename entry_allocator::pointer entry_pointer; 166 typedef typename entry_allocator::const_pointer const_entry_pointer; 167 typedef typename entry_allocator::reference entry_reference; 168 typedef typename entry_allocator::const_reference const_entry_reference; 169 170 typedef typename _Alloc::template rebind<entry_pointer>::other entry_pointer_allocator; 171 typedef typename entry_pointer_allocator::pointer entry_pointer_array; 172 173 typedef PB_DS_RANGED_HASH_FN_C_DEC ranged_hash_fn_base; 174 typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base; 175 typedef Resize_Policy resize_base; 176 177 #ifdef _GLIBCXX_DEBUG 178 typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base; 179 #endif 180 181 #define PB_DS_GEN_POS std::pair<entry_pointer, typename _Alloc::size_type> 182 183 #include <ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp> 184 #include <ext/pb_ds/detail/unordered_iterator/point_iterator.hpp> 185 #include <ext/pb_ds/detail/unordered_iterator/const_iterator.hpp> 186 #include <ext/pb_ds/detail/unordered_iterator/iterator.hpp> 187 188 #undef PB_DS_GEN_POS 189 190 public: 191 typedef _Alloc allocator_type; 192 typedef typename _Alloc::size_type size_type; 193 typedef typename _Alloc::difference_type difference_type; 194 typedef Hash_Fn hash_fn; 195 typedef Eq_Fn eq_fn; 196 typedef Comb_Hash_Fn comb_hash_fn; 197 typedef Resize_Policy resize_policy; 198 199 /// Value stores hash, true or false. 200 enum 201 { 202 store_hash = Store_Hash 203 }; 204 205 typedef typename traits_base::key_type key_type; 206 typedef typename traits_base::key_pointer key_pointer; 207 typedef typename traits_base::key_const_pointer key_const_pointer; 208 typedef typename traits_base::key_reference key_reference; 209 typedef typename traits_base::key_const_reference key_const_reference; 210 typedef typename traits_base::mapped_type mapped_type; 211 typedef typename traits_base::mapped_pointer mapped_pointer; 212 typedef typename traits_base::mapped_const_pointer mapped_const_pointer; 213 typedef typename traits_base::mapped_reference mapped_reference; 214 typedef typename traits_base::mapped_const_reference mapped_const_reference; 215 typedef typename traits_base::value_type value_type; 216 typedef typename traits_base::pointer pointer; 217 typedef typename traits_base::const_pointer const_pointer; 218 typedef typename traits_base::reference reference; 219 typedef typename traits_base::const_reference const_reference; 220 221 #ifdef PB_DS_DATA_TRUE_INDICATOR 222 typedef point_iterator_ point_iterator; 223 #endif 224 225 #ifdef PB_DS_DATA_FALSE_INDICATOR 226 typedef point_const_iterator_ point_iterator; 227 #endif 228 229 typedef point_const_iterator_ point_const_iterator; 230 231 #ifdef PB_DS_DATA_TRUE_INDICATOR 232 typedef iterator_ iterator; 233 #endif 234 235 #ifdef PB_DS_DATA_FALSE_INDICATOR 236 typedef const_iterator_ iterator; 237 #endif 238 239 typedef const_iterator_ const_iterator; 240 241 PB_DS_CC_HASH_NAME(); 242 243 PB_DS_CC_HASH_NAME(const Hash_Fn&); 244 245 PB_DS_CC_HASH_NAME(const Hash_Fn&, const Eq_Fn&); 246 247 PB_DS_CC_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Hash_Fn&); 248 249 PB_DS_CC_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Hash_Fn&, 250 const Resize_Policy&); 251 252 PB_DS_CC_HASH_NAME(const PB_DS_CLASS_C_DEC&); 253 254 virtual 255 ~PB_DS_CC_HASH_NAME(); 256 257 void 258 swap(PB_DS_CLASS_C_DEC&); 259 260 template<typename It> 261 void 262 copy_from_range(It, It); 263 264 void 265 initialize(); 266 267 inline size_type 268 size() const; 269 270 inline size_type 271 max_size() const; 272 273 /// True if size() == 0. 274 inline bool 275 empty() const; 276 277 /// Return current hash_fn. 278 Hash_Fn& 279 get_hash_fn(); 280 281 /// Return current const hash_fn. 282 const Hash_Fn& 283 get_hash_fn() const; 284 285 /// Return current eq_fn. 286 Eq_Fn& 287 get_eq_fn(); 288 289 /// Return current const eq_fn. 290 const Eq_Fn& 291 get_eq_fn() const; 292 293 /// Return current comb_hash_fn. 294 Comb_Hash_Fn& 295 get_comb_hash_fn(); 296 297 /// Return current const comb_hash_fn. 298 const Comb_Hash_Fn& 299 get_comb_hash_fn() const; 300 301 /// Return current resize_policy. 302 Resize_Policy& 303 get_resize_policy(); 304 305 /// Return current const resize_policy. 306 const Resize_Policy& 307 get_resize_policy() const; 308 309 inline std::pair<point_iterator, bool> 310 insert(const_reference r_val) 311 { return insert_imp(r_val, traits_base::m_store_extra_indicator); } 312 313 inline mapped_reference 314 operator[](key_const_reference r_key) 315 { 316 #ifdef PB_DS_DATA_TRUE_INDICATOR 317 return (subscript_imp(r_key, traits_base::m_store_extra_indicator)); 318 #else 319 insert(r_key); 320 return traits_base::s_null_type; 321 #endif 322 } 323 324 inline point_iterator 325 find(key_const_reference); 326 327 inline point_const_iterator 328 find(key_const_reference) const; 329 330 inline point_iterator 331 find_end(); 332 333 inline point_const_iterator 334 find_end() const; 335 336 inline bool 337 erase(key_const_reference); 338 339 template<typename Pred> 340 inline size_type 341 erase_if(Pred); 342 343 void 344 clear(); 345 346 inline iterator 347 begin(); 348 349 inline const_iterator 350 begin() const; 351 352 inline iterator 353 end(); 354 355 inline const_iterator 356 end() const; 357 358 #ifdef _GLIBCXX_DEBUG 359 void 360 assert_valid(const char*, int) const; 361 #endif 362 363 #ifdef PB_DS_HT_MAP_TRACE_ 364 void 365 trace() const; 366 #endif 367 368 private: 369 void 370 deallocate_all(); 371 372 inline bool 373 do_resize_if_needed(); 374 375 inline void 376 do_resize_if_needed_no_throw(); 377 378 void 379 resize_imp(size_type); 380 381 void 382 do_resize(size_type); 383 384 void 385 resize_imp_no_exceptions(size_type, entry_pointer_array, size_type); 386 387 inline entry_pointer 388 resize_imp_no_exceptions_reassign_pointer(entry_pointer, 389 entry_pointer_array, 390 false_type); 391 392 inline entry_pointer 393 resize_imp_no_exceptions_reassign_pointer(entry_pointer, 394 entry_pointer_array, 395 true_type); 396 397 void 398 deallocate_links_in_list(entry_pointer); 399 400 inline entry_pointer 401 get_entry(const_reference, false_type); 402 403 inline entry_pointer 404 get_entry(const_reference, true_type); 405 406 inline void 407 rels_entry(entry_pointer); 408 409 #ifdef PB_DS_DATA_TRUE_INDICATOR 410 inline mapped_reference 411 subscript_imp(key_const_reference r_key, false_type) 412 { 413 _GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) 414 const size_type pos = ranged_hash_fn_base::operator()(r_key); 415 entry_pointer p_e = m_entries[pos]; 416 resize_base::notify_insert_search_start(); 417 418 while (p_e != 0 419 && !hash_eq_fn_base::operator()(p_e->m_value.first, r_key)) 420 { 421 resize_base::notify_insert_search_collision(); 422 p_e = p_e->m_p_next; 423 } 424 425 resize_base::notify_insert_search_end(); 426 if (p_e != 0) 427 { 428 PB_DS_CHECK_KEY_EXISTS(r_key) 429 return (p_e->m_value.second); 430 } 431 432 PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) 433 return insert_new_imp(value_type(r_key, mapped_type()), pos)->second; 434 } 435 436 inline mapped_reference 437 subscript_imp(key_const_reference r_key, true_type) 438 { 439 _GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) 440 comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key); 441 entry_pointer p_e = m_entries[pos_hash_pair.first]; 442 resize_base::notify_insert_search_start(); 443 while (p_e != 0 && 444 !hash_eq_fn_base::operator()(p_e->m_value.first, p_e->m_hash, 445 r_key, pos_hash_pair.second)) 446 { 447 resize_base::notify_insert_search_collision(); 448 p_e = p_e->m_p_next; 449 } 450 451 resize_base::notify_insert_search_end(); 452 if (p_e != 0) 453 { 454 PB_DS_CHECK_KEY_EXISTS(r_key) 455 return p_e->m_value.second; 456 } 457 458 PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) 459 return insert_new_imp(value_type(r_key, mapped_type()), 460 pos_hash_pair)->second; 461 } 462 #endif 463 464 inline std::pair<point_iterator, bool> 465 insert_imp(const_reference, false_type); 466 467 inline std::pair<point_iterator, bool> 468 insert_imp(const_reference, true_type); 469 470 inline pointer 471 insert_new_imp(const_reference r_val, size_type pos) 472 { 473 if (do_resize_if_needed()) 474 pos = ranged_hash_fn_base::operator()(PB_DS_V2F(r_val)); 475 476 // Following lines might throw an exception. 477 entry_pointer p_e = get_entry(r_val, 478 traits_base::m_no_throw_copies_indicator); 479 480 // At this point no exceptions can be thrown. 481 p_e->m_p_next = m_entries[pos]; 482 m_entries[pos] = p_e; 483 resize_base::notify_inserted(++m_num_used_e); 484 485 _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));) 486 _GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) 487 return &p_e->m_value; 488 } 489 490 inline pointer 491 insert_new_imp(const_reference r_val, comp_hash& r_pos_hash_pair) 492 { 493 // Following lines might throw an exception. 494 if (do_resize_if_needed()) 495 r_pos_hash_pair = ranged_hash_fn_base::operator()(PB_DS_V2F(r_val)); 496 497 entry_pointer p_e = get_entry(r_val, 498 traits_base::m_no_throw_copies_indicator); 499 500 // At this point no exceptions can be thrown. 501 p_e->m_hash = r_pos_hash_pair.second; 502 p_e->m_p_next = m_entries[r_pos_hash_pair.first]; 503 m_entries[r_pos_hash_pair.first] = p_e; 504 resize_base::notify_inserted(++m_num_used_e); 505 _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));) 506 _GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) 507 return &p_e->m_value; 508 } 509 510 inline pointer 511 find_key_pointer(key_const_reference r_key, false_type) 512 { 513 entry_pointer p_e = m_entries[ranged_hash_fn_base::operator()(r_key)]; 514 resize_base::notify_find_search_start(); 515 while (p_e != 0 && 516 !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key)) 517 { 518 resize_base::notify_find_search_collision(); 519 p_e = p_e->m_p_next; 520 } 521 522 resize_base::notify_find_search_end(); 523 524 #ifdef _GLIBCXX_DEBUG 525 if (p_e == 0) 526 PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) 527 else 528 PB_DS_CHECK_KEY_EXISTS(r_key) 529 #endif 530 return &p_e->m_value; 531 } 532 533 inline pointer 534 find_key_pointer(key_const_reference r_key, true_type) 535 { 536 comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key); 537 entry_pointer p_e = m_entries[pos_hash_pair.first]; 538 resize_base::notify_find_search_start(); 539 while (p_e != 0 && 540 !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), 541 p_e->m_hash, 542 r_key, pos_hash_pair.second)) 543 { 544 resize_base::notify_find_search_collision(); 545 p_e = p_e->m_p_next; 546 } 547 548 resize_base::notify_find_search_end(); 549 550 #ifdef _GLIBCXX_DEBUG 551 if (p_e == 0) 552 PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) 553 else 554 PB_DS_CHECK_KEY_EXISTS(r_key) 555 #endif 556 return &p_e->m_value; 557 } 558 559 inline bool 560 erase_in_pos_imp(key_const_reference, size_type); 561 562 inline bool 563 erase_in_pos_imp(key_const_reference, const comp_hash&); 564 565 inline void 566 erase_entry_pointer(entry_pointer&); 567 568 #ifdef PB_DS_DATA_TRUE_INDICATOR 569 void 570 inc_it_state(pointer& r_p_value, 571 std::pair<entry_pointer, size_type>& r_pos) const 572 { 573 inc_it_state((mapped_const_pointer& )r_p_value, r_pos); 574 } 575 #endif 576 577 void 578 inc_it_state(const_pointer& r_p_value, 579 std::pair<entry_pointer, size_type>& r_pos) const 580 { 581 _GLIBCXX_DEBUG_ASSERT(r_p_value != 0); 582 r_pos.first = r_pos.first->m_p_next; 583 if (r_pos.first != 0) 584 { 585 r_p_value = &r_pos.first->m_value; 586 return; 587 } 588 589 for (++r_pos.second; r_pos.second < m_num_e; ++r_pos.second) 590 if (m_entries[r_pos.second] != 0) 591 { 592 r_pos.first = m_entries[r_pos.second]; 593 r_p_value = &r_pos.first->m_value; 594 return; 595 } 596 r_p_value = 0; 597 } 598 599 void 600 get_start_it_state(pointer& r_p_value, 601 std::pair<entry_pointer, size_type>& r_pos) const 602 { 603 for (r_pos.second = 0; r_pos.second < m_num_e; ++r_pos.second) 604 if (m_entries[r_pos.second] != 0) 605 { 606 r_pos.first = m_entries[r_pos.second]; 607 r_p_value = &r_pos.first->m_value; 608 return; 609 } 610 r_p_value = 0; 611 } 612 613 #ifdef _GLIBCXX_DEBUG 614 void 615 assert_entry_pointer_array_valid(const entry_pointer_array, 616 const char*, int) const; 617 618 void 619 assert_entry_pointer_valid(const entry_pointer, true_type, 620 const char*, int) const; 621 622 void 623 assert_entry_pointer_valid(const entry_pointer, false_type, 624 const char*, int) const; 625 #endif 626 627 #ifdef PB_DS_HT_MAP_TRACE_ 628 void 629 trace_list(const_entry_pointer) const; 630 #endif 631 632 private: 633 #ifdef PB_DS_DATA_TRUE_INDICATOR 634 friend class iterator_; 635 #endif 636 637 friend class const_iterator_; 638 639 static entry_allocator s_entry_allocator; 640 static entry_pointer_allocator s_entry_pointer_allocator; 641 static iterator s_end_it; 642 static const_iterator s_const_end_it; 643 static point_iterator s_find_end_it; 644 static point_const_iterator s_const_find_end_it; 645 646 size_type m_num_e; 647 size_type m_num_used_e; 648 entry_pointer_array m_entries; 649 650 enum 651 { 652 store_hash_ok = !Store_Hash 653 || !is_same<Hash_Fn, __gnu_pbds::null_type>::value 654 }; 655 656 PB_DS_STATIC_ASSERT(sth, store_hash_ok); 657 }; 658 659 #include <ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp> 660 #include <ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp> 661 #include <ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp> 662 #include <ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp> 663 #include <ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp> 664 #include <ext/pb_ds/detail/cc_hash_table_map_/size_fn_imps.hpp> 665 #include <ext/pb_ds/detail/cc_hash_table_map_/policy_access_fn_imps.hpp> 666 #include <ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp> 667 #include <ext/pb_ds/detail/cc_hash_table_map_/iterators_fn_imps.hpp> 668 #include <ext/pb_ds/detail/cc_hash_table_map_/insert_fn_imps.hpp> 669 #include <ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp> 670 671 #undef PB_DS_CLASS_T_DEC 672 #undef PB_DS_CLASS_C_DEC 673 #undef PB_DS_HASH_EQ_FN_C_DEC 674 #undef PB_DS_RANGED_HASH_FN_C_DEC 675 #undef PB_DS_CC_HASH_TRAITS_BASE 676 #undef PB_DS_DEBUG_MAP_BASE_C_DEC 677 #undef PB_DS_CC_HASH_NAME 678 } // namespace detail 679 } // namespace __gnu_pbds 680