1// -*- C++ -*- 2 3// Copyright (C) 2005-2015 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 gp_hash_table_map_/gp_ht_map_.hpp 38 * Contains an implementation class for general probing hash. 39 */ 40 41#include <ext/pb_ds/tag_and_trait.hpp> 42#include <ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp> 43#include <ext/pb_ds/detail/types_traits.hpp> 44#include <ext/pb_ds/exception.hpp> 45#include <ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp> 46#include <utility> 47#ifdef PB_DS_HT_MAP_TRACE_ 48#include <iostream> 49#endif 50#ifdef _GLIBCXX_DEBUG 51#include <ext/pb_ds/detail/debug_map_base.hpp> 52#endif 53#include <debug/debug.h> 54 55namespace __gnu_pbds 56{ 57 namespace detail 58 { 59#ifdef PB_DS_DATA_TRUE_INDICATOR 60#define PB_DS_GP_HASH_NAME gp_ht_map 61#endif 62 63#ifdef PB_DS_DATA_FALSE_INDICATOR 64#define PB_DS_GP_HASH_NAME gp_ht_set 65#endif 66 67#define PB_DS_CLASS_T_DEC \ 68 template<typename Key, typename Mapped, typename Hash_Fn, typename Eq_Fn, \ 69 typename _Alloc, bool Store_Hash, typename Comb_Probe_Fn, \ 70 typename Probe_Fn, typename Resize_Policy> 71 72#define PB_DS_CLASS_C_DEC \ 73 PB_DS_GP_HASH_NAME<Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, \ 74 Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy> 75 76#define PB_DS_HASH_EQ_FN_C_DEC \ 77 hash_eq_fn<Key, Eq_Fn, _Alloc, Store_Hash> 78 79#define PB_DS_RANGED_PROBE_FN_C_DEC \ 80 ranged_probe_fn<Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, Store_Hash> 81 82#define PB_DS_GP_HASH_TRAITS_BASE \ 83 types_traits<Key, Mapped, _Alloc, Store_Hash> 84 85#ifdef _GLIBCXX_DEBUG 86#define PB_DS_DEBUG_MAP_BASE_C_DEC \ 87 debug_map_base<Key, Eq_Fn, \ 88 typename _Alloc::template rebind<Key>::other::const_reference> 89#endif 90 91 92 /** 93 * A general-probing hash-based container. 94 * 95 * 96 * @ingroup hash-detail 97 * 98 * @tparam Key Key type. 99 * 100 * @tparam Mapped Map type. 101 * 102 * @tparam Hash_Fn Hashing functor. 103 * Default is __gnu_cxx::hash. 104 * 105 * @tparam Eq_Fn Equal functor. 106 * Default std::equal_to<Key> 107 * 108 * @tparam _Alloc Allocator type. 109 * 110 * @tparam Store_Hash If key type stores extra metadata. 111 * Defaults to false. 112 * 113 * @tparam Comb_Probe_Fn Combining probe functor. 114 * If Hash_Fn is not null_type, then this 115 * is the ranged-probe functor; otherwise, 116 * this is the range-hashing functor. 117 * XXX See Design::Hash-Based Containers::Hash Policies. 118 * Default direct_mask_range_hashing. 119 * 120 * @tparam Probe_Fn Probe functor. 121 * Defaults to linear_probe_fn, 122 * also quadratic_probe_fn. 123 * 124 * @tparam Resize_Policy Resizes hash. 125 * Defaults to hash_standard_resize_policy, 126 * using hash_exponential_size_policy and 127 * hash_load_check_resize_trigger. 128 * 129 * 130 * Bases are: detail::hash_eq_fn, Resize_Policy, detail::ranged_probe_fn, 131 * detail::types_traits. (Optional: detail::debug_map_base.) 132 */ 133 template<typename Key, 134 typename Mapped, 135 typename Hash_Fn, 136 typename Eq_Fn, 137 typename _Alloc, 138 bool Store_Hash, 139 typename Comb_Probe_Fn, 140 typename Probe_Fn, 141 typename Resize_Policy> 142 class PB_DS_GP_HASH_NAME : 143#ifdef _GLIBCXX_DEBUG 144 protected PB_DS_DEBUG_MAP_BASE_C_DEC, 145#endif 146 public PB_DS_HASH_EQ_FN_C_DEC, 147 public Resize_Policy, 148 public PB_DS_RANGED_PROBE_FN_C_DEC, 149 public PB_DS_GP_HASH_TRAITS_BASE 150 { 151 private: 152 typedef PB_DS_GP_HASH_TRAITS_BASE traits_base; 153 typedef typename traits_base::value_type value_type_; 154 typedef typename traits_base::pointer pointer_; 155 typedef typename traits_base::const_pointer const_pointer_; 156 typedef typename traits_base::reference reference_; 157 typedef typename traits_base::const_reference const_reference_; 158 typedef typename traits_base::comp_hash comp_hash; 159 160 enum entry_status 161 { 162 empty_entry_status, 163 valid_entry_status, 164 erased_entry_status 165 } __attribute__ ((__packed__)); 166 167 struct entry : public traits_base::stored_data_type 168 { 169 entry_status m_stat; 170 }; 171 172 typedef typename _Alloc::template rebind<entry>::other entry_allocator; 173 typedef typename entry_allocator::pointer entry_pointer; 174 typedef typename entry_allocator::const_pointer const_entry_pointer; 175 typedef typename entry_allocator::reference entry_reference; 176 typedef typename entry_allocator::const_reference const_entry_reference; 177 typedef typename entry_allocator::pointer entry_array; 178 179 typedef PB_DS_RANGED_PROBE_FN_C_DEC ranged_probe_fn_base; 180 181#ifdef _GLIBCXX_DEBUG 182 typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base; 183#endif 184 185 typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base; 186 typedef Resize_Policy resize_base; 187 188#define PB_DS_GEN_POS typename _Alloc::size_type 189 190#include <ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp> 191#include <ext/pb_ds/detail/unordered_iterator/point_iterator.hpp> 192#include <ext/pb_ds/detail/unordered_iterator/const_iterator.hpp> 193#include <ext/pb_ds/detail/unordered_iterator/iterator.hpp> 194 195#undef PB_DS_GEN_POS 196 197 public: 198 typedef _Alloc allocator_type; 199 typedef typename _Alloc::size_type size_type; 200 typedef typename _Alloc::difference_type difference_type; 201 typedef Hash_Fn hash_fn; 202 typedef Eq_Fn eq_fn; 203 typedef Probe_Fn probe_fn; 204 typedef Comb_Probe_Fn comb_probe_fn; 205 typedef Resize_Policy resize_policy; 206 207 /// Value stores hash, true or false. 208 enum 209 { 210 store_hash = Store_Hash 211 }; 212 213 typedef typename traits_base::key_type key_type; 214 typedef typename traits_base::key_pointer key_pointer; 215 typedef typename traits_base::key_const_pointer key_const_pointer; 216 typedef typename traits_base::key_reference key_reference; 217 typedef typename traits_base::key_const_reference key_const_reference; 218 typedef typename traits_base::mapped_type mapped_type; 219 typedef typename traits_base::mapped_pointer mapped_pointer; 220 typedef typename traits_base::mapped_const_pointer mapped_const_pointer; 221 typedef typename traits_base::mapped_reference mapped_reference; 222 typedef typename traits_base::mapped_const_reference mapped_const_reference; 223 typedef typename traits_base::value_type value_type; 224 typedef typename traits_base::pointer pointer; 225 typedef typename traits_base::const_pointer const_pointer; 226 typedef typename traits_base::reference reference; 227 typedef typename traits_base::const_reference const_reference; 228 229#ifdef PB_DS_DATA_TRUE_INDICATOR 230 typedef point_iterator_ point_iterator; 231#endif 232 233#ifdef PB_DS_DATA_FALSE_INDICATOR 234 typedef point_const_iterator_ point_iterator; 235#endif 236 237 typedef point_const_iterator_ point_const_iterator; 238 239#ifdef PB_DS_DATA_TRUE_INDICATOR 240 typedef iterator_ iterator; 241#endif 242 243#ifdef PB_DS_DATA_FALSE_INDICATOR 244 typedef const_iterator_ iterator; 245#endif 246 247 typedef const_iterator_ const_iterator; 248 249 PB_DS_GP_HASH_NAME(); 250 251 PB_DS_GP_HASH_NAME(const PB_DS_CLASS_C_DEC&); 252 253 PB_DS_GP_HASH_NAME(const Hash_Fn&); 254 255 PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&); 256 257 PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&); 258 259 PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&, 260 const Probe_Fn&); 261 262 PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&, 263 const Probe_Fn&, const Resize_Policy&); 264 265 template<typename It> 266 void 267 copy_from_range(It, It); 268 269 virtual 270 ~PB_DS_GP_HASH_NAME(); 271 272 void 273 swap(PB_DS_CLASS_C_DEC&); 274 275 inline size_type 276 size() const; 277 278 inline size_type 279 max_size() const; 280 281 /// True if size() == 0. 282 inline bool 283 empty() const; 284 285 /// Return current hash_fn. 286 Hash_Fn& 287 get_hash_fn(); 288 289 /// Return current const hash_fn. 290 const Hash_Fn& 291 get_hash_fn() const; 292 293 /// Return current eq_fn. 294 Eq_Fn& 295 get_eq_fn(); 296 297 /// Return current const eq_fn. 298 const Eq_Fn& 299 get_eq_fn() const; 300 301 /// Return current probe_fn. 302 Probe_Fn& 303 get_probe_fn(); 304 305 /// Return current const probe_fn. 306 const Probe_Fn& 307 get_probe_fn() const; 308 309 /// Return current comb_probe_fn. 310 Comb_Probe_Fn& 311 get_comb_probe_fn(); 312 313 /// Return current const comb_probe_fn. 314 const Comb_Probe_Fn& 315 get_comb_probe_fn() const; 316 317 /// Return current resize_policy. 318 Resize_Policy& 319 get_resize_policy(); 320 321 /// Return current const resize_policy. 322 const Resize_Policy& 323 get_resize_policy() const; 324 325 inline std::pair<point_iterator, bool> 326 insert(const_reference r_val) 327 { 328 _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid(__FILE__, __LINE__);) 329 return insert_imp(r_val, traits_base::m_store_extra_indicator); 330 } 331 332 inline mapped_reference 333 operator[](key_const_reference r_key) 334 { 335#ifdef PB_DS_DATA_TRUE_INDICATOR 336 return subscript_imp(r_key, traits_base::m_store_extra_indicator); 337#else 338 insert(r_key); 339 return traits_base::s_null_type; 340#endif 341 } 342 343 inline point_iterator 344 find(key_const_reference); 345 346 inline point_const_iterator 347 find(key_const_reference) const; 348 349 inline point_iterator 350 find_end(); 351 352 inline point_const_iterator 353 find_end() const; 354 355 inline bool 356 erase(key_const_reference); 357 358 template<typename Pred> 359 inline size_type 360 erase_if(Pred); 361 362 void 363 clear(); 364 365 inline iterator 366 begin(); 367 368 inline const_iterator 369 begin() const; 370 371 inline iterator 372 end(); 373 374 inline const_iterator 375 end() const; 376 377#ifdef _GLIBCXX_DEBUG 378 void 379 assert_valid(const char*, int) const; 380#endif 381 382#ifdef PB_DS_HT_MAP_TRACE_ 383 void 384 trace() const; 385#endif 386 387 private: 388#ifdef PB_DS_DATA_TRUE_INDICATOR 389 friend class iterator_; 390#endif 391 392 friend class const_iterator_; 393 394 void 395 deallocate_all(); 396 397 void 398 initialize(); 399 400 void 401 erase_all_valid_entries(entry_array, size_type); 402 403 inline bool 404 do_resize_if_needed(); 405 406 inline void 407 do_resize_if_needed_no_throw(); 408 409 void 410 resize_imp(size_type); 411 412 virtual void 413 do_resize(size_type); 414 415 void 416 resize_imp(entry_array, size_type); 417 418 inline void 419 resize_imp_reassign(entry_pointer, entry_array, false_type); 420 421 inline void 422 resize_imp_reassign(entry_pointer, entry_array, true_type); 423 424 inline size_type 425 find_ins_pos(key_const_reference, false_type); 426 427 inline comp_hash 428 find_ins_pos(key_const_reference, true_type); 429 430 inline std::pair<point_iterator, bool> 431 insert_imp(const_reference, false_type); 432 433 inline std::pair<point_iterator, bool> 434 insert_imp(const_reference, true_type); 435 436 inline pointer 437 insert_new_imp(const_reference r_val, size_type pos) 438 { 439 _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status); 440 441 if (do_resize_if_needed()) 442 pos = find_ins_pos(PB_DS_V2F(r_val), 443 traits_base::m_store_extra_indicator); 444 445 _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status); 446 entry* const p_e = m_entries + pos; 447 new (&p_e->m_value) value_type(r_val); 448 p_e->m_stat = valid_entry_status; 449 resize_base::notify_inserted(++m_num_used_e); 450 451 _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(p_e->m_value));) 452 _GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) 453 return &p_e->m_value; 454 } 455 456 inline pointer 457 insert_new_imp(const_reference r_val, comp_hash& r_pos_hash_pair) 458 { 459 _GLIBCXX_DEBUG_ASSERT(m_entries[r_pos_hash_pair.first].m_stat != 460 valid_entry_status); 461 462 if (do_resize_if_needed()) 463 r_pos_hash_pair = find_ins_pos(PB_DS_V2F(r_val), 464 traits_base::m_store_extra_indicator); 465 466 _GLIBCXX_DEBUG_ASSERT(m_entries[r_pos_hash_pair.first].m_stat != 467 valid_entry_status); 468 469 entry* const p_e = m_entries + r_pos_hash_pair.first; 470 new (&p_e->m_value) value_type(r_val); 471 p_e->m_hash = r_pos_hash_pair.second; 472 p_e->m_stat = valid_entry_status; 473 474 resize_base::notify_inserted(++m_num_used_e); 475 476 _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(p_e->m_value));) 477 _GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) 478 return &p_e->m_value; 479 } 480 481#ifdef PB_DS_DATA_TRUE_INDICATOR 482 inline mapped_reference 483 subscript_imp(key_const_reference key, false_type) 484 { 485 _GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) 486 487 const size_type pos = find_ins_pos(key, 488 traits_base::m_store_extra_indicator); 489 490 entry_pointer p_e = &m_entries[pos]; 491 if (p_e->m_stat != valid_entry_status) 492 return insert_new_imp(value_type(key, mapped_type()), pos)->second; 493 494 PB_DS_CHECK_KEY_EXISTS(key) 495 return p_e->m_value.second; 496 } 497 498 inline mapped_reference 499 subscript_imp(key_const_reference key, true_type) 500 { 501 _GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) 502 503 comp_hash pos_hash_pair = find_ins_pos(key, 504 traits_base::m_store_extra_indicator); 505 506 if (m_entries[pos_hash_pair.first].m_stat != valid_entry_status) 507 return insert_new_imp(value_type(key, mapped_type()), 508 pos_hash_pair)->second; 509 510 PB_DS_CHECK_KEY_EXISTS(key) 511 return (m_entries + pos_hash_pair.first)->m_value.second; 512 } 513#endif 514 515 inline pointer 516 find_key_pointer(key_const_reference key, false_type) 517 { 518 const size_type hash = ranged_probe_fn_base::operator()(key); 519 resize_base::notify_find_search_start(); 520 521 // Loop until entry is found or until all possible entries accessed. 522 for (size_type i = 0; i < m_num_e; ++i) 523 { 524 const size_type pos = ranged_probe_fn_base::operator()(key, 525 hash, i); 526 527 entry* const p_e = m_entries + pos; 528 switch (p_e->m_stat) 529 { 530 case empty_entry_status: 531 { 532 resize_base::notify_find_search_end(); 533 PB_DS_CHECK_KEY_DOES_NOT_EXIST(key) 534 return 0; 535 } 536 break; 537 case valid_entry_status: 538 if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), key)) 539 { 540 resize_base::notify_find_search_end(); 541 PB_DS_CHECK_KEY_EXISTS(key) 542 return pointer(&p_e->m_value); 543 } 544 break; 545 case erased_entry_status: 546 break; 547 default: 548 _GLIBCXX_DEBUG_ASSERT(0); 549 }; 550 551 resize_base::notify_find_search_collision(); 552 } 553 554 PB_DS_CHECK_KEY_DOES_NOT_EXIST(key) 555 resize_base::notify_find_search_end(); 556 return 0; 557 } 558 559 inline pointer 560 find_key_pointer(key_const_reference key, true_type) 561 { 562 comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(key); 563 resize_base::notify_find_search_start(); 564 565 // Loop until entry is found or until all possible entries accessed. 566 for (size_type i = 0; i < m_num_e; ++i) 567 { 568 const size_type pos = 569 ranged_probe_fn_base::operator()(key, pos_hash_pair.second, i); 570 571 entry* const p_e = m_entries + pos; 572 573 switch(p_e->m_stat) 574 { 575 case empty_entry_status: 576 { 577 resize_base::notify_find_search_end(); 578 PB_DS_CHECK_KEY_DOES_NOT_EXIST(key) 579 return 0; 580 } 581 break; 582 case valid_entry_status: 583 if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), 584 p_e->m_hash, 585 key, pos_hash_pair.second)) 586 { 587 resize_base::notify_find_search_end(); 588 PB_DS_CHECK_KEY_EXISTS(key) 589 return pointer(&p_e->m_value); 590 } 591 break; 592 case erased_entry_status: 593 break; 594 default: 595 _GLIBCXX_DEBUG_ASSERT(0); 596 }; 597 598 resize_base::notify_find_search_collision(); 599 } 600 601 PB_DS_CHECK_KEY_DOES_NOT_EXIST(key) 602 resize_base::notify_find_search_end(); 603 return 0; 604 } 605 606 inline bool 607 erase_imp(key_const_reference, true_type); 608 609 inline bool 610 erase_imp(key_const_reference, false_type); 611 612 inline void 613 erase_entry(entry_pointer); 614 615#ifdef PB_DS_DATA_TRUE_INDICATOR 616 void 617 inc_it_state(pointer& r_p_value, size_type& r_pos) const 618 { inc_it_state((mapped_const_pointer& )r_p_value, r_pos); } 619#endif 620 621 void 622 inc_it_state(const_pointer& r_p_value, size_type& r_pos) const 623 { 624 _GLIBCXX_DEBUG_ASSERT(r_p_value != 0); 625 for (++r_pos; r_pos < m_num_e; ++r_pos) 626 { 627 const_entry_pointer p_e =& m_entries[r_pos]; 628 if (p_e->m_stat == valid_entry_status) 629 { 630 r_p_value =& p_e->m_value; 631 return; 632 } 633 } 634 r_p_value = 0; 635 } 636 637 void 638 get_start_it_state(const_pointer& r_p_value, size_type& r_pos) const 639 { 640 for (r_pos = 0; r_pos < m_num_e; ++r_pos) 641 { 642 const_entry_pointer p_e = &m_entries[r_pos]; 643 if (p_e->m_stat == valid_entry_status) 644 { 645 r_p_value = &p_e->m_value; 646 return; 647 } 648 } 649 r_p_value = 0; 650 } 651 652 void 653 get_start_it_state(pointer& r_p_value, size_type& r_pos) 654 { 655 for (r_pos = 0; r_pos < m_num_e; ++r_pos) 656 { 657 entry_pointer p_e = &m_entries[r_pos]; 658 if (p_e->m_stat == valid_entry_status) 659 { 660 r_p_value = &p_e->m_value; 661 return; 662 } 663 } 664 r_p_value = 0; 665 } 666 667#ifdef _GLIBCXX_DEBUG 668 void 669 assert_entry_array_valid(const entry_array, false_type, 670 const char*, int) const; 671 672 void 673 assert_entry_array_valid(const entry_array, true_type, 674 const char*, int) const; 675#endif 676 677 static entry_allocator s_entry_allocator; 678 static iterator s_end_it; 679 static const_iterator s_const_end_it; 680 681 size_type m_num_e; 682 size_type m_num_used_e; 683 entry_pointer m_entries; 684 685 enum 686 { 687 store_hash_ok = !Store_Hash 688 || !is_same<Hash_Fn, __gnu_pbds::null_type>::value 689 }; 690 691 PB_DS_STATIC_ASSERT(sth, store_hash_ok); 692 }; 693 694#include <ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp> 695#include <ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp> 696#include <ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp> 697#include <ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp> 698#include <ext/pb_ds/detail/gp_hash_table_map_/info_fn_imps.hpp> 699#include <ext/pb_ds/detail/gp_hash_table_map_/policy_access_fn_imps.hpp> 700#include <ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp> 701#include <ext/pb_ds/detail/gp_hash_table_map_/iterator_fn_imps.hpp> 702#include <ext/pb_ds/detail/gp_hash_table_map_/insert_fn_imps.hpp> 703#include <ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp> 704 705#undef PB_DS_CLASS_T_DEC 706#undef PB_DS_CLASS_C_DEC 707#undef PB_DS_HASH_EQ_FN_C_DEC 708#undef PB_DS_RANGED_PROBE_FN_C_DEC 709#undef PB_DS_GP_HASH_TRAITS_BASE 710#undef PB_DS_DEBUG_MAP_BASE_C_DEC 711#undef PB_DS_GP_HASH_NAME 712 } // namespace detail 713} // namespace __gnu_pbds 714