From ce8b0a77329373909bac9fd6da9d7fa46605069e Mon Sep 17 00:00:00 2001 From: bkoz Date: Thu, 28 Sep 2006 01:23:58 +0000 Subject: 2006-09-27 Benjamin Kosnik * include/ext/typelist.h (type_to_type): Remove. * include/ext/throw_allocator.h (assert_allocatod): Remove. (check_allocated(label)): New. (print_to_string): Print numerical output correctly. * testsuite/ext/pb_ds/example/hash_resize_neg.cc: Adjust line numbers. * testsuite/util/regression/rand/priority_queue/detail/ operator_fn_imps.hpp: Set and clear label, throw probability. Check only allocations of the marked label. * testsuite/util/regression/rand/assoc/detail/ operator_fn_imps.hpp: Same. * testsuite/performance/ext/pb_ds/text_find_timing.cc: Adjustments for removal of type_to_type. * testsuite/performance/ext/pb_ds/ hash_random_int_erase_mem_usage.cc: Same. * testsuite/performance/ext/pb_ds/tree_text_insert_timing.cc: Same. * testsuite/performance/ext/pb_ds/ priority_queue_text_push_timing.cc: Same. * testsuite/performance/ext/pb_ds/ random_int_subscript_find_timing.cc: Same. * testsuite/performance/ext/pb_ds/tree_split_join_timing.cc: Same. * testsuite/performance/ext/pb_ds/random_int_find_timing.cc: Same. * testsuite/performance/ext/pb_ds/ multimap_text_insert_mem_usage.hpp: Same. * testsuite/performance/ext/pb_ds/ priority_queue_random_int_push_timing.cc: Same. * testsuite/performance/ext/pb_ds/multimap_text_find_timing.hpp: Same. * testsuite/performance/ext/pb_ds/ priority_queue_text_modify_timing.hpp: Same. * testsuite/performance/ext/pb_ds/ tree_order_statistics_timing.cc: Same. * testsuite/performance/ext/pb_ds/ priority_queue_text_push_pop_timing.cc: Same. * testsuite/performance/ext/pb_ds/ priority_queue_text_join_timing.cc: Same. * testsuite/performance/ext/pb_ds/ priority_queue_random_int_push_pop_timing.cc: Same. * testsuite/performance/ext/pb_ds/ random_int_subscript_insert_timing.cc: Same. * testsuite/performance/ext/pb_ds/tree_text_lor_find_timing.cc: Same. * testsuite/performance/ext/pb_ds/ multimap_text_insert_timing.hpp: Same. * testsuite/performance/ext/pb_ds/ priority_queue_text_pop_mem_usage.cc: Same. * testsuite/performance/ext/pb_ds/ hash_zlob_random_int_find_timing.cc: Same. * testsuite/util/regression/trait/assoc/type_trait.hpp: Same. * testsuite/util/regression/rand/priority_queue/ rand_regression_test.hpp: Same. * testsuite/util/regression/rand/assoc/detail/ constructor_destructor_fn_imps.hpp: Same. * testsuite/util/regression/rand/assoc/detail/insert_fn_imps.hpp: Same. * testsuite/util/regression/rand/assoc/rand_regression_test.hpp: Same. * testsuite/util/regression/rand/assoc/ container_rand_regression_test.hpp: Same. * testsuite/util/regression/assoc/common_type.hpp: Same. * testsuite/util/regression/basic_type.hpp: Same. * testsuite/util/common_type/assoc/common_type.hpp: Same. * testsuite/util/common_type/assoc/string_form.hpp: Same. * testsuite/util/common_type/assoc/template_policy.hpp: Same. * testsuite/util/common_type/assoc/native_set.hpp: Same. * testsuite/util/performance/priority_queue/mem_usage/ pop_test.hpp: Same. * testsuite/util/performance/priority_queue/timing/ push_pop_test.hpp: Same. * testsuite/util/performance/priority_queue/timing/join_test.hpp: Same. * testsuite/util/performance/priority_queue/timing/push_test.hpp: Same. * testsuite/util/performance/priority_queue/timing/ modify_test.hpp: Same. * testsuite/util/performance/assoc/mem_usage/ multimap_insert_test.hpp: Same. * testsuite/util/performance/assoc/mem_usage/erase_test.hpp: Same. * testsuite/util/performance/assoc/timing/ multimap_insert_test.hpp: Same. * testsuite/util/performance/assoc/timing/ subscript_find_test.hpp: Same. * testsuite/util/performance/assoc/timing/find_test.hpp: Same. * testsuite/util/performance/assoc/timing/ subscript_insert_test.hpp: Same. * testsuite/util/performance/assoc/timing/insert_test.hpp: Same. * testsuite/util/performance/assoc/timing/ tree_order_statistics_test.hpp: Same. * testsuite/util/performance/assoc/timing/multimap_find_test.hpp: Same. * testsuite/util/performance/assoc/timing/ tree_split_join_test.hpp: Same. * testsuite/util/performance/assoc/multimap_common_type.hpp: Same. * testsuite/util/testsuite_common_types.h: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/ constructor_destructor_no_store_hash_fn_imps.hpp: Typedef normalization, consistency in member names between cc and gp hash tables, formatting fixes. * include/ext/pb_ds/detail/cc_hash_table_map_/ erase_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/ insert_no_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/ constructor_destructor_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/ insert_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/ constructor_destructor_fn_imps.hpp: Same. * include/ext/pb_ds/detail/cc_hash_table_map_/ erase_no_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/ constructor_destructor_no_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/ erase_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/ insert_no_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/ constructor_destructor_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/ insert_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/ constructor_destructor_fn_imps.hpp: Same. * include/ext/pb_ds/detail/gp_hash_table_map_/ erase_no_store_hash_fn_imps.hpp: Same. * include/ext/pb_ds/assoc_container.hpp: Formatting fixes. * include/ext/pb_ds/detail/resize_policy/ hash_prime_size_policy_imp.hpp: Same. * include/ext/pb_ds/detail/resize_policy/ hash_standard_resize_policy_imp.hpp: Same. * include/ext/pb_ds/detail/types_traits.hpp: Same. * include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp: Same. * include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp: Same. * include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp: Same. * include/ext/pb_ds/detail/hash_fn/ direct_mod_range_hashing_imp.hpp: Same. * include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp: Same. * include/ext/pb_ds/detail/hash_fn/ direct_mask_range_hashing_imp.hpp: Same. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@117268 138bc75d-0d04-0410-961f-82ee72b054a4 --- libstdc++-v3/include/ext/pb_ds/assoc_container.hpp | 70 +-- .../pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp | 289 ++++------- .../constructor_destructor_fn_imps.hpp | 57 +-- ...onstructor_destructor_no_store_hash_fn_imps.hpp | 4 +- .../constructor_destructor_store_hash_fn_imps.hpp | 4 +- .../detail/cc_hash_table_map_/debug_fn_imps.hpp | 4 +- .../detail/cc_hash_table_map_/erase_fn_imps.hpp | 20 +- .../erase_no_store_hash_fn_imps.hpp | 4 +- .../erase_store_hash_fn_imps.hpp | 4 +- .../insert_no_store_hash_fn_imps.hpp | 2 +- .../insert_store_hash_fn_imps.hpp | 2 +- .../detail/cc_hash_table_map_/resize_fn_imps.hpp | 20 +- .../detail/cc_hash_table_map_/trace_fn_imps.hpp | 6 +- .../detail/constructors_destructor_fn_imps.hpp | 63 +-- .../constructor_destructor_fn_imps.hpp | 94 ++-- ...onstructor_destructor_no_store_hash_fn_imps.hpp | 4 +- .../constructor_destructor_store_hash_fn_imps.hpp | 4 +- .../detail/gp_hash_table_map_/debug_fn_imps.hpp | 2 +- .../detail/gp_hash_table_map_/erase_fn_imps.hpp | 32 +- .../erase_no_store_hash_fn_imps.hpp | 2 +- .../erase_store_hash_fn_imps.hpp | 2 +- .../detail/gp_hash_table_map_/find_fn_imps.hpp | 15 +- .../pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp | 531 +++++++-------------- .../insert_no_store_hash_fn_imps.hpp | 6 +- .../insert_store_hash_fn_imps.hpp | 50 +- .../detail/gp_hash_table_map_/resize_fn_imps.hpp | 55 +-- .../detail/gp_hash_table_map_/trace_fn_imps.hpp | 4 +- .../hash_fn/direct_mask_range_hashing_imp.hpp | 12 +- .../hash_fn/direct_mod_range_hashing_imp.hpp | 14 +- .../detail/hash_fn/mask_based_range_hashing.hpp | 52 +- .../ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp | 211 +++----- .../ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp | 8 +- .../resize_policy/hash_prime_size_policy_imp.hpp | 14 +- .../hash_standard_resize_policy_imp.hpp | 34 +- .../include/ext/pb_ds/detail/types_traits.hpp | 31 +- 35 files changed, 610 insertions(+), 1116 deletions(-) (limited to 'libstdc++-v3/include/ext/pb_ds') diff --git a/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp b/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp index 4491768cb47..271cc7600f1 100644 --- a/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp +++ b/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp @@ -184,14 +184,14 @@ namespace pb_ds // Constructor taking some policy objects. r_hash_fn will be // copied by the Hash_Fn object of the container object. cc_hash_table(const hash_fn& h) - : base_type(h) { } + : base_type(h) { } // Constructor taking some policy objects. r_hash_fn will be // copied by the hash_fn object of the container object, and // r_eq_fn will be copied by the eq_fn object of the container // object. cc_hash_table(const hash_fn& h, const eq_fn& e) - : base_type(h, e) { } + : base_type(h, e) { } // Constructor taking some policy objects. r_hash_fn will be // copied by the hash_fn object of the container object, r_eq_fn @@ -199,7 +199,7 @@ namespace pb_ds // r_comb_hash_fn will be copied by the comb_hash_fn object of the // container object. cc_hash_table(const hash_fn& h, const eq_fn& e, const comb_hash_fn& ch) - : base_type(h, e, ch) { } + : base_type(h, e, ch) { } // Constructor taking some policy objects. r_hash_fn will be // copied by the hash_fn object of the container object, r_eq_fn @@ -209,7 +209,7 @@ namespace pb_ds // resize_policy object of the container object. cc_hash_table(const hash_fn& h, const eq_fn& e, const comb_hash_fn& ch, const resize_policy& rp) - : base_type(h, e, ch, rp) { } + : base_type(h, e, ch, rp) { } // Constructor taking __iterators to a range of value_types. The // value_types between first_it and last_it will be inserted into @@ -223,7 +223,7 @@ namespace pb_ds // last_it will be inserted into the container object. template cc_hash_table(It first, It last, const hash_fn& h) - : base_type(h) + : base_type(h) { copy_from_range(first, last); } // Constructor taking __iterators to a range of value_types and @@ -234,7 +234,7 @@ namespace pb_ds // object. template cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e) - : base_type(h, e) + : base_type(h, e) { copy_from_range(first, last); } // Constructor taking __iterators to a range of value_types and @@ -247,7 +247,7 @@ namespace pb_ds template cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, const comb_hash_fn& ch) - : base_type(h, e, ch) + : base_type(h, e, ch) { copy_from_range(first, last); } // Constructor taking __iterators to a range of value_types and @@ -261,11 +261,11 @@ namespace pb_ds template cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, const comb_hash_fn& ch, const resize_policy& rp) - : base_type(h, e, ch, rp) + : base_type(h, e, ch, rp) { copy_from_range(first, last); } cc_hash_table(const cc_hash_table& other) - : base_type((const base_type&)other) + : base_type((const base_type&)other) { } virtual @@ -274,7 +274,7 @@ namespace pb_ds cc_hash_table& operator=(const cc_hash_table& other) { - if (this !=& other) + if (this != &other) { cc_hash_table tmp(other); swap(tmp); @@ -323,14 +323,14 @@ namespace pb_ds // Constructor taking some policy objects. r_hash_fn will be // copied by the hash_fn object of the container object. gp_hash_table(const hash_fn& h) - : base_type(h) { } + : base_type(h) { } // Constructor taking some policy objects. r_hash_fn will be // copied by the hash_fn object of the container object, and // r_eq_fn will be copied by the eq_fn object of the container // object. gp_hash_table(const hash_fn& h, const eq_fn& e) - : base_type(h, e) { } + : base_type(h, e) { } // Constructor taking some policy objects. r_hash_fn will be // copied by the hash_fn object of the container object, r_eq_fn @@ -338,7 +338,7 @@ namespace pb_ds // r_comb_probe_fn will be copied by the comb_probe_fn object of // the container object. gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp) - : base_type(h, e, cp) { } + : base_type(h, e, cp) { } // Constructor taking some policy objects. r_hash_fn will be // copied by the hash_fn object of the container object, r_eq_fn @@ -348,7 +348,7 @@ namespace pb_ds // probe_fn object of the container object. gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp, const probe_fn& p) - : base_type(h, e, cp, p) { } + : base_type(h, e, cp, p) { } // Constructor taking some policy objects. r_hash_fn will be // copied by the hash_fn object of the container object, r_eq_fn @@ -359,7 +359,7 @@ namespace pb_ds // copied by the Resize_Policy object of the container object. gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp, const probe_fn& p, const resize_policy& rp) - : base_type(h, e, cp, p, rp) { } + : base_type(h, e, cp, p, rp) { } // Constructor taking __iterators to a range of value_types. The // value_types between first_it and last_it will be inserted into @@ -374,7 +374,7 @@ namespace pb_ds // will be copied by the hash_fn object of the container object. template gp_hash_table(It first, It last, const hash_fn& h) - : base_type(h) + : base_type(h) { base_type::copy_from_range(first, last); } // Constructor taking __iterators to a range of value_types and @@ -385,7 +385,7 @@ namespace pb_ds // object. template gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e) - : base_type(h, e) + : base_type(h, e) { base_type::copy_from_range(first, last); } // Constructor taking __iterators to a range of value_types and @@ -398,7 +398,7 @@ namespace pb_ds template gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp) - : base_type(h, e, cp) + : base_type(h, e, cp) { base_type::copy_from_range(first, last); } // Constructor taking __iterators to a range of value_types and @@ -412,7 +412,7 @@ namespace pb_ds template gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp, const probe_fn& p) - : base_type(h, e, cp, p) + : base_type(h, e, cp, p) { base_type::copy_from_range(first, last); } // Constructor taking __iterators to a range of value_types and @@ -429,11 +429,11 @@ namespace pb_ds gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp, const probe_fn& p, const resize_policy& rp) - : base_type(h, e, cp, p, rp) + : base_type(h, e, cp, p, rp) { base_type::copy_from_range(first, last); } gp_hash_table(const gp_hash_table& other) - : base_type((const base_type&)other) + : base_type((const base_type&)other) { } virtual @@ -442,7 +442,7 @@ namespace pb_ds gp_hash_table& operator=(const gp_hash_table& other) { - if (this !=& other) + if (this != &other) { gp_hash_table tmp(other); swap(tmp); @@ -458,7 +458,7 @@ namespace pb_ds #undef PB_DS_BASE_C_DEC -#define PB_DS_BASE_C_DEC \ +#define PB_DS_BASE_C_DEC \ container_base // An abstract basic tree-like (tree, trie) associative container. @@ -484,10 +484,10 @@ namespace pb_ds #undef PB_DS_BASE_C_DEC -#define PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC \ +#define PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC \ detail::tree_traits -#define PB_DS_BASE_C_DEC \ +#define PB_DS_BASE_C_DEC \ basic_tree::type, Allocator> @@ -511,7 +511,7 @@ namespace pb_ds // Constructor taking some policy objects. r_cmp_fn will be copied // by the Cmp_Fn object of the container object. tree(const cmp_fn& c) - : base_type(c) { } + : base_type(c) { } // Constructor taking __iterators to a range of value_types. The // value_types between first_it and last_it will be inserted into @@ -530,7 +530,7 @@ namespace pb_ds { base_type::copy_from_range(first, last); } tree(const tree& other) - : base_type((const base_type&)other) { } + : base_type((const base_type&)other) { } virtual ~tree() { } @@ -538,7 +538,7 @@ namespace pb_ds tree& operator=(const tree& other) { - if (this !=& other) + if (this != &other) { tree tmp(other); swap(tmp); @@ -555,10 +555,10 @@ namespace pb_ds #undef PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC -#define PB_DS_TRIE_NODE_AND_ITS_TRAITS \ +#define PB_DS_TRIE_NODE_AND_ITS_TRAITS \ detail::trie_traits -#define PB_DS_BASE_C_DEC \ +#define PB_DS_BASE_C_DEC \ basic_tree::type, Allocator> @@ -588,7 +588,7 @@ namespace pb_ds // be copied by the E_Access_Traits object of the container // object. trie(const e_access_traits& t) - : base_type(t) { } + : base_type(t) { } // Constructor taking __iterators to a range of value_types. The // value_types between first_it and last_it will be inserted into @@ -602,11 +602,11 @@ namespace pb_ds // last_it will be inserted into the container object. template trie(It first, It last, const e_access_traits& t) - : base_type(t) + : base_type(t) { base_type::copy_from_range(first, last); } trie(const trie& other) - : base_type((const base_type&)other) { } + : base_type((const base_type&)other) { } virtual ~trie() { } @@ -614,7 +614,7 @@ namespace pb_ds trie& operator=(const trie& other) { - if (this !=& other) + if (this != &other) { trie tmp(other); swap(tmp); @@ -661,7 +661,7 @@ namespace pb_ds { base_type::copy_from_range(first, last); } list_update(const list_update& other) - : base_type((const base_type&)other) { } + : base_type((const base_type&)other) { } virtual ~list_update() { } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp index 2659a0bb347..93035e86079 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp @@ -66,9 +66,9 @@ namespace pb_ds { #define PB_DS_CLASS_T_DEC \ - template + template #ifdef PB_DS_DATA_TRUE_INDICATOR #define PB_DS_CLASS_NAME cc_ht_map_data_ @@ -113,12 +113,12 @@ namespace pb_ds // <011i$i0|\|-<|-|4i|\|i|\|g |-|4$|-| 74813. template + typename Comb_Hash_Fn, + typename Resize_Policy > class PB_DS_CLASS_NAME: #ifdef _GLIBCXX_DEBUG protected PB_DS_MAP_DEBUG_BASE_C_DEC, @@ -128,48 +128,42 @@ namespace pb_ds public PB_DS_RANGED_HASH_FN_C_DEC, public PB_DS_TYPES_TRAITS_C_DEC { - private: - typedef typename PB_DS_TYPES_TRAITS_C_DEC::comp_hash comp_hash; - - struct entry : public PB_DS_TYPES_TRAITS_C_DEC::stored_value_type + typedef PB_DS_TYPES_TRAITS_C_DEC traits_base; + typedef typename traits_base::comp_hash comp_hash; + typedef typename traits_base::value_type value_type_; + typedef typename traits_base::pointer pointer_; + typedef typename traits_base::const_pointer const_pointer_; + typedef typename traits_base::reference reference_; + typedef typename traits_base::const_reference const_reference_; + typedef typename traits_base::store_extra_false_type store_hash_false_type; + typedef typename traits_base::store_extra_true_type store_hash_true_type; + typedef typename traits_base::no_throw_copies_false_type no_throw_copies_false_type; + typedef typename traits_base::no_throw_copies_true_type no_throw_copies_true_type; + + struct entry : public traits_base::stored_value_type { typename Allocator::template rebind::other::pointer m_p_next; }; - typedef - typename Allocator::template rebind::other - entry_allocator; + typedef cond_dealtor cond_dealtor_t; + typedef typename Allocator::template rebind::other entry_allocator; typedef typename entry_allocator::pointer entry_pointer; - typedef typename entry_allocator::const_pointer const_entry_pointer; - typedef typename entry_allocator::reference entry_reference; + typedef typename entry_allocator::const_reference const_entry_reference; - typedef - typename entry_allocator::const_reference - const_entry_reference; - - typedef - typename Allocator::template rebind::other - entry_pointer_allocator; - + typedef typename Allocator::template rebind::other entry_pointer_allocator; typedef typename entry_pointer_allocator::pointer entry_pointer_array; - typedef typename PB_DS_TYPES_TRAITS_C_DEC::value_type value_type_; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::pointer pointer_; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_pointer - const_pointer_; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::reference reference_; + typedef PB_DS_RANGED_HASH_FN_C_DEC ranged_hash_fn_base; + typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base; + typedef Resize_Policy resize_base; - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_reference - const_reference_; +#ifdef _GLIBCXX_DEBUG + typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base; +#endif #define PB_DS_GEN_POS std::pair @@ -181,19 +175,12 @@ namespace pb_ds #undef PB_DS_GEN_POS public: - + typedef Allocator allocator; typedef typename Allocator::size_type size_type; - typedef typename Allocator::difference_type difference_type; - typedef Hash_Fn hash_fn; - typedef Eq_Fn eq_fn; - - typedef Allocator allocator; - typedef Comb_Hash_Fn comb_hash_fn; - typedef Resize_Policy resize_policy; enum @@ -201,49 +188,21 @@ namespace pb_ds store_hash = Store_Hash }; - typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_type key_type; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_pointer key_pointer; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_key_pointer - const_key_pointer; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_reference key_reference; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_key_reference - const_key_reference; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::mapped_type mapped_type; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::mapped_pointer - mapped_pointer; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_mapped_pointer - const_mapped_pointer; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::mapped_reference - mapped_reference; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_mapped_reference - const_mapped_reference; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::value_type value_type; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::pointer pointer; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::const_pointer const_pointer; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::reference reference; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_reference - const_reference; + typedef typename traits_base::key_type key_type; + typedef typename traits_base::key_pointer key_pointer; + typedef typename traits_base::const_key_pointer const_key_pointer; + typedef typename traits_base::key_reference key_reference; + typedef typename traits_base::const_key_reference const_key_reference; + typedef typename traits_base::mapped_type mapped_type; + typedef typename traits_base::mapped_pointer mapped_pointer; + typedef typename traits_base::const_mapped_pointer const_mapped_pointer; + typedef typename traits_base::mapped_reference mapped_reference; + typedef typename traits_base::const_mapped_reference const_mapped_reference; + typedef typename traits_base::value_type value_type; + typedef typename traits_base::pointer pointer; + typedef typename traits_base::const_pointer const_pointer; + typedef typename traits_base::reference reference; + typedef typename traits_base::const_reference const_reference; #ifdef PB_DS_DATA_TRUE_INDICATOR typedef point_iterator_ point_iterator; @@ -265,29 +224,28 @@ namespace pb_ds typedef const_iterator_ const_iterator; - public: - PB_DS_CLASS_NAME(); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn); + PB_DS_CLASS_NAME(const Hash_Fn&); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn); + PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Hash_Fn& r_comb_hash_fn); + PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Hash_Fn&); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Hash_Fn& r_comb_hash_fn, const Resize_Policy& r_resize_policy); + PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Hash_Fn&, + const Resize_Policy&); - PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other); + PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC&); virtual ~PB_DS_CLASS_NAME(); void - swap(PB_DS_CLASS_C_DEC& other); + swap(PB_DS_CLASS_C_DEC&); template void - copy_from_range(It first_it, It last_it); + copy_from_range(It, It); void initialize(); @@ -327,9 +285,7 @@ namespace pb_ds inline std::pair insert(const_reference r_val) - { - return insert_imp(r_val, traits_base::m_store_extra_indicator); - } + { return insert_imp(r_val, traits_base::m_store_extra_indicator); } inline mapped_reference operator[](const_key_reference r_key) @@ -343,10 +299,10 @@ namespace pb_ds } inline point_iterator - find(const_key_reference r_key); + find(const_key_reference); inline const_point_iterator - find(const_key_reference r_key) const; + find(const_key_reference) const; inline point_iterator find_end(); @@ -355,11 +311,11 @@ namespace pb_ds find_end() const; inline bool - erase(const_key_reference r_key); + erase(const_key_reference); template inline size_type - erase_if(Pred pred); + erase_if(Pred); void clear(); @@ -387,38 +343,6 @@ namespace pb_ds #endif private: - typedef PB_DS_TYPES_TRAITS_C_DEC traits_base; - - typedef PB_DS_RANGED_HASH_FN_C_DEC ranged_hash_fn_base; - - typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base; - - typedef Resize_Policy resize_base; - -#ifdef _GLIBCXX_DEBUG - typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base; -#endif - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::store_extra_false_type - store_hash_false_type; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::store_extra_true_type - store_hash_true_type; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC:: - no_throw_copies_false_type - no_throw_copies_false_type; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC:: - no_throw_copies_true_type - no_throw_copies_true_type; - - private: - void deallocate_all(); @@ -441,19 +365,19 @@ namespace pb_ds resize_imp_no_exceptions_reassign_pointer(entry_pointer, entry_pointer_array, store_hash_false_type); inline entry_pointer - resize_imp_no_exceptions_reassign_pointer(entry_pointer p_e, entry_pointer_array a_p_entries_resized, store_hash_true_type); + resize_imp_no_exceptions_reassign_pointer(entry_pointer, entry_pointer_array, store_hash_true_type); void - deallocate_links_in_list(entry_pointer p_e); + deallocate_links_in_list(entry_pointer); inline entry_pointer - get_entry(const_reference r_val, no_throw_copies_false_type); + get_entry(const_reference, no_throw_copies_false_type); inline entry_pointer - get_entry(const_reference r_val, no_throw_copies_true_type); + get_entry(const_reference, no_throw_copies_true_type); inline void - rels_entry(entry_pointer p_e); + rels_entry(entry_pointer); #ifdef PB_DS_DATA_TRUE_INDICATOR inline mapped_reference @@ -461,7 +385,7 @@ namespace pb_ds { _GLIBCXX_DEBUG_ONLY(assert_valid();) const size_type pos = ranged_hash_fn_base::operator()(r_key); - entry_pointer p_e = m_a_p_entries[pos]; + entry_pointer p_e = m_entries[pos]; resize_base::notify_insert_search_start(); while (p_e != NULL @@ -487,7 +411,7 @@ namespace pb_ds { _GLIBCXX_DEBUG_ONLY(assert_valid();) comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key); - entry_pointer p_e = m_a_p_entries[pos_hash_pair.first]; + entry_pointer p_e = m_entries[pos_hash_pair.first]; resize_base::notify_insert_search_start(); while (p_e != NULL && !hash_eq_fn_base::operator()(p_e->m_value.first, p_e->m_hash, r_key, pos_hash_pair.second)) @@ -504,15 +428,16 @@ namespace pb_ds } _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);) - return insert_new_imp(value_type(r_key, mapped_type()), pos_hash_pair)->second; + return insert_new_imp(value_type(r_key, mapped_type()), + pos_hash_pair)->second; } #endif inline std::pair - insert_imp(const_reference r_val, store_hash_false_type); + insert_imp(const_reference, store_hash_false_type); inline std::pair - insert_imp(const_reference r_val, store_hash_true_type); + insert_imp(const_reference, store_hash_true_type); inline pointer insert_new_imp(const_reference r_val, size_type pos) @@ -521,11 +446,11 @@ namespace pb_ds pos = ranged_hash_fn_base::operator()(PB_DS_V2F(r_val)); // Following lines might throw an exception. - entry_pointer p_e = get_entry(r_val, PB_DS_TYPES_TRAITS_C_DEC::m_no_throw_copies_indicator); + entry_pointer p_e = get_entry(r_val, traits_base::m_no_throw_copies_indicator); // At this point no exceptions can be thrown. - p_e->m_p_next = m_a_p_entries[pos]; - m_a_p_entries[pos] = p_e; + p_e->m_p_next = m_entries[pos]; + m_entries[pos] = p_e; resize_base::notify_inserted(++m_num_used_e); _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_val));) @@ -540,12 +465,12 @@ namespace pb_ds if (do_resize_if_needed()) r_pos_hash_pair = ranged_hash_fn_base::operator()(PB_DS_V2F(r_val)); - entry_pointer p_e = get_entry(r_val, PB_DS_TYPES_TRAITS_C_DEC::m_no_throw_copies_indicator); + entry_pointer p_e = get_entry(r_val, traits_base::m_no_throw_copies_indicator); // At this point no exceptions can be thrown. p_e->m_hash = r_pos_hash_pair.second; - p_e->m_p_next = m_a_p_entries[r_pos_hash_pair.first]; - m_a_p_entries[r_pos_hash_pair.first] = p_e; + p_e->m_p_next = m_entries[r_pos_hash_pair.first]; + m_entries[r_pos_hash_pair.first] = p_e; resize_base::notify_inserted(++m_num_used_e); _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_val));) _GLIBCXX_DEBUG_ONLY(assert_valid();) @@ -555,7 +480,7 @@ namespace pb_ds inline pointer find_key_pointer(const_key_reference r_key, store_hash_false_type) { - entry_pointer p_e = m_a_p_entries[ranged_hash_fn_base::operator()(r_key)]; + entry_pointer p_e = m_entries[ranged_hash_fn_base::operator()(r_key)]; resize_base::notify_find_search_start(); while (p_e != NULL && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key)) @@ -579,7 +504,7 @@ namespace pb_ds find_key_pointer(const_key_reference r_key, store_hash_true_type) { comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key); - entry_pointer p_e = m_a_p_entries[pos_hash_pair.first]; + entry_pointer p_e = m_entries[pos_hash_pair.first]; resize_base::notify_find_search_start(); while (p_e != NULL && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), @@ -602,17 +527,18 @@ namespace pb_ds } inline bool - erase_in_pos_imp(const_key_reference r_key, size_type pos); + erase_in_pos_imp(const_key_reference, size_type); inline bool - erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair); + erase_in_pos_imp(const_key_reference, const comp_hash&); inline void - erase_entry_pointer(entry_pointer& r_p_e); + erase_entry_pointer(entry_pointer&); #ifdef PB_DS_DATA_TRUE_INDICATOR void - inc_it_state(pointer& r_p_value, std::pair& r_pos) const + inc_it_state(pointer& r_p_value, + std::pair& r_pos) const { inc_it_state((const_mapped_pointer& )r_p_value, r_pos); } @@ -626,15 +552,15 @@ namespace pb_ds r_pos.first = r_pos.first->m_p_next; if (r_pos.first != NULL) { - r_p_value =& r_pos.first->m_value; + r_p_value = &r_pos.first->m_value; return; } - for (++r_pos.second; r_pos.second < m_num_e_p; ++r_pos.second) - if (m_a_p_entries[r_pos.second] != NULL) + for (++r_pos.second; r_pos.second < m_num_e; ++r_pos.second) + if (m_entries[r_pos.second] != NULL) { - r_pos.first = m_a_p_entries[r_pos.second]; - r_p_value =& r_pos.first->m_value; + r_pos.first = m_entries[r_pos.second]; + r_p_value = &r_pos.first->m_value; return; } r_p_value = NULL; @@ -644,11 +570,11 @@ namespace pb_ds get_start_it_state(pointer& r_p_value, std::pair& r_pos) const { - for (r_pos.second = 0; r_pos.second < m_num_e_p; ++r_pos.second) - if (m_a_p_entries[r_pos.second] != NULL) + for (r_pos.second = 0; r_pos.second < m_num_e; ++r_pos.second) + if (m_entries[r_pos.second] != NULL) { - r_pos.first = m_a_p_entries[r_pos.second]; - r_p_value =& r_pos.first->m_value; + r_pos.first = m_entries[r_pos.second]; + r_p_value = &r_pos.first->m_value; return; } r_p_value = NULL; @@ -673,31 +599,22 @@ namespace pb_ds #endif private: - static entry_allocator s_entry_allocator; - - static entry_pointer_allocator s_entry_pointer_allocator; - - typedef cond_dealtor< entry, Allocator> cond_dealtor_t; - - entry_pointer_array m_a_p_entries; - - size_type m_num_e_p; - - size_type m_num_used_e; - #ifdef PB_DS_DATA_TRUE_INDICATOR friend class iterator_; #endif friend class const_iterator_; - static iterator s_end_it; + static entry_allocator s_entry_allocator; + static entry_pointer_allocator s_entry_pointer_allocator; + static iterator s_end_it; + static const_iterator s_const_end_it; + static point_iterator s_find_end_it; + static const_point_iterator s_const_find_end_it; - static const_iterator s_const_end_it; - - static point_iterator s_find_end_it; - - static const_point_iterator s_const_find_end_it; + size_type m_num_e; + size_type m_num_used_e; + entry_pointer_array m_entries; enum { @@ -727,10 +644,8 @@ namespace pb_ds #undef PB_DS_TYPES_TRAITS_C_DEC #undef PB_DS_MAP_DEBUG_BASE_C_DEC #undef PB_DS_CLASS_NAME - #undef PB_DS_V2F #undef PB_DS_V2S - #undef PB_DS_STATIC_ASSERT } // namespace detail diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp index 9d6ee01efff..7273b0ff522 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp @@ -67,9 +67,8 @@ PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: PB_DS_CLASS_NAME() : ranged_hash_fn_base(resize_base::get_nearest_larger_size(1)), - m_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e_p(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_pointer_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -79,9 +78,8 @@ PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn) : ranged_hash_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn), - m_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e_p(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_pointer_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -92,13 +90,12 @@ PB_DS_CLASS_C_DEC:: PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) : PB_DS_HASH_EQ_FN_C_DEC(r_eq_fn), ranged_hash_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn), - m_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e_p(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_pointer_allocator.allocate(m_num_e)) { - std::fill(m_a_p_entries, m_a_p_entries + m_num_e_p, (entry_pointer)NULL); + std::fill(m_entries, m_entries + m_num_e, (entry_pointer)NULL); Resize_Policy::notify_cleared(); - ranged_hash_fn_base::notify_resized(m_num_e_p); + ranged_hash_fn_base::notify_resized(m_num_e); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) } @@ -107,11 +104,9 @@ PB_DS_CLASS_C_DEC:: PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Hash_Fn& r_comb_hash_fn) : PB_DS_HASH_EQ_FN_C_DEC(r_eq_fn), ranged_hash_fn_base(resize_base::get_nearest_larger_size(1), - r_hash_fn, - r_comb_hash_fn), - m_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e_p(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + r_hash_fn, r_comb_hash_fn), + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_pointer_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -123,11 +118,9 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Hash PB_DS_HASH_EQ_FN_C_DEC(r_eq_fn), Resize_Policy(r_resize_policy), ranged_hash_fn_base(resize_base::get_nearest_larger_size(1), - r_hash_fn, - r_comb_hash_fn), - m_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e_p(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + r_hash_fn, r_comb_hash_fn), + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_pointer_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -140,11 +133,9 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) : map_debug_base(other), #endif PB_DS_HASH_EQ_FN_C_DEC(other), - resize_base(other), - ranged_hash_fn_base(other), - m_a_p_entries(m_a_p_entries = s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e_p(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + resize_base(other), ranged_hash_fn_base(other), + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(m_entries = s_entry_pointer_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -152,7 +143,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) : { copy_from_range(other.begin(), other.end()); } - catch(...) + catch (...) { deallocate_all(); throw; @@ -173,8 +164,8 @@ swap(PB_DS_CLASS_C_DEC& other) _GLIBCXX_DEBUG_ONLY(assert_valid()); _GLIBCXX_DEBUG_ONLY(other.assert_valid()); - std::swap(m_a_p_entries, other.m_a_p_entries); - std::swap(m_num_e_p, other.m_num_e_p); + std::swap(m_entries, other.m_entries); + std::swap(m_num_e, other.m_num_e); std::swap(m_num_used_e, other.m_num_used_e); ranged_hash_fn_base::swap(other); hash_eq_fn_base::swap(other); @@ -191,7 +182,7 @@ PB_DS_CLASS_C_DEC:: deallocate_all() { clear(); - s_entry_pointer_allocator.deallocate(m_a_p_entries, m_num_e_p); + s_entry_pointer_allocator.deallocate(m_entries, m_num_e); } PB_DS_CLASS_T_DEC @@ -199,8 +190,8 @@ void PB_DS_CLASS_C_DEC:: initialize() { - std::fill(m_a_p_entries, m_a_p_entries + m_num_e_p, entry_pointer(NULL)); - Resize_Policy::notify_resized(m_num_e_p); + std::fill(m_entries, m_entries + m_num_e, entry_pointer(NULL)); + Resize_Policy::notify_resized(m_num_e); Resize_Policy::notify_cleared(); - ranged_hash_fn_base::notify_resized(m_num_e_p); + ranged_hash_fn_base::notify_resized(m_num_e); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp index 3bf820f94e6..7c38d1092e2 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp @@ -55,7 +55,7 @@ constructor_insert_new_imp(const_mapped_reference r_val, size_type pos, integral // At this point no exceptions can be thrown. - p_e->m_p_next = m_a_p_entries[pos]; - m_a_p_entries[pos] = p_e; + p_e->m_p_next = m_entries[pos]; + m_entries[pos] = p_e; _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(r_key);) } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp index 8dbbe5cbf99..6ebd1f722b7 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp @@ -55,9 +55,9 @@ constructor_insert_new_imp(const_reference r_val, size_type pos, true_type) traits_base::s_no_throw_copies_indicator); // At this point no exceptions can be thrown. - p_e->m_p_next = m_a_p_entries[pos]; + p_e->m_p_next = m_entries[pos]; p_e->m_hash = ranged_hash_fn_base::operator()((const_key_reference)(PB_DS_V2F(p_e->m_value))).second; - m_a_p_entries[pos] = p_e; + m_entries[pos] = p_e; _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(r_key);) } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp index 9de8696c422..61cbfa90d2e 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp @@ -52,7 +52,7 @@ PB_DS_CLASS_C_DEC:: assert_valid() const { map_debug_base::check_size(m_num_used_e); - assert_entry_pointer_array_valid(m_a_p_entries); + assert_entry_pointer_array_valid(m_entries); } PB_DS_CLASS_T_DEC @@ -61,7 +61,7 @@ PB_DS_CLASS_C_DEC:: assert_entry_pointer_array_valid(const entry_pointer_array a_p_entries) const { size_type iterated_num_used_e = 0; - for (size_type pos = 0; pos < m_num_e_p; ++pos) + for (size_type pos = 0; pos < m_num_e; ++pos) { entry_pointer p_e = a_p_entries[pos]; while (p_e != NULL) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp index be92f2f9c8d..3a821385028 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp @@ -70,25 +70,25 @@ erase_if(Pred pred) { size_type num_ersd = 0; - for (size_type pos = 0; pos < m_num_e_p; ++pos) + for (size_type pos = 0; pos < m_num_e; ++pos) { typedef typename PB_DS_TYPES_TRAITS_C_DEC::const_reference const_reference; - while (m_a_p_entries[pos] != NULL&& - pred(m_a_p_entries[pos]->m_value)) + while (m_entries[pos] != NULL&& + pred(m_entries[pos]->m_value)) { ++num_ersd; - entry_pointer p_next_e = m_a_p_entries[pos]->m_p_next; + entry_pointer p_next_e = m_entries[pos]->m_p_next; - erase_entry_pointer(m_a_p_entries[pos]); + erase_entry_pointer(m_entries[pos]); - m_a_p_entries[pos] = p_next_e; + m_entries[pos] = p_next_e; } - entry_pointer p_e = m_a_p_entries[pos]; + entry_pointer p_e = m_entries[pos]; while (p_e != NULL&& p_e->m_p_next != NULL) { @@ -113,9 +113,9 @@ void PB_DS_CLASS_C_DEC:: clear() { - for (size_type pos = 0; pos < m_num_e_p; ++pos) - while (m_a_p_entries[pos] != NULL) - erase_entry_pointer(m_a_p_entries[pos]); + for (size_type pos = 0; pos < m_num_e; ++pos) + while (m_entries[pos] != NULL) + erase_entry_pointer(m_entries[pos]); do_resize_if_needed_no_throw(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp index 3d3dd9d1f81..298c580c34e 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp @@ -63,7 +63,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos) { _GLIBCXX_DEBUG_ONLY(assert_valid();) - entry_pointer p_e = m_a_p_entries[pos]; + entry_pointer p_e = m_entries[pos]; resize_base::notify_erase_search_start(); @@ -88,7 +88,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos) _GLIBCXX_DEBUG_ONLY(map_debug_base:: check_key_exists(r_key);) - erase_entry_pointer(m_a_p_entries[pos]); + erase_entry_pointer(m_entries[pos]); do_resize_if_needed_no_throw(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp index 490c365c9fd..ddd898bdc7c 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp @@ -52,7 +52,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair) { _GLIBCXX_DEBUG_ONLY(assert_valid();) - entry_pointer p_e = m_a_p_entries[r_pos_hash_pair.first]; + entry_pointer p_e = m_entries[r_pos_hash_pair.first]; resize_base::notify_erase_search_start(); @@ -80,7 +80,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair) _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists( r_key);) - erase_entry_pointer(m_a_p_entries[r_pos_hash_pair.first]); + erase_entry_pointer(m_entries[r_pos_hash_pair.first]); do_resize_if_needed_no_throw(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp index 64ce3928f6a..41815c86608 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp @@ -58,7 +58,7 @@ insert_imp(const_reference r_val, store_hash_false_type) const size_type pos = ranged_hash_fn_base::operator()(r_key); - entry_pointer p_e = m_a_p_entries[pos]; + entry_pointer p_e = m_entries[pos]; resize_base::notify_insert_search_start(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp index b3841391d89..73a0aa9a02b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp @@ -58,7 +58,7 @@ insert_imp(const_reference r_val, store_hash_true_type) comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key); - entry_pointer p_e = m_a_p_entries[pos_hash_pair.first]; + entry_pointer p_e = m_entries[pos_hash_pair.first]; resize_base::notify_insert_search_start(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp index b508d4da138..fb692b50940 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp @@ -52,7 +52,7 @@ do_resize_if_needed() if (!resize_base::is_resize_needed()) return (false); - resize_imp(resize_base::get_new_size( m_num_e_p, m_num_used_e)); + resize_imp(resize_base::get_new_size( m_num_e, m_num_used_e)); return (true); } @@ -76,7 +76,7 @@ do_resize_if_needed_no_throw() try { - resize_imp(resize_base::get_new_size( m_num_e_p, m_num_used_e)); + resize_imp(resize_base::get_new_size( m_num_e, m_num_used_e)); } catch(...) { } @@ -91,10 +91,10 @@ resize_imp(size_type new_size) { _GLIBCXX_DEBUG_ONLY(assert_valid();) - if (new_size == m_num_e_p) + if (new_size == m_num_e) return; - const size_type old_size = m_num_e_p; + const size_type old_size = m_num_e; entry_pointer_array a_p_entries_resized; @@ -108,7 +108,7 @@ resize_imp(size_type new_size) a_p_entries_resized = s_entry_pointer_allocator.allocate(new_size); - m_num_e_p = new_size; + m_num_e = new_size; } catch(...) { @@ -131,23 +131,23 @@ void PB_DS_CLASS_C_DEC:: resize_imp_no_exceptions(size_type new_size, entry_pointer_array a_p_entries_resized, size_type old_size) { - std::fill(a_p_entries_resized, a_p_entries_resized + m_num_e_p,(entry_pointer)NULL); + std::fill(a_p_entries_resized, a_p_entries_resized + m_num_e,(entry_pointer)NULL); for (size_type pos = 0; pos < old_size; ++pos) { - entry_pointer p_e = m_a_p_entries[pos]; + entry_pointer p_e = m_entries[pos]; while (p_e != NULL) p_e = resize_imp_no_exceptions_reassign_pointer(p_e, a_p_entries_resized, traits_base::m_store_extra_indicator); } - m_num_e_p = new_size; + m_num_e = new_size; _GLIBCXX_DEBUG_ONLY(assert_entry_pointer_array_valid(a_p_entries_resized);) - s_entry_pointer_allocator.deallocate(m_a_p_entries, old_size); + s_entry_pointer_allocator.deallocate(m_entries, old_size); - m_a_p_entries = a_p_entries_resized; + m_entries = a_p_entries_resized; _GLIBCXX_DEBUG_ONLY(assert_valid();) } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp index 4c3e095ed26..e40a45c60ab 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp @@ -51,14 +51,14 @@ void PB_DS_CLASS_C_DEC:: trace() const { - std::cerr << static_cast(m_num_e_p) << " " << + std::cerr << static_cast(m_num_e) << " " << static_cast(m_num_used_e) << std::endl; - for (size_type i = 0; i < m_num_e_p; ++i) + for (size_type i = 0; i < m_num_e; ++i) { std::cerr << static_cast(i) << " "; - trace_list(m_a_p_entries[i]); + trace_list(m_entries[i]); std::cerr << std::endl; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp index 8a673e7c08b..91763669c76 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp @@ -49,7 +49,8 @@ PB_DS_CLASS_NAME() { } inline -PB_DS_CLASS_NAME(const PB_DS_CLASS_NAME& other) : base_type((const base_type&)other) +PB_DS_CLASS_NAME(const PB_DS_CLASS_NAME& other) +: base_type((const base_type&)other) { } template @@ -69,60 +70,40 @@ PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2) : base_type(t0, t1, t2) template inline -PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3) : base_type(t0, t1, t2, t3) +PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3) +: base_type(t0, t1, t2, t3) { } -template +template inline -PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) : base_type(t0, t1, t2, t3, t4) +PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) +: base_type(t0, t1, t2, t3, t4) { } -template inline -PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) : base_type(t0, t1, t2, t3, t4, t5) +PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) +: base_type(t0, t1, t2, t3, t4, t5) { } -template +template inline -PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) : base_type(t0, t1, t2, t3, t4, t5, t6) +PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) +: base_type(t0, t1, t2, t3, t4, t5, t6) { } -template +template inline -PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) : base_type(t0, t1, t2, t3, t4, t5, t6, t7) +PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) +: base_type(t0, t1, t2, t3, t4, t5, t6, t7) { } -template +template inline -PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) : base_type(t0, t1, t2, t3, t4, t5, t6, t7, t8) +PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) +: base_type(t0, t1, t2, t3, t4, t5, t6, t7, t8) { } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp index 817bcd0ca70..fa1d9b204e9 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp @@ -61,11 +61,10 @@ copy_from_range(It first_it, It last_it) PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -PB_DS_CLASS_NAME() : - ranged_probe_fn_base(resize_base::get_nearest_larger_size(1)), - m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) +PB_DS_CLASS_NAME() +: ranged_probe_fn_base(resize_base::get_nearest_larger_size(1)), + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -73,11 +72,10 @@ PB_DS_CLASS_NAME() : PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn) : - ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn), - m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) +PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn) +: ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn), + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -85,12 +83,11 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn) : PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) : - hash_eq_fn_base(r_eq_fn), +PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) +: hash_eq_fn_base(r_eq_fn), ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn), - m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -98,13 +95,13 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) : PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_hash_fn) : - hash_eq_fn_base(r_eq_fn), +PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, + const Comb_Probe_Fn& r_comb_hash_fn) +: hash_eq_fn_base(r_eq_fn), ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn, r_comb_hash_fn), - m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -112,13 +109,13 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Prob PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_hash_fn, const Probe_Fn& r_probe_fn) : - hash_eq_fn_base(r_eq_fn), +PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, + const Comb_Probe_Fn& comb_hash_fn, const Probe_Fn& probe_fn) +: hash_eq_fn_base(r_eq_fn), ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), - r_hash_fn, r_comb_hash_fn, r_probe_fn), - m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + r_hash_fn, comb_hash_fn, probe_fn), + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -126,14 +123,14 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Prob PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_hash_fn, const Probe_Fn& r_probe_fn, const Resize_Policy& r_resize_policy) : - hash_eq_fn_base(r_eq_fn), - resize_base(r_resize_policy), +PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, + const Comb_Probe_Fn& comb_hash_fn, const Probe_Fn& probe_fn, + const Resize_Policy& r_resize_policy) +: hash_eq_fn_base(r_eq_fn), resize_base(r_resize_policy), ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), - r_hash_fn, r_comb_hash_fn, r_probe_fn), - m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))), - m_num_e(resize_base::get_nearest_larger_size(1)), - m_num_used_e(0) + r_hash_fn, comb_hash_fn, probe_fn), + m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), + m_entries(s_entry_allocator.allocate(m_num_e)) { initialize(); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -148,37 +145,34 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) : hash_eq_fn_base(other), resize_base(other), ranged_probe_fn_base(other), - m_a_entries(s_entry_allocator.allocate(other.m_num_e)), m_num_e(other.m_num_e), - m_num_used_e(other.m_num_used_e) + m_num_used_e(other.m_num_used_e), + m_entries(s_entry_allocator.allocate(m_num_e)) { for (size_type i = 0; i < m_num_e; ++i) - m_a_entries[i].m_stat = (entry_status)empty_entry_status; + m_entries[i].m_stat = (entry_status)empty_entry_status; try { for (size_type i = 0; i < m_num_e; ++i) { - m_a_entries[i].m_stat = other.m_a_entries[i].m_stat; - if (m_a_entries[i].m_stat == valid_entry_status) - new (m_a_entries + i) entry(other.m_a_entries[i]); + m_entries[i].m_stat = other.m_entries[i].m_stat; + if (m_entries[i].m_stat == valid_entry_status) + new (m_entries + i) entry(other.m_entries[i]); } } - catch(...) + catch (...) { deallocate_all(); throw; } - _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) - } +} PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: ~PB_DS_CLASS_NAME() -{ - deallocate_all(); -} +{ deallocate_all(); } PB_DS_CLASS_T_DEC void @@ -187,9 +181,9 @@ swap(PB_DS_CLASS_C_DEC& other) { _GLIBCXX_DEBUG_ONLY(assert_valid()); _GLIBCXX_DEBUG_ONLY(other.assert_valid()); - std::swap(m_a_entries, other.m_a_entries); std::swap(m_num_e, other.m_num_e); std::swap(m_num_used_e, other.m_num_used_e); + std::swap(m_entries, other.m_entries); ranged_probe_fn_base::swap(other); hash_eq_fn_base::swap(other); resize_base::swap(other); @@ -204,8 +198,8 @@ PB_DS_CLASS_C_DEC:: deallocate_all() { clear(); - erase_all_valid_entries(m_a_entries, m_num_e); - s_entry_allocator.deallocate(m_a_entries, m_num_e); + erase_all_valid_entries(m_entries, m_num_e); + s_entry_allocator.deallocate(m_entries, m_num_e); } PB_DS_CLASS_T_DEC @@ -215,7 +209,7 @@ erase_all_valid_entries(entry_array a_entries_resized, size_type size) { for (size_type pos = 0; pos < size; ++pos) { - entry_pointer p_e =& a_entries_resized[pos]; + entry_pointer p_e = &a_entries_resized[pos]; if (p_e->m_stat == valid_entry_status) p_e->m_value.~value_type(); } @@ -230,6 +224,6 @@ initialize() Resize_Policy::notify_cleared(); ranged_probe_fn_base::notify_resized(m_num_e); for (size_type i = 0; i < m_num_e; ++i) - m_a_entries[i].m_stat = (entry_status)empty_entry_status; + m_entries[i].m_stat = empty_entry_status; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp index c7a3d403ff4..72d2a19f3bc 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp @@ -50,9 +50,9 @@ inline void PB_DS_CLASS_C_DEC:: constructor_insert_new_imp(const_mapped_reference r_val, size_type pos, integral_constant) { - _GLIBCXX_DEBUG_ASSERT(m_a_entries[pos].m_stat != valid_entry_status); + _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status); - entry* const p_e = m_a_entries + pos; + entry* const p_e = m_entries + pos; new (&p_e->m_value) mapped_value_type(r_val); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp index 74e5429b420..d532b84b0b8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp @@ -50,9 +50,9 @@ inline void PB_DS_CLASS_C_DEC:: constructor_insert_new_imp(const_mapped_reference r_val, size_type pos, true_type) { - _GLIBCXX_DEBUG_ASSERT(m_a_entries[pos].m_stat != valid_entry_status); + _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status); - entry* const p_e = m_a_entries + pos; + entry* const p_e = m_entries + pos; new (&p_e->m_value) mapped_value_type(r_val); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp index 1efdd183b80..fd8ca9abe12 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp @@ -52,7 +52,7 @@ PB_DS_CLASS_C_DEC:: assert_valid() const { map_debug_base::check_size(m_num_used_e); - assert_entry_array_valid(m_a_entries, traits_base::m_store_extra_indicator); + assert_entry_array_valid(m_entries, traits_base::m_store_extra_indicator); } #include diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp index df4f673bb5f..9da85072586 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp @@ -50,18 +50,9 @@ PB_DS_CLASS_C_DEC:: erase_entry(entry_pointer p_e) { _GLIBCXX_DEBUG_ASSERT(p_e->m_stat = valid_entry_status); - - _GLIBCXX_DEBUG_ONLY(map_debug_base::erase_existing( - PB_DS_V2F(p_e->m_value));) - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::stored_value_type - stored_value_type; - + _GLIBCXX_DEBUG_ONLY(map_debug_base::erase_existing(PB_DS_V2F(p_e->m_value));) p_e->m_value.~value_type(); - p_e->m_stat = erased_entry_status; - _GLIBCXX_DEBUG_ASSERT(m_num_used_e > 0); resize_base::notify_erased(--m_num_used_e); } @@ -73,14 +64,11 @@ clear() { for (size_type pos = 0; pos < m_num_e; ++pos) { - entry_pointer p_e =& m_a_entries[pos]; - + entry_pointer p_e = &m_entries[pos]; if (p_e->m_stat == valid_entry_status) erase_entry(p_e); } - do_resize_if_needed_no_throw(); - resize_base::notify_cleared(); } @@ -91,36 +79,28 @@ PB_DS_CLASS_C_DEC:: erase_if(Pred pred) { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) - - size_type num_ersd = 0; - + size_type num_ersd = 0; for (size_type pos = 0; pos < m_num_e; ++pos) { - entry_pointer p_e =& m_a_entries[pos]; - + entry_pointer p_e = &m_entries[pos]; if (p_e->m_stat == valid_entry_status) if (pred(p_e->m_value)) { ++num_ersd; - erase_entry(p_e); } } do_resize_if_needed_no_throw(); - _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) - - return (num_ersd); + return num_ersd; } PB_DS_CLASS_T_DEC inline bool PB_DS_CLASS_C_DEC:: erase(const_key_reference r_key) -{ - return (erase_imp(r_key, traits_base::m_store_extra_indicator)); -} +{ return erase_imp(r_key, traits_base::m_store_extra_indicator); } #include #include diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp index 0f6949a912d..94d1f871b9a 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp @@ -63,7 +63,7 @@ erase_imp(const_key_reference r_key, false_type) const size_type pos = ranged_probe_fn_base::operator()( r_key, hash, i); - entry* const p_e = m_a_entries + pos; + entry* const p_e = m_entries + pos; switch(p_e->m_stat) { diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp index d4eda6bda58..77f1aa31de8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp @@ -61,7 +61,7 @@ erase_imp(const_key_reference r_key, true_type) { const size_type pos = ranged_probe_fn_base::operator()( r_key, pos_hash_pair.second, i); - entry* const p_e = m_a_entries + pos; + entry* const p_e = m_entries + pos; switch(p_e->m_stat) { diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp index 2f89522744e..604dc40043f 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp @@ -50,8 +50,7 @@ PB_DS_CLASS_C_DEC:: find(const_key_reference r_key) { _GLIBCXX_DEBUG_ONLY(assert_valid();) - - return ((find_key_pointer(r_key, traits_base::m_store_extra_indicator))); + return find_key_pointer(r_key, traits_base::m_store_extra_indicator); } PB_DS_CLASS_T_DEC @@ -60,24 +59,18 @@ PB_DS_CLASS_C_DEC:: find(const_key_reference r_key) const { _GLIBCXX_DEBUG_ONLY(assert_valid();) - - return (const_cast(*this). - find_key_pointer(r_key, traits_base::m_store_extra_indicator)); + return const_cast(*this).find_key_pointer(r_key, traits_base::m_store_extra_indicator); } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::point_iterator PB_DS_CLASS_C_DEC:: find_end() -{ - return (NULL); -} +{ return NULL; } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::const_point_iterator PB_DS_CLASS_C_DEC:: find_end() const -{ - return (NULL); -} +{ return NULL; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp index 0497fbc8619..4d527bad2cc 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp @@ -62,18 +62,10 @@ namespace pb_ds { namespace detail { - -#define PB_DS_CLASS_T_DEC \ - template< \ - typename Key, \ - typename Mapped, \ - class Hash_Fn, \ - class Eq_Fn, \ - class Allocator, \ - bool Store_Hash, \ - class Comb_Probe_Fn, \ - class Probe_Fn, \ - class Resize_Policy> +#define PB_DS_CLASS_T_DEC \ + template #ifdef PB_DS_DATA_TRUE_INDICATOR #define PB_DS_CLASS_NAME gp_ht_map_data_ @@ -83,43 +75,21 @@ namespace pb_ds #define PB_DS_CLASS_NAME gp_ht_map_no_data_ #endif -#define PB_DS_CLASS_C_DEC \ - PB_DS_CLASS_NAME< \ - Key, \ - Mapped, \ - Hash_Fn, \ - Eq_Fn, \ - Allocator, \ - Store_Hash, \ - Comb_Probe_Fn, \ - Probe_Fn, \ - Resize_Policy> - -#define PB_DS_HASH_EQ_FN_C_DEC \ - hash_eq_fn< \ - Key, \ - Eq_Fn, \ - Allocator, \ - Store_Hash> - -#define PB_DS_RANGED_PROBE_FN_C_DEC \ - ranged_probe_fn< \ - Key, \ - Hash_Fn, \ - Allocator, \ - Comb_Probe_Fn, \ - Probe_Fn, \ - Store_Hash> - -#define PB_DS_TYPES_TRAITS_C_DEC \ - types_traits< \ - Key, \ - Mapped, \ - Allocator, \ - Store_Hash> +#define PB_DS_CLASS_C_DEC \ + PB_DS_CLASS_NAME + +#define PB_DS_HASH_EQ_FN_C_DEC \ + hash_eq_fn + +#define PB_DS_RANGED_PROBE_FN_C_DEC \ + ranged_probe_fn + +#define PB_DS_TYPES_TRAITS_C_DEC \ + types_traits #ifdef _GLIBCXX_DEBUG -#define PB_DS_MAP_DEBUG_BASE_C_DEC \ +#define PB_DS_MAP_DEBUG_BASE_C_DEC \ map_debug_base::other::const_reference> #endif @@ -133,21 +103,19 @@ namespace pb_ds #define PB_DS_V2S(X) Mapped() #endif -#define PB_DS_STATIC_ASSERT(UNIQUE, E) \ - typedef \ - static_assert_dumclass< \ - sizeof(static_assert<(bool)(E)>)> \ +#define PB_DS_STATIC_ASSERT(UNIQUE, E) \ + typedef static_assert_dumclass)> \ UNIQUE##static_assert_type template + typename Comb_Probe_Fn, + typename Probe_Fn, + typename Resize_Policy> class PB_DS_CLASS_NAME : #ifdef _GLIBCXX_DEBUG protected PB_DS_MAP_DEBUG_BASE_C_DEC, @@ -157,33 +125,46 @@ namespace pb_ds public PB_DS_RANGED_PROBE_FN_C_DEC, public PB_DS_TYPES_TRAITS_C_DEC { - private: + typedef PB_DS_TYPES_TRAITS_C_DEC traits_base; + typedef typename traits_base::store_extra_false_type store_hash_false_type; + typedef typename traits_base::store_extra_true_type store_hash_true_type; + typedef typename traits_base::value_type value_type_; + typedef typename traits_base::pointer pointer_; + typedef typename traits_base::const_pointer const_pointer_; + typedef typename traits_base::reference reference_; + typedef typename traits_base::const_reference const_reference_; + typedef typename traits_base::comp_hash comp_hash; + + enum entry_status + { + empty_entry_status, + valid_entry_status, + erased_entry_status + } __attribute__ ((packed)); - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::store_extra_false_type - store_hash_false_type; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::store_extra_true_type - store_hash_true_type; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::value_type value_type_; + struct entry : public traits_base::stored_value_type + { + entry_status m_stat; + }; - typedef typename PB_DS_TYPES_TRAITS_C_DEC::pointer pointer_; + typedef typename Allocator::template rebind::other entry_allocator; + typedef typename entry_allocator::pointer entry_pointer; + typedef typename entry_allocator::const_pointer const_entry_pointer; + typedef typename entry_allocator::reference entry_reference; + typedef typename entry_allocator::const_reference const_entry_reference; + typedef typename entry_allocator::pointer entry_array; - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_pointer - const_pointer_; + typedef PB_DS_RANGED_PROBE_FN_C_DEC ranged_probe_fn_base; - typedef typename PB_DS_TYPES_TRAITS_C_DEC::reference reference_; +#ifdef _GLIBCXX_DEBUG + typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base; +#endif - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_reference - const_reference_; + typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base; + typedef Resize_Policy resize_base; -#define PB_DS_GEN_POS \ - typename Allocator::size_type +#define PB_DS_GEN_POS typename Allocator::size_type #include #include @@ -193,21 +174,13 @@ namespace pb_ds #undef PB_DS_GEN_POS public: - + typedef Allocator allocator; typedef typename Allocator::size_type size_type; - typedef typename Allocator::difference_type difference_type; - typedef Hash_Fn hash_fn; - typedef Eq_Fn eq_fn; - - typedef Allocator allocator; - typedef Probe_Fn probe_fn; - typedef Comb_Probe_Fn comb_probe_fn; - typedef Resize_Policy resize_policy; enum @@ -215,85 +188,57 @@ namespace pb_ds store_hash = Store_Hash }; - typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_type key_type; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_pointer key_pointer; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_key_pointer - const_key_pointer; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_reference key_reference; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_key_reference - const_key_reference; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::mapped_type mapped_type; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::mapped_pointer - mapped_pointer; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_mapped_pointer - const_mapped_pointer; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::mapped_reference - mapped_reference; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_mapped_reference - const_mapped_reference; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::value_type value_type; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::pointer pointer; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::const_pointer const_pointer; - - typedef typename PB_DS_TYPES_TRAITS_C_DEC::reference reference; - - typedef - typename PB_DS_TYPES_TRAITS_C_DEC::const_reference - const_reference; + typedef typename traits_base::key_type key_type; + typedef typename traits_base::key_pointer key_pointer; + typedef typename traits_base::const_key_pointer const_key_pointer; + typedef typename traits_base::key_reference key_reference; + typedef typename traits_base::const_key_reference const_key_reference; + typedef typename traits_base::mapped_type mapped_type; + typedef typename traits_base::mapped_pointer mapped_pointer; + typedef typename traits_base::const_mapped_pointer const_mapped_pointer; + typedef typename traits_base::mapped_reference mapped_reference; + typedef typename traits_base::const_mapped_reference const_mapped_reference; + typedef typename traits_base::value_type value_type; + typedef typename traits_base::pointer pointer; + typedef typename traits_base::const_pointer const_pointer; + typedef typename traits_base::reference reference; + typedef typename traits_base::const_reference const_reference; #ifdef PB_DS_DATA_TRUE_INDICATOR typedef point_iterator_ point_iterator; -#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR +#endif #ifdef PB_DS_DATA_FALSE_INDICATOR typedef const_point_iterator_ point_iterator; -#endif // #ifdef PB_DS_DATA_FALSE_INDICATOR +#endif typedef const_point_iterator_ const_point_iterator; #ifdef PB_DS_DATA_TRUE_INDICATOR typedef iterator_ iterator; -#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR +#endif #ifdef PB_DS_DATA_FALSE_INDICATOR typedef const_iterator_ iterator; -#endif // #ifdef PB_DS_DATA_FALSE_INDICATOR +#endif typedef const_iterator_ const_iterator; - public: - PB_DS_CLASS_NAME(); - PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other); + PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC&); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn); + PB_DS_CLASS_NAME(const Hash_Fn&); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn); + PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_probe_fn); + PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn); + PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&, + const Probe_Fn&); - PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn, const Resize_Policy& r_resize_policy); + PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&, + const Probe_Fn&, const Resize_Policy&); template void @@ -348,20 +293,18 @@ namespace pb_ds insert(const_reference r_val) { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) - - return (insert_imp(r_val, traits_base::m_store_extra_indicator)); + return insert_imp(r_val, traits_base::m_store_extra_indicator); } inline mapped_reference operator[](const_key_reference r_key) { #ifdef PB_DS_DATA_TRUE_INDICATOR - return (subscript_imp(r_key, traits_base::m_store_extra_indicator)); -#else // #ifdef PB_DS_DATA_TRUE_INDICATOR + return subscript_imp(r_key, traits_base::m_store_extra_indicator); +#else insert(r_key); - - return (traits_base::s_null_mapped); -#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR + return traits_base::s_null_mapped; +#endif } inline point_iterator @@ -409,58 +352,12 @@ namespace pb_ds #endif private: - typedef PB_DS_TYPES_TRAITS_C_DEC traits_base; - - enum ENTRY_STATUS - { - empty_entry_status, - valid_entry_status, - erased_entry_status - }; - - typedef char entry_status; - - struct entry : public PB_DS_TYPES_TRAITS_C_DEC::stored_value_type - { - entry_status m_stat; - }; - - typedef - typename Allocator::template rebind::other - entry_allocator; - - typedef typename entry_allocator::pointer entry_pointer; - - typedef typename entry_allocator::const_pointer const_entry_pointer; - - typedef typename entry_allocator::reference entry_reference; - - typedef - typename entry_allocator::const_reference - const_entry_reference; - - typedef typename entry_allocator::pointer entry_array; - - typedef PB_DS_RANGED_PROBE_FN_C_DEC ranged_probe_fn_base; - -#ifdef _GLIBCXX_DEBUG - typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base; -#endif - - typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base; - - typedef Resize_Policy resize_base; - #ifdef PB_DS_DATA_TRUE_INDICATOR friend class iterator_; -#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR +#endif friend class const_iterator_; - typedef typename PB_DS_TYPES_TRAITS_C_DEC::comp_hash comp_hash; - - private: - void deallocate_all(); @@ -468,7 +365,7 @@ namespace pb_ds initialize(); void - erase_all_valid_entries(entry_array a_entries_resized, size_type size); + erase_all_valid_entries(entry_array, size_type); inline bool do_resize_if_needed(); @@ -477,175 +374,145 @@ namespace pb_ds do_resize_if_needed_no_throw(); void - resize_imp(size_type new_size); + resize_imp(size_type); virtual void - do_resize(size_type new_size); + do_resize(size_type); void - resize_imp(entry_array a_entries_resized, size_type old_size); + resize_imp(entry_array, size_type); inline void - resize_imp_reassign(entry_pointer p_e, entry_array a_entries_resized, store_hash_false_type); + resize_imp_reassign(entry_pointer, entry_array, store_hash_false_type); inline void - resize_imp_reassign(entry_pointer p_e, entry_array a_entries_resized, store_hash_true_type); + resize_imp_reassign(entry_pointer, entry_array, store_hash_true_type); inline size_type - find_ins_pos(const_key_reference r_key, store_hash_false_type); + find_ins_pos(const_key_reference, store_hash_false_type); inline comp_hash - find_ins_pos(const_key_reference r_key, store_hash_true_type); + find_ins_pos(const_key_reference, store_hash_true_type); inline std::pair - insert_imp(const_reference r_val, store_hash_false_type); + insert_imp(const_reference, store_hash_false_type); inline std::pair - insert_imp(const_reference r_val, store_hash_true_type); + insert_imp(const_reference, store_hash_true_type); inline pointer insert_new_imp(const_reference r_val, size_type pos) { - _GLIBCXX_DEBUG_ASSERT(m_a_entries[pos].m_stat != valid_entry_status); + _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status); if (do_resize_if_needed()) pos = find_ins_pos(PB_DS_V2F(r_val), traits_base::m_store_extra_indicator); - _GLIBCXX_DEBUG_ASSERT(m_a_entries[pos].m_stat != valid_entry_status); - - entry* const p_e = m_a_entries + pos; + _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status); + entry* const p_e = m_entries + pos; new (&p_e->m_value) value_type(r_val); - p_e->m_stat = valid_entry_status; - resize_base::notify_inserted(++m_num_used_e); - _GLIBCXX_DEBUG_ONLY(map_debug_base:: - insert_new(PB_DS_V2F(p_e->m_value));) + _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(p_e->m_value));) - _GLIBCXX_DEBUG_ONLY(assert_valid();) - - return (&p_e->m_value); + _GLIBCXX_DEBUG_ONLY(assert_valid();) + return &p_e->m_value; } inline pointer insert_new_imp(const_reference r_val, comp_hash& r_pos_hash_pair) { - _GLIBCXX_DEBUG_ASSERT(m_a_entries[r_pos_hash_pair.first].m_stat != + _GLIBCXX_DEBUG_ASSERT(m_entries[r_pos_hash_pair.first].m_stat != valid_entry_status); if (do_resize_if_needed()) - r_pos_hash_pair = find_ins_pos( - PB_DS_V2F(r_val), + r_pos_hash_pair = find_ins_pos(PB_DS_V2F(r_val), traits_base::m_store_extra_indicator); - _GLIBCXX_DEBUG_ASSERT(m_a_entries[r_pos_hash_pair.first].m_stat != - valid_entry_status); - - entry* const p_e = m_a_entries + r_pos_hash_pair.first; + _GLIBCXX_DEBUG_ASSERT(m_entries[r_pos_hash_pair.first].m_stat != + valid_entry_status); + entry* const p_e = m_entries + r_pos_hash_pair.first; new (&p_e->m_value) value_type(r_val); - p_e->m_hash = r_pos_hash_pair.second; - p_e->m_stat = valid_entry_status; resize_base::notify_inserted(++m_num_used_e); - _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new( - PB_DS_V2F(p_e->m_value));) - - _GLIBCXX_DEBUG_ONLY(assert_valid();) + _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(p_e->m_value));) - return (&p_e->m_value); + _GLIBCXX_DEBUG_ONLY(assert_valid();) + return &p_e->m_value; } #ifdef PB_DS_DATA_TRUE_INDICATOR inline mapped_reference - subscript_imp(const_key_reference r_key, store_hash_false_type) + subscript_imp(const_key_reference key, store_hash_false_type) { _GLIBCXX_DEBUG_ONLY(assert_valid();) - const size_type pos = - find_ins_pos(r_key, traits_base::m_store_extra_indicator); + const size_type pos = find_ins_pos(key, + traits_base::m_store_extra_indicator); - entry_pointer p_e =& m_a_entries[pos]; + entry_pointer p_e =& m_entries[pos]; if (p_e->m_stat != valid_entry_status) - return (insert_new_imp( - value_type( - r_key, - mapped_type()), - pos)->second); - - _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);) + return insert_new_imp(value_type(key, mapped_type()), pos)->second; - return (p_e->m_value.second); + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);) + return p_e->m_value.second; } inline mapped_reference - subscript_imp(const_key_reference r_key, store_hash_true_type) + subscript_imp(const_key_reference key, store_hash_true_type) { _GLIBCXX_DEBUG_ONLY(assert_valid();) - comp_hash pos_hash_pair = - find_ins_pos(r_key, traits_base::m_store_extra_indicator); + comp_hash pos_hash_pair = + find_ins_pos(key, traits_base::m_store_extra_indicator); - if (m_a_entries[pos_hash_pair.first].m_stat != valid_entry_status) - return (insert_new_imp( - value_type( - r_key, - mapped_type()), - pos_hash_pair)->second); + if (m_entries[pos_hash_pair.first].m_stat != valid_entry_status) + return insert_new_imp(value_type(key, mapped_type()), + pos_hash_pair)->second; - _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key)); - - return ((m_a_entries + pos_hash_pair.first)->m_value.second); + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key)); + return (m_entries + pos_hash_pair.first)->m_value.second; } -#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR +#endif inline pointer - find_key_pointer(const_key_reference r_key, store_hash_false_type) + find_key_pointer(const_key_reference key, store_hash_false_type) { - const size_type hash = ranged_probe_fn_base::operator()(r_key); - + const size_type hash = ranged_probe_fn_base::operator()(key); size_type i; - resize_base::notify_find_search_start(); // Loop until entry is found or until all possible entries accessed. - for (i = 0; i < m_num_e; ++i) { - const size_type pos = - ranged_probe_fn_base::operator()( r_key, hash, i); - - entry* const p_e = m_a_entries + pos; + const size_type pos = ranged_probe_fn_base::operator()(key, hash, i); - switch(p_e->m_stat) + entry* const p_e = m_entries + pos; + switch (p_e->m_stat) { case empty_entry_status: { resize_base::notify_find_search_end(); + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);) - _GLIBCXX_DEBUG_ONLY(map_debug_base:: - check_key_does_not_exist(r_key);) - - return (NULL); + return NULL; } break; case valid_entry_status: - if (hash_eq_fn_base::operator()( - PB_DS_V2F(p_e->m_value), - r_key)) + if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), key)) { resize_base::notify_find_search_end(); + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);) - _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);) - - return ((pointer)&p_e->m_value); + return pointer(&p_e->m_value); } break; case erased_entry_status: @@ -657,55 +524,44 @@ namespace pb_ds resize_base::notify_find_search_collision(); } - _GLIBCXX_DEBUG_ONLY(map_debug_base:: - check_key_does_not_exist(r_key);) - - resize_base::notify_find_search_end(); - - return (NULL); + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);) + resize_base::notify_find_search_end(); + return NULL; } inline pointer - find_key_pointer(const_key_reference r_key, store_hash_true_type) + find_key_pointer(const_key_reference key, store_hash_true_type) { - comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key); - + comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(key); size_type i; - resize_base::notify_find_search_start(); // Loop until entry is found or until all possible entries accessed. - for (i = 0; i < m_num_e; ++i) { const size_type pos = - ranged_probe_fn_base::operator()( r_key, pos_hash_pair.second, i); + ranged_probe_fn_base::operator()(key, pos_hash_pair.second, i); - entry* const p_e = m_a_entries + pos; + entry* const p_e = m_entries + pos; switch(p_e->m_stat) { case empty_entry_status: { resize_base::notify_find_search_end(); + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);) - _GLIBCXX_DEBUG_ONLY(map_debug_base:: - check_key_does_not_exist(r_key);) - - return (NULL); + return NULL; } break; case valid_entry_status: - if (hash_eq_fn_base::operator()( - PB_DS_V2F(p_e->m_value), + if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), p_e->m_hash, - r_key, pos_hash_pair.second)) + key, pos_hash_pair.second)) { resize_base::notify_find_search_end(); - - _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);) - - return ((pointer)&p_e->m_value); + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);) + return pointer(&p_e->m_value); } break; case erased_entry_status: @@ -717,19 +573,16 @@ namespace pb_ds resize_base::notify_find_search_collision(); } - _GLIBCXX_DEBUG_ONLY(map_debug_base:: - check_key_does_not_exist(r_key);) - - resize_base::notify_find_search_end(); - - return (NULL); + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);) + resize_base::notify_find_search_end(); + return NULL; } inline bool - erase_imp(const_key_reference r_key, true_type); + erase_imp(const_key_reference, true_type); inline bool - erase_imp(const_key_reference r_key, false_type); + erase_imp(const_key_reference, false_type); inline void erase_entry(entry_pointer p_e); @@ -737,28 +590,22 @@ namespace pb_ds #ifdef PB_DS_DATA_TRUE_INDICATOR void inc_it_state(pointer& r_p_value, size_type& r_pos) const - { - inc_it_state((const_mapped_pointer& )r_p_value, r_pos); - } -#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR + { inc_it_state((const_mapped_pointer& )r_p_value, r_pos); } +#endif void inc_it_state(const_pointer& r_p_value, size_type& r_pos) const { _GLIBCXX_DEBUG_ASSERT(r_p_value != NULL); - for (++r_pos; r_pos < m_num_e; ++r_pos) { - const_entry_pointer p_e =& m_a_entries[r_pos]; - + const_entry_pointer p_e =& m_entries[r_pos]; if (p_e->m_stat == valid_entry_status) { r_p_value =& p_e->m_value; - return; } } - r_p_value = NULL; } @@ -767,16 +614,13 @@ namespace pb_ds { for (r_pos = 0; r_pos < m_num_e; ++r_pos) { - const_entry_pointer p_e =& m_a_entries[r_pos]; - + const_entry_pointer p_e = &m_entries[r_pos]; if (p_e->m_stat == valid_entry_status) { - r_p_value =& p_e->m_value; - + r_p_value = &p_e->m_value; return; } } - r_p_value = NULL; } @@ -785,49 +629,36 @@ namespace pb_ds { for (r_pos = 0; r_pos < m_num_e; ++r_pos) { - entry_pointer p_e =& m_a_entries[r_pos]; - + entry_pointer p_e = &m_entries[r_pos]; if (p_e->m_stat == valid_entry_status) { - r_p_value =& p_e->m_value; - + r_p_value = &p_e->m_value; return; } } - r_p_value = NULL; } #ifdef _GLIBCXX_DEBUG void - assert_entry_array_valid(const entry_array a_entries, - store_hash_false_type) const; + assert_entry_array_valid(const entry_array, store_hash_false_type) const; void - assert_entry_array_valid(const entry_array a_entries, - store_hash_true_type) const; + assert_entry_array_valid(const entry_array, store_hash_true_type) const; #endif - private: - static entry_allocator s_entry_allocator; - - entry_pointer m_a_entries; - - size_type m_num_e; - - size_type m_num_used_e; + static entry_allocator s_entry_allocator; + static iterator s_end_it; + static const_iterator s_const_end_it; - static iterator s_end_it; - - static const_iterator s_const_end_it; + size_type m_num_e; + size_type m_num_used_e; + entry_pointer m_entries; enum { - store_hash_ok = - !Store_Hash || - !is_same< - Hash_Fn, - pb_ds::null_hash_fn>::value + store_hash_ok = !Store_Hash + || !is_same::value }; PB_DS_STATIC_ASSERT(sth, store_hash_ok); @@ -845,22 +676,14 @@ namespace pb_ds #include #undef PB_DS_CLASS_T_DEC - #undef PB_DS_CLASS_C_DEC - #undef PB_DS_HASH_EQ_FN_C_DEC - #undef PB_DS_RANGED_PROBE_FN_C_DEC - #undef PB_DS_TYPES_TRAITS_C_DEC - #undef PB_DS_MAP_DEBUG_BASE_C_DEC - #undef PB_DS_CLASS_NAME - #undef PB_DS_V2F #undef PB_DS_V2S - #undef PB_DS_STATIC_ASSERT } // namespace detail diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp index ef5ea837ff7..dcb712e303d 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp @@ -68,7 +68,7 @@ find_ins_pos(const_key_reference r_key, store_hash_false_type) _GLIBCXX_DEBUG_ASSERT(pos < m_num_e); - entry* const p_e = m_a_entries + pos; + entry* const p_e = m_entries + pos; switch(p_e->m_stat) { @@ -122,12 +122,12 @@ insert_imp(const_reference r_val, store_hash_false_type) const size_type pos = find_ins_pos(r_key, traits_base::m_store_extra_indicator); - if (m_a_entries[pos].m_stat == valid_entry_status) + if (m_entries[pos].m_stat == valid_entry_status) { _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);) return (std::make_pair( - & (m_a_entries + pos)->m_value, + & (m_entries + pos)->m_value, false)); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp index 4f2ae016ed8..4ef9b202d79 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp @@ -51,8 +51,7 @@ PB_DS_CLASS_C_DEC:: find_ins_pos(const_key_reference r_key, store_hash_true_type) { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) - - comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key); + comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key); size_type i; @@ -60,26 +59,21 @@ find_ins_pos(const_key_reference r_key, store_hash_true_type) * that it has not been initted yet. */ size_type ins_pos = m_num_e; - resize_base::notify_insert_search_start(); - for (i = 0; i < m_num_e; ++i) { - const size_type pos = - ranged_probe_fn_base::operator()(r_key, pos_hash_pair.second, i); - - entry* const p_e = m_a_entries + pos; + const size_type pos = ranged_probe_fn_base::operator()(r_key, pos_hash_pair.second, i); + entry* const p_e = m_entries + pos; switch(p_e->m_stat) { case empty_entry_status: { resize_base::notify_insert_search_end(); - _GLIBCXX_DEBUG_ONLY( - map_debug_base::check_key_does_not_exist(r_key);) + _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);) - return ((ins_pos == m_num_e)? + return ((ins_pos == m_num_e) ? std::make_pair(pos, pos_hash_pair.second) : std::make_pair(ins_pos, pos_hash_pair.second)); } @@ -89,32 +83,23 @@ find_ins_pos(const_key_reference r_key, store_hash_true_type) ins_pos = pos; break; case valid_entry_status: - if (hash_eq_fn_base::operator()( - PB_DS_V2F(p_e->m_value), - p_e->m_hash, - r_key, - pos_hash_pair.second)) + if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), p_e->m_hash, + r_key, pos_hash_pair.second)) { resize_base::notify_insert_search_end(); - _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);) - - return (std::make_pair(pos, pos_hash_pair.second)); + return std::make_pair(pos, pos_hash_pair.second); } break; default: _GLIBCXX_DEBUG_ASSERT(0); }; - resize_base::notify_insert_search_collision(); } - resize_base::notify_insert_search_end(); - if (ins_pos == m_num_e) throw insert_error(); - - return (std::make_pair(ins_pos, pos_hash_pair.second)); + return std::make_pair(ins_pos, pos_hash_pair.second); } PB_DS_CLASS_T_DEC @@ -123,25 +108,18 @@ PB_DS_CLASS_C_DEC:: insert_imp(const_reference r_val, store_hash_true_type) { const_key_reference r_key = PB_DS_V2F(r_val); - - comp_hash pos_hash_pair = - find_ins_pos(r_key, traits_base::m_store_extra_indicator); + comp_hash pos_hash_pair = find_ins_pos(r_key, + traits_base::m_store_extra_indicator); _GLIBCXX_DEBUG_ASSERT(pos_hash_pair.first < m_num_e); - - entry_pointer p_e =& m_a_entries[pos_hash_pair.first]; - + entry_pointer p_e =& m_entries[pos_hash_pair.first]; if (p_e->m_stat == valid_entry_status) { _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key)); - - return (std::make_pair(&p_e->m_value, false)); + return std::make_pair(&p_e->m_value, false); } _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key)); - - return (std::make_pair( - insert_new_imp(r_val, pos_hash_pair), - true)); + return std::make_pair(insert_new_imp(r_val, pos_hash_pair), true); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp index fb31e2b0d1f..d7998048cfe 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp @@ -50,21 +50,16 @@ PB_DS_CLASS_C_DEC:: do_resize_if_needed() { if (!resize_base::is_resize_needed()) - return (false); - - resize_imp(resize_base::get_new_size( m_num_e, m_num_used_e)); - - return (true); + return false; + resize_imp(resize_base::get_new_size(m_num_e, m_num_used_e)); + return true; } PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: -do_resize(size_type size) -{ - resize_imp(resize_base::get_nearest_larger_size( - size)); -} +do_resize(size_type n) +{ resize_imp(resize_base::get_nearest_larger_size(n)); } PB_DS_CLASS_T_DEC inline void @@ -76,13 +71,13 @@ do_resize_if_needed_no_throw() try { - resize_imp(resize_base::get_new_size( m_num_e, m_num_used_e)); + resize_imp(resize_base::get_new_size(m_num_e, m_num_used_e)); } - catch(...) + catch (...) { } _GLIBCXX_DEBUG_ONLY(assert_valid();) - } +} PB_DS_CLASS_T_DEC void @@ -91,23 +86,19 @@ resize_imp(size_type new_size) { #ifdef PB_DS_REGRESSION typename Allocator::group_throw_prob_adjustor adjust(m_num_e); -#endif // #ifdef PB_DS_REGRESSION +#endif if (new_size == m_num_e) return; _GLIBCXX_DEBUG_ONLY(assert_valid();) - - const size_type old_size = m_num_e; - + const size_type old_size = m_num_e; entry_array a_entries_resized = NULL; // Following line might throw an exception. - a_entries_resized = s_entry_allocator.allocate(new_size); ranged_probe_fn_base::notify_resized(new_size); - m_num_e = new_size; for (size_type i = 0; i < m_num_e; ++i) @@ -117,33 +108,24 @@ resize_imp(size_type new_size) { resize_imp(a_entries_resized, old_size); } - catch(...) + catch (...) { erase_all_valid_entries(a_entries_resized, new_size); - m_num_e = old_size; - s_entry_allocator.deallocate(a_entries_resized, new_size); - ranged_probe_fn_base::notify_resized(old_size); - throw; } // At this point no exceptions can be thrown. - _GLIBCXX_DEBUG_ONLY(assert_entry_array_valid(a_entries_resized, traits_base::m_store_extra_indicator);) - Resize_Policy::notify_resized(new_size); - - erase_all_valid_entries(m_a_entries, old_size); - - s_entry_allocator.deallocate(m_a_entries, old_size); - - m_a_entries = a_entries_resized; - + Resize_Policy::notify_resized(new_size); + erase_all_valid_entries(m_entries, old_size); + s_entry_allocator.deallocate(m_entries, old_size); + m_entries = a_entries_resized; _GLIBCXX_DEBUG_ONLY(assert_valid();) - } +} PB_DS_CLASS_T_DEC void @@ -151,8 +133,9 @@ PB_DS_CLASS_C_DEC:: resize_imp(entry_array a_entries_resized, size_type old_size) { for (size_type pos = 0; pos < old_size; ++pos) - if (m_a_entries[pos].m_stat == valid_entry_status) - resize_imp_reassign(m_a_entries + pos, a_entries_resized, traits_base::m_store_extra_indicator); + if (m_entries[pos].m_stat == valid_entry_status) + resize_imp_reassign(m_entries + pos, a_entries_resized, + traits_base::m_store_extra_indicator); } #include diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp index f41e38040e1..78240c4219c 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp @@ -58,7 +58,7 @@ trace() const { std::cerr << static_cast(i) << " "; - switch(m_a_entries[i].m_stat) + switch(m_entries[i].m_stat) { case empty_entry_status: std::cerr << ""; @@ -67,7 +67,7 @@ trace() const std::cerr << ""; break; case valid_entry_status: - std::cerr << PB_DS_V2F(m_a_entries[i].m_value); + std::cerr << PB_DS_V2F(m_entries[i].m_value); break; default: _GLIBCXX_DEBUG_ASSERT(0); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp index c12901c8641..5295134a5c9 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp @@ -48,23 +48,17 @@ PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: swap(PB_DS_CLASS_C_DEC& other) -{ - mask_based_base::swap(other); -} +{ mask_based_base::swap(other); } PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: notify_resized(size_type size) -{ - mask_based_base::notify_resized(size); -} +{ mask_based_base::notify_resized(size); } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: operator()(size_type hash) const -{ - return (mask_based_base::range_hash(hash)); -} +{ return mask_based_base::range_hash(hash); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp index e6f2fe9bec1..5edff69aa95 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp @@ -48,23 +48,17 @@ PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: swap(PB_DS_CLASS_C_DEC& other) -{ - mod_based_base::swap(other); -} +{ mod_based_base::swap(other); } PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: -notify_resized(size_type size) -{ - mod_based_base::notify_resized(size); -} +notify_resized(size_type n) +{ mod_based_base::notify_resized(n); } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: operator()(size_type hash) const -{ - return (mod_based_base::range_hash(hash)); -} +{ return mod_based_base::range_hash(hash); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp index 68d0c2b973b..4aa1894bade 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp @@ -49,16 +49,10 @@ namespace pb_ds { - namespace detail { - -#define PB_DS_CLASS_T_DEC \ - template - -#define PB_DS_CLASS_C_DEC \ - mask_based_range_hashing< \ - Size_Type> +#define PB_DS_CLASS_T_DEC template +#define PB_DS_CLASS_C_DEC mask_based_range_hashing template class mask_based_range_hashing @@ -66,22 +60,21 @@ namespace pb_ds protected: typedef Size_Type size_type; - protected: void - swap(PB_DS_CLASS_C_DEC& other); + swap(mask_based_range_hashing& other) + { std::swap(m_mask, other.m_mask); } void notify_resized(size_type size); inline size_type - range_hash(size_type hash) const; + range_hash(size_type hash) const + { return size_type(hash & m_mask); } private: - size_type m_mask; - - const static size_type s_num_bits_in_size_type; - - const static size_type s_highest_bit_1; + size_type m_mask; + const static size_type s_num_bits_in_size_type; + const static size_type s_highest_bit_1; }; PB_DS_CLASS_T_DEC @@ -90,52 +83,31 @@ namespace pb_ds sizeof(typename PB_DS_CLASS_C_DEC::size_type) << 3; PB_DS_CLASS_T_DEC - const typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC::s_highest_bit_1 = - static_cast(1) << (s_num_bits_in_size_type - 1); - - PB_DS_CLASS_T_DEC - void - PB_DS_CLASS_C_DEC:: - swap(PB_DS_CLASS_C_DEC& other) - { - std::swap(m_mask, other.m_mask); - } + const typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC::s_highest_bit_1 = static_cast(1) << (s_num_bits_in_size_type - 1); + PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: notify_resized(size_type size) { size_type i = 0; - while (size ^ s_highest_bit_1) { size <<= 1; - ++i; } m_mask = 1; - i += 2; - while (i++ < s_num_bits_in_size_type) m_mask = (m_mask << 1) ^ 1; } - PB_DS_CLASS_T_DEC - inline typename PB_DS_CLASS_C_DEC::size_type - PB_DS_CLASS_C_DEC:: - range_hash(size_type hash) const - { - return (hash& m_mask); - } - #undef PB_DS_CLASS_T_DEC #undef PB_DS_CLASS_C_DEC } // namespace detail - } // namespace pb_ds -#endif // #ifndef PB_DS_MASK_BASED_RANGE_HASHING_HPP +#endif diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp index 6fddfeb9d28..d4b834dd34f 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp @@ -57,48 +57,29 @@ namespace pb_ds namespace detail { template class ranged_probe_fn; -#define PB_DS_CLASS_T_DEC \ - template< \ - typename Key, \ - class Hash_Fn, \ - class Allocator, \ - class Comb_Probe_Fn, \ - class Probe_Fn> - -#define PB_DS_CLASS_C_DEC \ - ranged_probe_fn< \ - Key, \ - Hash_Fn, \ - Allocator, \ - Comb_Probe_Fn, \ - Probe_Fn, \ - false> +#define PB_DS_CLASS_T_DEC \ + template + +#define PB_DS_CLASS_C_DEC \ + ranged_probe_fn /** * Specialization 1- The client supplies a probe function and a ranged * probe function, and requests that hash values not be stored. **/ - template - class ranged_probe_fn< - Key, - Hash_Fn, - Allocator, - Comb_Probe_Fn, - Probe_Fn, - false> : public Hash_Fn, - public Comb_Probe_Fn, - public Probe_Fn + template + class ranged_probe_fn + : public Hash_Fn, public Comb_Probe_Fn, public Probe_Fn { protected: typedef typename Allocator::size_type size_type; @@ -138,26 +119,20 @@ namespace pb_ds PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: ranged_probe_fn(size_type size) - { - Comb_Probe_Fn::notify_resized(size); - } + { Comb_Probe_Fn::notify_resized(size); } PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn) : Hash_Fn(r_hash_fn) - { - Comb_Probe_Fn::notify_resized(size); - } + { Comb_Probe_Fn::notify_resized(size); } PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn) : Hash_Fn(r_hash_fn), Comb_Probe_Fn(r_comb_probe_fn) - { - comb_probe_fn_base::notify_resized(size); - } + { comb_probe_fn_base::notify_resized(size); } PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: @@ -165,9 +140,7 @@ namespace pb_ds Hash_Fn(r_hash_fn), Comb_Probe_Fn(r_comb_probe_fn), Probe_Fn(r_probe_fn) - { - comb_probe_fn_base::notify_resized(size); - } + { comb_probe_fn_base::notify_resized(size); } PB_DS_CLASS_T_DEC void @@ -175,75 +148,48 @@ namespace pb_ds swap(PB_DS_CLASS_C_DEC& other) { comb_probe_fn_base::swap(other); - - std::swap((Hash_Fn& )(*this), (Hash_Fn& )other); + std::swap((Hash_Fn& )(*this), (Hash_Fn&)other); } PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: notify_resized(size_type size) - { - comb_probe_fn_base::notify_resized(size); - } + { comb_probe_fn_base::notify_resized(size); } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: operator()(const_key_reference r_key) const - { - return (comb_probe_fn_base::operator()( - hash_fn_base::operator()(r_key))); - } + { return comb_probe_fn_base::operator()(hash_fn_base::operator()(r_key)); } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: - operator()(const_key_reference /*r_key*/, size_type hash, size_type i) const + operator()(const_key_reference, size_type hash, size_type i) const { - return (comb_probe_fn_base::operator()( - hash + probe_fn_base::operator()(i))); + return comb_probe_fn_base::operator()(hash + probe_fn_base::operator()(i)); } #undef PB_DS_CLASS_T_DEC #undef PB_DS_CLASS_C_DEC -#define PB_DS_CLASS_T_DEC \ - template< \ - typename Key, \ - class Hash_Fn, \ - class Allocator, \ - class Comb_Probe_Fn, \ - class Probe_Fn> - -#define PB_DS_CLASS_C_DEC \ - ranged_probe_fn< \ - Key, \ - Hash_Fn, \ - Allocator, \ - Comb_Probe_Fn, \ - Probe_Fn, \ - true> +#define PB_DS_CLASS_T_DEC \ + template + +#define PB_DS_CLASS_C_DEC \ + ranged_probe_fn /** * Specialization 2- The client supplies a probe function and a ranged * probe function, and requests that hash values not be stored. **/ - template - class ranged_probe_fn< - Key, - Hash_Fn, - Allocator, - Comb_Probe_Fn, - Probe_Fn, - true> : - public Hash_Fn, - public Comb_Probe_Fn, - public Probe_Fn + template + class ranged_probe_fn + : public Hash_Fn, public Comb_Probe_Fn, public Probe_Fn { protected: typedef typename Allocator::size_type size_type; @@ -260,14 +206,16 @@ namespace pb_ds typedef typename key_allocator::const_reference const_key_reference; - protected: ranged_probe_fn(size_type size); ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn); - ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn); + ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, + const Comb_Probe_Fn& r_comb_probe_fn); - ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn); + ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, + const Comb_Probe_Fn& r_comb_probe_fn, + const Probe_Fn& r_probe_fn); void swap(PB_DS_CLASS_C_DEC& other); @@ -298,14 +246,17 @@ namespace pb_ds PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: - ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn) : + ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, + const Comb_Probe_Fn& r_comb_probe_fn) : Hash_Fn(r_hash_fn), Comb_Probe_Fn(r_comb_probe_fn) { comb_probe_fn_base::notify_resized(size); } PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: - ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn) : + ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, + const Comb_Probe_Fn& r_comb_probe_fn, + const Probe_Fn& r_probe_fn) : Hash_Fn(r_hash_fn), Comb_Probe_Fn(r_comb_probe_fn), Probe_Fn(r_probe_fn) @@ -338,7 +289,7 @@ namespace pb_ds PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: - operator()(const_key_reference /*r_key*/, size_type hash, size_type i) const + operator()(const_key_reference, size_type hash, size_type i) const { return comb_probe_fn_base::operator()(hash + probe_fn_base::operator()(i)); } @@ -360,33 +311,14 @@ namespace pb_ds #undef PB_DS_CLASS_T_DEC #undef PB_DS_CLASS_C_DEC -#define PB_DS_CLASS_T_DEC \ - template - -#define PB_DS_CLASS_C_DEC \ - ranged_probe_fn< \ - Key, \ - null_hash_fn, \ - Allocator, \ - Comb_Probe_Fn, \ - null_probe_fn, \ - false> - /** * Specialization 3 and 4- The client does not supply a hash function or * probe function, and requests that hash values not be stored. **/ - template - class ranged_probe_fn< - Key, - null_hash_fn, - Allocator, - Comb_Probe_Fn, - null_probe_fn, - false> : - public Comb_Probe_Fn, - public null_hash_fn, - public null_probe_fn + template + class ranged_probe_fn + : public Comb_Probe_Fn, public null_hash_fn, public null_probe_fn { protected: typedef typename Allocator::size_type size_type; @@ -397,42 +329,23 @@ namespace pb_ds typedef typename key_allocator::const_reference const_key_reference; - protected: - ranged_probe_fn(size_type size); + ranged_probe_fn(size_type size) + { Comb_Probe_Fn::notify_resized(size); } - ranged_probe_fn(size_type size, const Comb_Probe_Fn& r_comb_probe_fn); + ranged_probe_fn(size_type size, const Comb_Probe_Fn& r_comb_probe_fn) + : Comb_Probe_Fn(r_comb_probe_fn) + { } - ranged_probe_fn(size_type size, const null_hash_fn& r_null_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const null_probe_fn& r_null_probe_fn); + ranged_probe_fn(size_type size, const null_hash_fn& r_null_hash_fn, + const Comb_Probe_Fn& r_comb_probe_fn, + const null_probe_fn& r_null_probe_fn) + : Comb_Probe_Fn(r_comb_probe_fn) + { } void - swap(PB_DS_CLASS_C_DEC& other); + swap(ranged_probe_fn& other) + { comb_probe_fn_base::swap(other); } }; - - PB_DS_CLASS_T_DEC - PB_DS_CLASS_C_DEC:: - ranged_probe_fn(size_type size) - { Comb_Probe_Fn::notify_resized(size); } - - PB_DS_CLASS_T_DEC - PB_DS_CLASS_C_DEC:: - ranged_probe_fn(size_type size, const Comb_Probe_Fn& r_comb_probe_fn) : - Comb_Probe_Fn(r_comb_probe_fn) - { } - - PB_DS_CLASS_T_DEC - PB_DS_CLASS_C_DEC:: - ranged_probe_fn(size_type size, const null_hash_fn& r_null_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const null_probe_fn& r_null_probe_fn) : - Comb_Probe_Fn(r_comb_probe_fn) - { } - - PB_DS_CLASS_T_DEC - void - PB_DS_CLASS_C_DEC:: - swap(PB_DS_CLASS_C_DEC& other) - { comb_probe_fn_base::swap(other); } - -#undef PB_DS_CLASS_T_DEC -#undef PB_DS_CLASS_C_DEC } // namespace detail } // namespace pb_ds diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp index 242169cd7ba..b3854318bf0 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp @@ -353,7 +353,7 @@ namespace pb_ds if (pot_it != end()&& !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it))) { _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key)); - return (++pot_it); + return ++pot_it; } _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key)); @@ -362,17 +362,17 @@ namespace pb_ds inline const_point_iterator upper_bound(const_key_reference r_key) const - { return const_cast(*this).upper_bound(r_key); } + { return const_cast(*this).upper_bound(r_key); } inline point_iterator find(const_key_reference r_key) { _GLIBCXX_DEBUG_ONLY(assert_valid();) iterator pot_it = lower_bound(r_key); - if (pot_it != end()&& !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it))) + if (pot_it != end() && !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it))) { _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key)); - return (pot_it); + return pot_it; } _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key)); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp index 8303c3fd3de..18f24bd7b29 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp @@ -127,8 +127,8 @@ namespace detail PB_DS_CLASS_T_DEC inline PB_DS_CLASS_C_DEC:: -hash_prime_size_policy(size_type start_size) : m_start_size(start_size) -{ m_start_size = get_nearest_larger_size(start_size); } +hash_prime_size_policy(size_type n) : m_start_size(n) +{ m_start_size = get_nearest_larger_size(n); } PB_DS_CLASS_T_DEC inline void @@ -139,10 +139,10 @@ swap(PB_DS_CLASS_C_DEC& other) PB_DS_CLASS_T_DEC inline PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: -get_nearest_larger_size(size_type size) const +get_nearest_larger_size(size_type n) const { const std::size_t* const p_upper = std::upper_bound(detail::g_a_sizes, - detail::g_a_sizes + detail::num_distinct_sizes, size); + detail::g_a_sizes + detail::num_distinct_sizes, n); if (p_upper == detail::g_a_sizes + detail::num_distinct_sizes) throw resize_error(); @@ -152,12 +152,12 @@ get_nearest_larger_size(size_type size) const PB_DS_CLASS_T_DEC inline PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: -get_nearest_smaller_size(size_type size) const +get_nearest_smaller_size(size_type n) const { const size_t* p_lower = std::lower_bound(detail::g_a_sizes, - detail::g_a_sizes + detail::num_distinct_sizes, size); + detail::g_a_sizes + detail::num_distinct_sizes, n); - if (*p_lower >= size&& p_lower != detail::g_a_sizes) + if (*p_lower >= n && p_lower != detail::g_a_sizes) --p_lower; if (*p_lower < m_start_size) return m_start_size; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp index bbea0b2a364..e6edf0254b8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp @@ -49,23 +49,21 @@ PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -hash_standard_resize_policy() : - m_size(Size_Policy::get_nearest_larger_size(1)) +hash_standard_resize_policy() +: m_size(Size_Policy::get_nearest_larger_size(1)) { trigger_policy_base::notify_externally_resized(m_size); } PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -hash_standard_resize_policy(const Size_Policy& r_size_policy) : - Size_Policy(r_size_policy), - m_size(Size_Policy::get_nearest_larger_size(1)) +hash_standard_resize_policy(const Size_Policy& r_size_policy) +: Size_Policy(r_size_policy), m_size(Size_Policy::get_nearest_larger_size(1)) { trigger_policy_base::notify_externally_resized(m_size); } PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: hash_standard_resize_policy(const Size_Policy& r_size_policy, - const Trigger_Policy& r_trigger_policy) : - Size_Policy(r_size_policy), - Trigger_Policy(r_trigger_policy), + const Trigger_Policy& r_trigger_policy) +: Size_Policy(r_size_policy), Trigger_Policy(r_trigger_policy), m_size(Size_Policy::get_nearest_larger_size(1)) { trigger_policy_base::notify_externally_resized(m_size); } @@ -167,8 +165,7 @@ typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: get_new_size(size_type size, size_type num_used_e) const { - if (trigger_policy_base:: - is_grow_needed(size, num_used_e)) + if (trigger_policy_base::is_grow_needed(size, num_used_e)) return size_policy_base::get_nearest_larger_size(size); return size_policy_base::get_nearest_smaller_size(size); } @@ -197,24 +194,23 @@ PB_DS_CLASS_C_DEC:: resize(size_type new_size) { PB_DS_STATIC_ASSERT(access, external_size_access); - size_type actual_new_size = size_policy_base::get_nearest_larger_size(1); - while (actual_new_size < new_size) + size_type actual_size = size_policy_base::get_nearest_larger_size(1); + while (actual_size < new_size) { - const size_type pot = - size_policy_base::get_nearest_larger_size(actual_new_size); + const size_type pot = size_policy_base::get_nearest_larger_size(actual_size); - if (pot == actual_new_size&& pot < new_size) + if (pot == actual_size && pot < new_size) throw resize_error(); - actual_new_size = pot; + actual_size = pot; } - if (actual_new_size > 0) - --actual_new_size; + if (actual_size > 0) + --actual_size; const size_type old_size = m_size; try { - do_resize(actual_new_size - 1); + do_resize(actual_size - 1); } catch(insert_error& ) { diff --git a/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp b/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp index 88f8757ce41..b51e252cd29 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp @@ -55,47 +55,34 @@ namespace pb_ds { namespace detail { - - template + template struct vt_base_selector { - typedef value_type_base< Key, Mapped, Allocator, Store_Extra> type; + typedef value_type_base type; }; - template + template struct types_traits - : public vt_base_selector::type + : public vt_base_selector::type { - typedef typename Allocator::template rebind< Key>::other key_allocator; - + typedef typename Alloc::template rebind< Key>::other key_allocator; typedef typename key_allocator::value_type key_type; - typedef typename key_allocator::pointer key_pointer; - typedef typename key_allocator::const_pointer const_key_pointer; - typedef typename key_allocator::reference key_reference; - typedef typename key_allocator::const_reference const_key_reference; - - typedef typename Allocator::size_type size_type; - + typedef typename Alloc::size_type size_type; typedef false_type store_extra_false_type; - typedef true_type store_extra_true_type; - - integral_constant m_store_extra_indicator; - typedef false_type no_throw_copies_false_type; - typedef true_type no_throw_copies_true_type; - typename no_throw_copies::indicator - m_no_throw_copies_indicator; + integral_constant m_store_extra_indicator; + typename no_throw_copies::indicator m_no_throw_copies_indicator; // Extra value (used when the extra value is stored with each value). - typedef typename comp_hash_< size_type>::comp_hash comp_hash; + typedef typename comp_hash_::comp_hash comp_hash; }; } // namespace detail -- cgit v1.2.1