/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp |
---|
0,0 → 1,223 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/constructor_destructor_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s constructors, destructor, |
* and related functions. |
*/ |
PB_DS_CLASS_T_DEC |
typename PB_DS_CLASS_C_DEC::entry_allocator |
PB_DS_CLASS_C_DEC::s_entry_allocator; |
PB_DS_CLASS_T_DEC |
template<typename It> |
void |
PB_DS_CLASS_C_DEC:: |
copy_from_range(It first_it, It last_it) |
{ |
while (first_it != last_it) |
insert(*(first_it++)); |
} |
PB_DS_CLASS_T_DEC |
PB_DS_CLASS_C_DEC:: |
PB_DS_GP_HASH_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(); |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
PB_DS_CLASS_C_DEC:: |
PB_DS_GP_HASH_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(); |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
PB_DS_CLASS_C_DEC:: |
PB_DS_GP_HASH_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_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), |
m_entries(s_entry_allocator.allocate(m_num_e)) |
{ |
initialize(); |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
PB_DS_CLASS_C_DEC:: |
PB_DS_GP_HASH_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_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), |
m_entries(s_entry_allocator.allocate(m_num_e)) |
{ |
initialize(); |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
PB_DS_CLASS_C_DEC:: |
PB_DS_GP_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, |
const Comb_Probe_Fn& comb_hash_fn, const Probe_Fn& prober) |
: hash_eq_fn_base(r_eq_fn), |
ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), |
r_hash_fn, comb_hash_fn, prober), |
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(); |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
PB_DS_CLASS_C_DEC:: |
PB_DS_GP_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, |
const Comb_Probe_Fn& comb_hash_fn, const Probe_Fn& prober, |
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, comb_hash_fn, prober), |
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(); |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
PB_DS_CLASS_C_DEC:: |
PB_DS_GP_HASH_NAME(const PB_DS_CLASS_C_DEC& other) : |
#ifdef _GLIBCXX_DEBUG |
debug_base(other), |
#endif |
hash_eq_fn_base(other), |
resize_base(other), |
ranged_probe_fn_base(other), |
m_num_e(other.m_num_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_entries[i].m_stat = (entry_status)empty_entry_status; |
__try |
{ |
for (size_type i = 0; i < m_num_e; ++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(...) |
{ |
deallocate_all(); |
__throw_exception_again; |
} |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
PB_DS_CLASS_C_DEC:: |
~PB_DS_GP_HASH_NAME() |
{ deallocate_all(); } |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
swap(PB_DS_CLASS_C_DEC& other) |
{ |
PB_DS_ASSERT_VALID((*this)) |
PB_DS_ASSERT_VALID(other) |
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); |
_GLIBCXX_DEBUG_ONLY(debug_base::swap(other)); |
PB_DS_ASSERT_VALID((*this)) |
PB_DS_ASSERT_VALID(other) |
} |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
deallocate_all() |
{ |
clear(); |
erase_all_valid_entries(m_entries, m_num_e); |
s_entry_allocator.deallocate(m_entries, m_num_e); |
} |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
erase_all_valid_entries(entry_array a_entries_resized, size_type len) |
{ |
for (size_type pos = 0; pos < len; ++pos) |
{ |
entry_pointer p_e = &a_entries_resized[pos]; |
if (p_e->m_stat == valid_entry_status) |
p_e->m_value.~value_type(); |
} |
} |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
initialize() |
{ |
Resize_Policy::notify_resized(m_num_e); |
Resize_Policy::notify_cleared(); |
ranged_probe_fn_base::notify_resized(m_num_e); |
for (size_type i = 0; i < m_num_e; ++i) |
m_entries[i].m_stat = empty_entry_status; |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp |
---|
0,0 → 1,53 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s constructors, destructor, |
* and related functions. |
*/ |
PB_DS_CLASS_T_DEC |
inline void |
PB_DS_CLASS_C_DEC:: |
constructor_insert_new_imp(mapped_const_reference r_val, size_type pos, |
false_type) |
{ |
_GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status)k; |
entry* const p_e = m_entries + pos; |
new (&p_e->m_value) mapped_value_type(r_val); |
p_e->m_stat = valid_entry_status; |
_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(p_e->m_value.first);) |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp |
---|
0,0 → 1,54 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s constructors, destructor, |
* and related functions. |
*/ |
PB_DS_CLASS_T_DEC |
inline void |
PB_DS_CLASS_C_DEC:: |
constructor_insert_new_imp(mapped_const_reference r_val, size_type pos, |
true_type) |
{ |
_GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status); |
entry* const p_e = m_entries + pos; |
new (&p_e->m_value) mapped_value_type(r_val); |
p_e->m_hash = ranged_probe_fn_base::operator()(PB_DS_V2F(r_val)).second; |
p_e->m_stat = valid_entry_status; |
_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(p_e->m_value.first);) |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp |
---|
0,0 → 1,56 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/debug_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s debug-mode functions. |
*/ |
#ifdef _GLIBCXX_DEBUG |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
assert_valid(const char* __file, int __line) const |
{ |
debug_base::check_size(m_num_used_e, __file, __line); |
assert_entry_array_valid(m_entries, traits_base::m_store_extra_indicator, |
__file, __line); |
} |
#include <ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp> |
#endif |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp |
---|
0,0 → 1,72 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s debug-mode functions. |
*/ |
#ifdef _GLIBCXX_DEBUG |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
assert_entry_array_valid(const entry_array a_entries, false_type, |
const char* __file, int __line) const |
{ |
size_type iterated_num_used_e = 0; |
for (size_type pos = 0; pos < m_num_e; ++pos) |
{ |
const_entry_pointer p_e = &a_entries[pos]; |
switch(p_e->m_stat) |
{ |
case empty_entry_status: |
case erased_entry_status: |
break; |
case valid_entry_status: |
{ |
key_const_reference r_key = PB_DS_V2F(p_e->m_value); |
debug_base::check_key_exists(r_key, __file, __line); |
++iterated_num_used_e; |
break; |
} |
default: |
PB_DS_DEBUG_VERIFY(0); |
}; |
} |
PB_DS_DEBUG_VERIFY(iterated_num_used_e == m_num_used_e); |
} |
#endif |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp |
---|
0,0 → 1,78 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/debug_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s debug-mode functions. |
*/ |
#ifdef _GLIBCXX_DEBUG |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
assert_entry_array_valid(const entry_array a_entries, true_type, |
const char* __file, int __line) const |
{ |
size_type iterated_num_used_e = 0; |
for (size_type pos = 0; pos < m_num_e; ++pos) |
{ |
const_entry_pointer p_e =& a_entries[pos]; |
switch(p_e->m_stat) |
{ |
case empty_entry_status: |
case erased_entry_status: |
break; |
case valid_entry_status: |
{ |
key_const_reference r_key = PB_DS_V2F(p_e->m_value); |
debug_base::check_key_exists(r_key, __file, __line); |
const comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key); |
PB_DS_DEBUG_VERIFY(p_e->m_hash == pos_hash_pair.second); |
++iterated_num_used_e; |
break; |
} |
default: |
PB_DS_DEBUG_VERIFY(0); |
}; |
} |
PB_DS_DEBUG_VERIFY(iterated_num_used_e == m_num_used_e); |
} |
#endif |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp |
---|
0,0 → 1,100 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/erase_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s erase related functions. |
*/ |
PB_DS_CLASS_T_DEC |
inline void |
PB_DS_CLASS_C_DEC:: |
erase_entry(entry_pointer p_e) |
{ |
_GLIBCXX_DEBUG_ASSERT(p_e->m_stat = valid_entry_status); |
_GLIBCXX_DEBUG_ONLY(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); |
} |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
clear() |
{ |
for (size_type pos = 0; pos < m_num_e; ++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(); |
} |
PB_DS_CLASS_T_DEC |
template<typename Pred> |
inline typename PB_DS_CLASS_C_DEC::size_type |
PB_DS_CLASS_C_DEC:: |
erase_if(Pred pred) |
{ |
PB_DS_ASSERT_VALID((*this)) |
size_type num_ersd = 0; |
for (size_type pos = 0; pos < m_num_e; ++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(); |
PB_DS_ASSERT_VALID((*this)) |
return num_ersd; |
} |
PB_DS_CLASS_T_DEC |
inline bool |
PB_DS_CLASS_C_DEC:: |
erase(key_const_reference r_key) |
{ return erase_imp(r_key, traits_base::m_store_extra_indicator); } |
#include <ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp> |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp |
---|
0,0 → 1,84 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s erase related functions, |
* when the hash value is not stored. |
*/ |
PB_DS_CLASS_T_DEC |
inline bool |
PB_DS_CLASS_C_DEC:: |
erase_imp(key_const_reference r_key, false_type) |
{ |
PB_DS_ASSERT_VALID((*this)) |
size_type hash = ranged_probe_fn_base::operator()(r_key); |
size_type i; |
resize_base::notify_erase_search_start(); |
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_entries + pos; |
switch(p_e->m_stat) |
{ |
case empty_entry_status: |
{ |
resize_base::notify_erase_search_end(); |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) |
return false; |
} |
break; |
case valid_entry_status: |
if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key)) |
{ |
resize_base::notify_erase_search_end(); |
erase_entry(p_e); |
do_resize_if_needed_no_throw(); |
return true; |
} |
break; |
case erased_entry_status: |
break; |
default: |
_GLIBCXX_DEBUG_ASSERT(0); |
}; |
resize_base::notify_erase_search_collision(); |
} |
resize_base::notify_erase_search_end(); |
return false; |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp |
---|
0,0 → 1,85 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/erase_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s erase related functions, |
* when the hash value is stored. |
*/ |
PB_DS_CLASS_T_DEC |
inline bool |
PB_DS_CLASS_C_DEC:: |
erase_imp(key_const_reference r_key, true_type) |
{ |
const comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key); |
size_type i; |
resize_base::notify_erase_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_entries + pos; |
switch(p_e->m_stat) |
{ |
case empty_entry_status: |
{ |
resize_base::notify_erase_search_end(); |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) |
return false; |
} |
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)) |
{ |
resize_base::notify_erase_search_end(); |
erase_entry(p_e); |
do_resize_if_needed_no_throw(); |
return true; |
} |
break; |
case erased_entry_status: |
break; |
default: |
_GLIBCXX_DEBUG_ASSERT(0); |
}; |
resize_base::notify_erase_search_collision(); |
} |
resize_base::notify_erase_search_end(); |
return false; |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp |
---|
0,0 → 1,70 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/find_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s find related functions. |
*/ |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::point_iterator |
PB_DS_CLASS_C_DEC:: |
find(key_const_reference r_key) |
{ |
PB_DS_ASSERT_VALID((*this)) |
return find_key_pointer(r_key, traits_base::m_store_extra_indicator); |
} |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::point_const_iterator |
PB_DS_CLASS_C_DEC:: |
find(key_const_reference r_key) const |
{ |
PB_DS_ASSERT_VALID((*this)) |
return const_cast<PB_DS_CLASS_C_DEC&>(*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 0; } |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::point_const_iterator |
PB_DS_CLASS_C_DEC:: |
find_end() const |
{ return 0; } |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_no_store_hash_fn_imps.hpp |
---|
0,0 → 1,46 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/find_no_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s find related functions, |
* when the hash value is not stored. |
*/ |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::pointer |
PB_DS_CLASS_C_DEC:: |
find_key_pointer(key_const_reference r_key, false_type) |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_store_hash_fn_imps.hpp |
---|
0,0 → 1,40 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/find_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s insert related functions, |
* when the hash value is stored. |
*/ |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp |
---|
0,0 → 1,713 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/gp_ht_map_.hpp |
* Contains an implementation class for general probing hash. |
*/ |
#include <ext/pb_ds/tag_and_trait.hpp> |
#include <ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp> |
#include <ext/pb_ds/detail/types_traits.hpp> |
#include <ext/pb_ds/exception.hpp> |
#include <ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp> |
#include <utility> |
#ifdef PB_DS_HT_MAP_TRACE_ |
#include <iostream> |
#endif |
#ifdef _GLIBCXX_DEBUG |
#include <ext/pb_ds/detail/debug_map_base.hpp> |
#endif |
#include <debug/debug.h> |
namespace __gnu_pbds |
{ |
namespace detail |
{ |
#ifdef PB_DS_DATA_TRUE_INDICATOR |
#define PB_DS_GP_HASH_NAME gp_ht_map |
#endif |
#ifdef PB_DS_DATA_FALSE_INDICATOR |
#define PB_DS_GP_HASH_NAME gp_ht_set |
#endif |
#define PB_DS_CLASS_T_DEC \ |
template<typename Key, typename Mapped, typename Hash_Fn, typename Eq_Fn, \ |
typename _Alloc, bool Store_Hash, typename Comb_Probe_Fn, \ |
typename Probe_Fn, typename Resize_Policy> |
#define PB_DS_CLASS_C_DEC \ |
PB_DS_GP_HASH_NAME<Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, \ |
Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy> |
#define PB_DS_HASH_EQ_FN_C_DEC \ |
hash_eq_fn<Key, Eq_Fn, _Alloc, Store_Hash> |
#define PB_DS_RANGED_PROBE_FN_C_DEC \ |
ranged_probe_fn<Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, Store_Hash> |
#define PB_DS_GP_HASH_TRAITS_BASE \ |
types_traits<Key, Mapped, _Alloc, Store_Hash> |
#ifdef _GLIBCXX_DEBUG |
#define PB_DS_DEBUG_MAP_BASE_C_DEC \ |
debug_map_base<Key, Eq_Fn, \ |
typename _Alloc::template rebind<Key>::other::const_reference> |
#endif |
/** |
* A general-probing hash-based container. |
* |
* |
* @ingroup hash-detail |
* |
* @tparam Key Key type. |
* |
* @tparam Mapped Map type. |
* |
* @tparam Hash_Fn Hashing functor. |
* Default is __gnu_cxx::hash. |
* |
* @tparam Eq_Fn Equal functor. |
* Default std::equal_to<Key> |
* |
* @tparam _Alloc Allocator type. |
* |
* @tparam Store_Hash If key type stores extra metadata. |
* Defaults to false. |
* |
* @tparam Comb_Probe_Fn Combining probe functor. |
* If Hash_Fn is not null_type, then this |
* is the ranged-probe functor; otherwise, |
* this is the range-hashing functor. |
* XXX See Design::Hash-Based Containers::Hash Policies. |
* Default direct_mask_range_hashing. |
* |
* @tparam Probe_Fn Probe functor. |
* Defaults to linear_probe_fn, |
* also quadratic_probe_fn. |
* |
* @tparam Resize_Policy Resizes hash. |
* Defaults to hash_standard_resize_policy, |
* using hash_exponential_size_policy and |
* hash_load_check_resize_trigger. |
* |
* |
* Bases are: detail::hash_eq_fn, Resize_Policy, detail::ranged_probe_fn, |
* detail::types_traits. (Optional: detail::debug_map_base.) |
*/ |
template<typename Key, |
typename Mapped, |
typename Hash_Fn, |
typename Eq_Fn, |
typename _Alloc, |
bool Store_Hash, |
typename Comb_Probe_Fn, |
typename Probe_Fn, |
typename Resize_Policy> |
class PB_DS_GP_HASH_NAME : |
#ifdef _GLIBCXX_DEBUG |
protected PB_DS_DEBUG_MAP_BASE_C_DEC, |
#endif |
public PB_DS_HASH_EQ_FN_C_DEC, |
public Resize_Policy, |
public PB_DS_RANGED_PROBE_FN_C_DEC, |
public PB_DS_GP_HASH_TRAITS_BASE |
{ |
private: |
typedef PB_DS_GP_HASH_TRAITS_BASE traits_base; |
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)); |
struct entry : public traits_base::stored_data_type |
{ |
entry_status m_stat; |
}; |
typedef typename _Alloc::template rebind<entry>::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_DEBUG_MAP_BASE_C_DEC debug_base; |
#endif |
typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base; |
typedef Resize_Policy resize_base; |
#define PB_DS_GEN_POS typename _Alloc::size_type |
#include <ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp> |
#include <ext/pb_ds/detail/unordered_iterator/point_iterator.hpp> |
#include <ext/pb_ds/detail/unordered_iterator/const_iterator.hpp> |
#include <ext/pb_ds/detail/unordered_iterator/iterator.hpp> |
#undef PB_DS_GEN_POS |
public: |
typedef _Alloc allocator_type; |
typedef typename _Alloc::size_type size_type; |
typedef typename _Alloc::difference_type difference_type; |
typedef Hash_Fn hash_fn; |
typedef Eq_Fn eq_fn; |
typedef Probe_Fn probe_fn; |
typedef Comb_Probe_Fn comb_probe_fn; |
typedef Resize_Policy resize_policy; |
/// Value stores hash, true or false. |
enum |
{ |
store_hash = Store_Hash |
}; |
typedef typename traits_base::key_type key_type; |
typedef typename traits_base::key_pointer key_pointer; |
typedef typename traits_base::key_const_pointer key_const_pointer; |
typedef typename traits_base::key_reference key_reference; |
typedef typename traits_base::key_const_reference key_const_reference; |
typedef typename traits_base::mapped_type mapped_type; |
typedef typename traits_base::mapped_pointer mapped_pointer; |
typedef typename traits_base::mapped_const_pointer mapped_const_pointer; |
typedef typename traits_base::mapped_reference mapped_reference; |
typedef typename traits_base::mapped_const_reference mapped_const_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_FALSE_INDICATOR |
typedef point_const_iterator_ point_iterator; |
#endif |
typedef point_const_iterator_ point_const_iterator; |
#ifdef PB_DS_DATA_TRUE_INDICATOR |
typedef iterator_ iterator; |
#endif |
#ifdef PB_DS_DATA_FALSE_INDICATOR |
typedef const_iterator_ iterator; |
#endif |
typedef const_iterator_ const_iterator; |
PB_DS_GP_HASH_NAME(); |
PB_DS_GP_HASH_NAME(const PB_DS_CLASS_C_DEC&); |
PB_DS_GP_HASH_NAME(const Hash_Fn&); |
PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&); |
PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&); |
PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&, |
const Probe_Fn&); |
PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&, |
const Probe_Fn&, const Resize_Policy&); |
template<typename It> |
void |
copy_from_range(It, It); |
virtual |
~PB_DS_GP_HASH_NAME(); |
void |
swap(PB_DS_CLASS_C_DEC&); |
inline size_type |
size() const; |
inline size_type |
max_size() const; |
/// True if size() == 0. |
inline bool |
empty() const; |
/// Return current hash_fn. |
Hash_Fn& |
get_hash_fn(); |
/// Return current const hash_fn. |
const Hash_Fn& |
get_hash_fn() const; |
/// Return current eq_fn. |
Eq_Fn& |
get_eq_fn(); |
/// Return current const eq_fn. |
const Eq_Fn& |
get_eq_fn() const; |
/// Return current probe_fn. |
Probe_Fn& |
get_probe_fn(); |
/// Return current const probe_fn. |
const Probe_Fn& |
get_probe_fn() const; |
/// Return current comb_probe_fn. |
Comb_Probe_Fn& |
get_comb_probe_fn(); |
/// Return current const comb_probe_fn. |
const Comb_Probe_Fn& |
get_comb_probe_fn() const; |
/// Return current resize_policy. |
Resize_Policy& |
get_resize_policy(); |
/// Return current const resize_policy. |
const Resize_Policy& |
get_resize_policy() const; |
inline std::pair<point_iterator, bool> |
insert(const_reference r_val) |
{ |
_GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid(__FILE__, __LINE__);) |
return insert_imp(r_val, traits_base::m_store_extra_indicator); |
} |
inline mapped_reference |
operator[](key_const_reference r_key) |
{ |
#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_type; |
#endif |
} |
inline point_iterator |
find(key_const_reference); |
inline point_const_iterator |
find(key_const_reference) const; |
inline point_iterator |
find_end(); |
inline point_const_iterator |
find_end() const; |
inline bool |
erase(key_const_reference); |
template<typename Pred> |
inline size_type |
erase_if(Pred); |
void |
clear(); |
inline iterator |
begin(); |
inline const_iterator |
begin() const; |
inline iterator |
end(); |
inline const_iterator |
end() const; |
#ifdef _GLIBCXX_DEBUG |
void |
assert_valid(const char*, int) const; |
#endif |
#ifdef PB_DS_HT_MAP_TRACE_ |
void |
trace() const; |
#endif |
private: |
#ifdef PB_DS_DATA_TRUE_INDICATOR |
friend class iterator_; |
#endif |
friend class const_iterator_; |
void |
deallocate_all(); |
void |
initialize(); |
void |
erase_all_valid_entries(entry_array, size_type); |
inline bool |
do_resize_if_needed(); |
inline void |
do_resize_if_needed_no_throw(); |
void |
resize_imp(size_type); |
virtual void |
do_resize(size_type); |
void |
resize_imp(entry_array, size_type); |
inline void |
resize_imp_reassign(entry_pointer, entry_array, false_type); |
inline void |
resize_imp_reassign(entry_pointer, entry_array, true_type); |
inline size_type |
find_ins_pos(key_const_reference, false_type); |
inline comp_hash |
find_ins_pos(key_const_reference, true_type); |
inline std::pair<point_iterator, bool> |
insert_imp(const_reference, false_type); |
inline std::pair<point_iterator, bool> |
insert_imp(const_reference, true_type); |
inline pointer |
insert_new_imp(const_reference r_val, size_type pos) |
{ |
_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_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(debug_base::insert_new(PB_DS_V2F(p_e->m_value));) |
_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) |
return &p_e->m_value; |
} |
inline pointer |
insert_new_imp(const_reference r_val, comp_hash& r_pos_hash_pair) |
{ |
_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), |
traits_base::m_store_extra_indicator); |
_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(debug_base::insert_new(PB_DS_V2F(p_e->m_value));) |
_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) |
return &p_e->m_value; |
} |
#ifdef PB_DS_DATA_TRUE_INDICATOR |
inline mapped_reference |
subscript_imp(key_const_reference key, false_type) |
{ |
_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) |
const size_type pos = find_ins_pos(key, |
traits_base::m_store_extra_indicator); |
entry_pointer p_e = &m_entries[pos]; |
if (p_e->m_stat != valid_entry_status) |
return insert_new_imp(value_type(key, mapped_type()), pos)->second; |
PB_DS_CHECK_KEY_EXISTS(key) |
return p_e->m_value.second; |
} |
inline mapped_reference |
subscript_imp(key_const_reference key, true_type) |
{ |
_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);) |
comp_hash pos_hash_pair = find_ins_pos(key, |
traits_base::m_store_extra_indicator); |
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; |
PB_DS_CHECK_KEY_EXISTS(key) |
return (m_entries + pos_hash_pair.first)->m_value.second; |
} |
#endif |
inline pointer |
find_key_pointer(key_const_reference key, false_type) |
{ |
const size_type hash = ranged_probe_fn_base::operator()(key); |
resize_base::notify_find_search_start(); |
// Loop until entry is found or until all possible entries accessed. |
for (size_type i = 0; i < m_num_e; ++i) |
{ |
const size_type pos = ranged_probe_fn_base::operator()(key, |
hash, i); |
entry* const p_e = m_entries + pos; |
switch (p_e->m_stat) |
{ |
case empty_entry_status: |
{ |
resize_base::notify_find_search_end(); |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(key) |
return 0; |
} |
break; |
case valid_entry_status: |
if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), key)) |
{ |
resize_base::notify_find_search_end(); |
PB_DS_CHECK_KEY_EXISTS(key) |
return pointer(&p_e->m_value); |
} |
break; |
case erased_entry_status: |
break; |
default: |
_GLIBCXX_DEBUG_ASSERT(0); |
}; |
resize_base::notify_find_search_collision(); |
} |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(key) |
resize_base::notify_find_search_end(); |
return 0; |
} |
inline pointer |
find_key_pointer(key_const_reference key, true_type) |
{ |
comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(key); |
resize_base::notify_find_search_start(); |
// Loop until entry is found or until all possible entries accessed. |
for (size_type i = 0; i < m_num_e; ++i) |
{ |
const size_type pos = |
ranged_probe_fn_base::operator()(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_find_search_end(); |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(key) |
return 0; |
} |
break; |
case valid_entry_status: |
if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), |
p_e->m_hash, |
key, pos_hash_pair.second)) |
{ |
resize_base::notify_find_search_end(); |
PB_DS_CHECK_KEY_EXISTS(key) |
return pointer(&p_e->m_value); |
} |
break; |
case erased_entry_status: |
break; |
default: |
_GLIBCXX_DEBUG_ASSERT(0); |
}; |
resize_base::notify_find_search_collision(); |
} |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(key) |
resize_base::notify_find_search_end(); |
return 0; |
} |
inline bool |
erase_imp(key_const_reference, true_type); |
inline bool |
erase_imp(key_const_reference, false_type); |
inline void |
erase_entry(entry_pointer); |
#ifdef PB_DS_DATA_TRUE_INDICATOR |
void |
inc_it_state(pointer& r_p_value, size_type& r_pos) const |
{ inc_it_state((mapped_const_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 != 0); |
for (++r_pos; r_pos < m_num_e; ++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 = 0; |
} |
void |
get_start_it_state(const_pointer& r_p_value, size_type& r_pos) const |
{ |
for (r_pos = 0; r_pos < m_num_e; ++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 = 0; |
} |
void |
get_start_it_state(pointer& r_p_value, size_type& r_pos) |
{ |
for (r_pos = 0; r_pos < m_num_e; ++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; |
return; |
} |
} |
r_p_value = 0; |
} |
#ifdef _GLIBCXX_DEBUG |
void |
assert_entry_array_valid(const entry_array, false_type, |
const char*, int) const; |
void |
assert_entry_array_valid(const entry_array, true_type, |
const char*, int) const; |
#endif |
static entry_allocator s_entry_allocator; |
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, __gnu_pbds::null_type>::value |
}; |
PB_DS_STATIC_ASSERT(sth, store_hash_ok); |
}; |
#include <ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/info_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/policy_access_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/iterator_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/insert_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp> |
#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_GP_HASH_TRAITS_BASE |
#undef PB_DS_DEBUG_MAP_BASE_C_DEC |
#undef PB_DS_GP_HASH_NAME |
} // namespace detail |
} // namespace __gnu_pbds |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/info_fn_imps.hpp |
---|
0,0 → 1,58 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/info_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s entire container info related |
* functions. |
*/ |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::size_type |
PB_DS_CLASS_C_DEC:: |
size() const |
{ return m_num_used_e; } |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::size_type |
PB_DS_CLASS_C_DEC:: |
max_size() const |
{ return s_entry_allocator.max_size(); } |
PB_DS_CLASS_T_DEC |
inline bool |
PB_DS_CLASS_C_DEC:: |
empty() const |
{ return (size() == 0); } |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_fn_imps.hpp |
---|
0,0 → 1,43 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/insert_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s insert related functions. |
*/ |
#include <ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp> |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp |
---|
0,0 → 1,111 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s insert related functions, |
* when the hash value is not stored. |
*/ |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::size_type |
PB_DS_CLASS_C_DEC:: |
find_ins_pos(key_const_reference r_key, false_type) |
{ |
size_type hash = ranged_probe_fn_base::operator()(r_key); |
size_type i; |
/* The insertion position is initted to a non-legal value to indicate |
* 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, hash, i); |
_GLIBCXX_DEBUG_ASSERT(pos < m_num_e); |
entry* const p_e = m_entries + pos; |
switch(p_e->m_stat) |
{ |
case empty_entry_status: |
{ |
resize_base::notify_insert_search_end(); |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) |
return (ins_pos == m_num_e) ? pos : ins_pos; |
} |
break; |
case erased_entry_status: |
if (ins_pos == m_num_e) |
ins_pos = pos; |
break; |
case valid_entry_status: |
if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key)) |
{ |
resize_base::notify_insert_search_end(); |
PB_DS_CHECK_KEY_EXISTS(r_key) |
return pos; |
} |
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 ins_pos; |
} |
PB_DS_CLASS_T_DEC |
inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool> |
PB_DS_CLASS_C_DEC:: |
insert_imp(const_reference r_val, false_type) |
{ |
key_const_reference r_key = PB_DS_V2F(r_val); |
const size_type pos = find_ins_pos(r_key, |
traits_base::m_store_extra_indicator); |
if (m_entries[pos].m_stat == valid_entry_status) |
{ |
PB_DS_CHECK_KEY_EXISTS(r_key) |
return std::make_pair(&(m_entries + pos)->m_value, false); |
} |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) |
return std::make_pair(insert_new_imp(r_val, pos), true); |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp |
---|
0,0 → 1,118 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/insert_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s find related functions, |
* when the hash value is stored. |
*/ |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::comp_hash |
PB_DS_CLASS_C_DEC:: |
find_ins_pos(key_const_reference r_key, true_type) |
{ |
PB_DS_ASSERT_VALID((*this)) |
comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key); |
size_type i; |
/* The insertion position is initted to a non-legal value to indicate |
* 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_entries + pos; |
switch(p_e->m_stat) |
{ |
case empty_entry_status: |
{ |
resize_base::notify_insert_search_end(); |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) |
return ((ins_pos == m_num_e) ? |
std::make_pair(pos, pos_hash_pair.second) : |
std::make_pair(ins_pos, pos_hash_pair.second)); |
} |
break; |
case erased_entry_status: |
if (ins_pos == m_num_e) |
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)) |
{ |
resize_base::notify_insert_search_end(); |
PB_DS_CHECK_KEY_EXISTS(r_key) |
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); |
} |
PB_DS_CLASS_T_DEC |
inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool> |
PB_DS_CLASS_C_DEC:: |
insert_imp(const_reference r_val, true_type) |
{ |
key_const_reference r_key = PB_DS_V2F(r_val); |
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_entries[pos_hash_pair.first]; |
if (p_e->m_stat == valid_entry_status) |
{ |
PB_DS_CHECK_KEY_EXISTS(r_key) |
return std::make_pair(&p_e->m_value, false); |
} |
PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key) |
return std::make_pair(insert_new_imp(r_val, pos_hash_pair), true); |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/iterator_fn_imps.hpp |
---|
0,0 → 1,83 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/iterator_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s iterators related functions, e.g., |
* begin(). |
*/ |
PB_DS_CLASS_T_DEC |
typename PB_DS_CLASS_C_DEC::iterator |
PB_DS_CLASS_C_DEC::s_end_it; |
PB_DS_CLASS_T_DEC |
typename PB_DS_CLASS_C_DEC::const_iterator |
PB_DS_CLASS_C_DEC::s_const_end_it; |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::iterator |
PB_DS_CLASS_C_DEC:: |
begin() |
{ |
pointer_ p_value; |
size_type pos; |
get_start_it_state(p_value, pos); |
return iterator(p_value, pos, this); |
} |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::iterator |
PB_DS_CLASS_C_DEC:: |
end() |
{ return s_end_it; } |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::const_iterator |
PB_DS_CLASS_C_DEC:: |
begin() const |
{ |
const_pointer_ p_value; |
size_type pos; |
get_start_it_state(p_value, pos); |
return const_iterator(p_value, pos, this); |
} |
PB_DS_CLASS_T_DEC |
inline typename PB_DS_CLASS_C_DEC::const_iterator |
PB_DS_CLASS_C_DEC:: |
end() const |
{ return s_const_end_it; } |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/policy_access_fn_imps.hpp |
---|
0,0 → 1,100 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/policy_access_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s policy agpess |
* functions. |
*/ |
PB_DS_CLASS_T_DEC |
Hash_Fn& |
PB_DS_CLASS_C_DEC:: |
get_hash_fn() |
{ return *this; } |
PB_DS_CLASS_T_DEC |
const Hash_Fn& |
PB_DS_CLASS_C_DEC:: |
get_hash_fn() const |
{ return *this; } |
PB_DS_CLASS_T_DEC |
Eq_Fn& |
PB_DS_CLASS_C_DEC:: |
get_eq_fn() |
{ return *this; } |
PB_DS_CLASS_T_DEC |
const Eq_Fn& |
PB_DS_CLASS_C_DEC:: |
get_eq_fn() const |
{ return *this; } |
PB_DS_CLASS_T_DEC |
Probe_Fn& |
PB_DS_CLASS_C_DEC:: |
get_probe_fn() |
{ return *this; } |
PB_DS_CLASS_T_DEC |
const Probe_Fn& |
PB_DS_CLASS_C_DEC:: |
get_probe_fn() const |
{ return *this; } |
PB_DS_CLASS_T_DEC |
Comb_Probe_Fn& |
PB_DS_CLASS_C_DEC:: |
get_comb_probe_fn() |
{ return *this; } |
PB_DS_CLASS_T_DEC |
const Comb_Probe_Fn& |
PB_DS_CLASS_C_DEC:: |
get_comb_probe_fn() const |
{ return *this; } |
PB_DS_CLASS_T_DEC |
Resize_Policy& |
PB_DS_CLASS_C_DEC:: |
get_resize_policy() |
{ return *this; } |
PB_DS_CLASS_T_DEC |
const Resize_Policy& |
PB_DS_CLASS_C_DEC:: |
get_resize_policy() const |
{ return *this; } |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp |
---|
0,0 → 1,139 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/resize_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s resize related functions. |
*/ |
PB_DS_CLASS_T_DEC |
inline bool |
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; |
} |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
do_resize(size_type n) |
{ resize_imp(resize_base::get_nearest_larger_size(n)); } |
PB_DS_CLASS_T_DEC |
inline void |
PB_DS_CLASS_C_DEC:: |
do_resize_if_needed_no_throw() |
{ |
if (!resize_base::is_resize_needed()) |
return; |
__try |
{ |
resize_imp(resize_base::get_new_size(m_num_e, m_num_used_e)); |
} |
__catch(...) |
{ } |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
resize_imp(size_type new_size) |
{ |
#ifdef PB_DS_REGRESSION |
typename _Alloc::group_adjustor adjust(m_num_e); |
#endif |
if (new_size == m_num_e) |
return; |
PB_DS_ASSERT_VALID((*this)) |
const size_type old_size = m_num_e; |
entry_array a_entries_resized = 0; |
// 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) |
a_entries_resized[i].m_stat = empty_entry_status; |
__try |
{ |
resize_imp(a_entries_resized, old_size); |
} |
__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_exception_again; |
} |
// At this point no exceptions can be thrown. |
_GLIBCXX_DEBUG_ONLY(assert_entry_array_valid(a_entries_resized, |
traits_base::m_store_extra_indicator, |
__FILE__, __LINE__);) |
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; |
PB_DS_ASSERT_VALID((*this)) |
} |
PB_DS_CLASS_T_DEC |
void |
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_entries[pos].m_stat == valid_entry_status) |
resize_imp_reassign(m_entries + pos, a_entries_resized, |
traits_base::m_store_extra_indicator); |
} |
#include <ext/pb_ds/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp> |
#include <ext/pb_ds/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp> |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp |
---|
0,0 → 1,72 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s resize related functions, when the |
* hash value is not stored. |
*/ |
PB_DS_CLASS_T_DEC |
inline void |
PB_DS_CLASS_C_DEC:: |
resize_imp_reassign(entry_pointer p_e, entry_array a_entries_resized, |
false_type) |
{ |
key_const_reference r_key = PB_DS_V2F(p_e->m_value); |
size_type hash = ranged_probe_fn_base::operator()(r_key); |
size_type i; |
for (i = 0; i < m_num_e; ++i) |
{ |
const size_type pos = ranged_probe_fn_base::operator()(r_key, hash, i); |
entry_pointer p_new_e = a_entries_resized + pos; |
switch(p_new_e->m_stat) |
{ |
case empty_entry_status: |
new (&p_new_e->m_value) value_type(p_e->m_value); |
p_new_e->m_stat = valid_entry_status; |
return; |
case erased_entry_status: |
_GLIBCXX_DEBUG_ASSERT(0); |
break; |
case valid_entry_status: |
break; |
default: |
_GLIBCXX_DEBUG_ASSERT(0); |
}; |
} |
__throw_insert_error(); |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp |
---|
0,0 → 1,74 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/resize_store_hash_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s resize related functions, when the |
* hash value is stored. |
*/ |
PB_DS_CLASS_T_DEC |
inline void |
PB_DS_CLASS_C_DEC:: |
resize_imp_reassign(entry_pointer p_e, entry_array a_entries_resized, |
true_type) |
{ |
key_const_reference r_key = PB_DS_V2F(p_e->m_value); |
size_type hash = ranged_probe_fn_base::operator()(r_key, p_e->m_hash); |
size_type i; |
for (i = 0; i < m_num_e; ++i) |
{ |
const size_type pos = ranged_probe_fn_base::operator()(r_key, hash, i); |
entry_pointer p_new_e = a_entries_resized + pos; |
switch(p_new_e->m_stat) |
{ |
case empty_entry_status: |
new (&p_new_e->m_value) value_type(p_e->m_value); |
p_new_e->m_hash = hash; |
p_new_e->m_stat = valid_entry_status; |
return; |
case erased_entry_status: |
_GLIBCXX_DEBUG_ASSERT(0); |
break; |
case valid_entry_status: |
break; |
default: |
_GLIBCXX_DEBUG_ASSERT(0); |
}; |
} |
__throw_insert_error(); |
} |
/contrib/sdk/sources/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp |
---|
0,0 → 1,74 |
// -*- C++ -*- |
// Copyright (C) 2005-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the terms |
// of the GNU General Public License as published by the Free Software |
// Foundation; either version 3, or (at your option) any later |
// version. |
// This library is distributed in the hope that it will be useful, but |
// WITHOUT ANY WARRANTY; without even the implied warranty of |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// General Public License for more details. |
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. |
// Permission to use, copy, modify, sell, and distribute this software |
// is hereby granted without fee, provided that the above copyright |
// notice appears in all copies, and that both that copyright notice |
// and this permission notice appear in supporting documentation. None |
// of the above authors, nor IBM Haifa Research Laboratories, make any |
// representation about the suitability of this software for any |
// purpose. It is provided "as is" without express or implied |
// warranty. |
/** |
* @file gp_hash_table_map_/trace_fn_imps.hpp |
* Contains implementations of gp_ht_map_'s trace-mode functions. |
*/ |
#ifdef PB_DS_HT_MAP_TRACE_ |
PB_DS_CLASS_T_DEC |
void |
PB_DS_CLASS_C_DEC:: |
trace() const |
{ |
std::cerr << static_cast<unsigned long>(m_num_e) << " " << |
static_cast<unsigned long>(m_num_used_e) << std::endl; |
for (size_type i = 0; i < m_num_e; ++i) |
{ |
std::cerr << static_cast<unsigned long>(i) << " "; |
switch(m_entries[i].m_stat) |
{ |
case empty_entry_status: |
std::cerr << "<empty>"; |
break; |
case erased_entry_status: |
std::cerr << "<erased>"; |
break; |
case valid_entry_status: |
std::cerr << PB_DS_V2F(m_entries[i].m_value); |
break; |
default: |
_GLIBCXX_DEBUG_ASSERT(0); |
}; |
std::cerr << std::endl; |
} |
} |
#endif // #ifdef PB_DS_HT_MAP_TRACE_ |