PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
make_child_of(node_pointer p_nd, node_pointer p_new_parent)
{
_GLIBCXX_DEBUG_ASSERT(p_nd != 0);
_GLIBCXX_DEBUG_ASSERT(p_new_parent != 0);
p_nd->m_p_next_sibling = p_new_parent->m_p_l_child;
if (p_new_parent->m_p_l_child != 0)
p_new_parent->m_p_l_child->m_p_prev_or_parent = p_nd;
p_nd->m_p_prev_or_parent = p_new_parent;
p_new_parent->m_p_l_child = p_nd;
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
assert_aux_null() const
{
for (size_type i = 0; i < max_rank; ++i)
_GLIBCXX_DEBUG_ASSERT(m_a_aux[i] == NULL);
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
assert_max() const
{
if (m_p_max == NULL)
{
_GLIBCXX_DEBUG_ASSERT(base_type::empty());
return;
}
_GLIBCXX_DEBUG_ASSERT(!base_type::empty());
_GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == NULL);
_GLIBCXX_DEBUG_ASSERT(m_p_max->m_p_prev_or_parent == NULL);
for (const_iterator it = base_type::begin(); it != base_type::end(); ++it)
_GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(m_p_max->m_value, it.m_p_nd->m_value));
}
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
swap_with_parent(node_pointer p_nd, node_pointer p_parent)
{
if (p_parent == m_p_root)
m_p_root = p_nd;
_GLIBCXX_DEBUG_ASSERT(p_nd != 0);
_GLIBCXX_DEBUG_ASSERT(p_parent != 0);
_GLIBCXX_DEBUG_ASSERT(parent(p_nd) == p_parent);
const bool nd_direct_child = p_parent->m_p_l_child == p_nd;
const bool parent_root = p_parent->m_p_prev_or_parent == 0;
const bool parent_direct_child =
!parent_root&& p_parent->m_p_prev_or_parent->m_p_l_child == p_parent;
std::swap(p_parent->m_p_prev_or_parent, p_nd->m_p_prev_or_parent);
std::swap(p_parent->m_p_next_sibling, p_nd->m_p_next_sibling);
std::swap(p_parent->m_p_l_child, p_nd->m_p_l_child);
std::swap(p_parent->m_metadata, p_nd->m_metadata);
_GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child != 0);
_GLIBCXX_DEBUG_ASSERT(p_parent->m_p_prev_or_parent != 0);
if (p_nd->m_p_next_sibling != 0)
p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd;
if (p_parent->m_p_next_sibling != 0)
p_parent->m_p_next_sibling->m_p_prev_or_parent = p_parent;
if (p_parent->m_p_l_child != 0)
p_parent->m_p_l_child->m_p_prev_or_parent = p_parent;
if (parent_direct_child)
p_nd->m_p_prev_or_parent->m_p_l_child = p_nd;
else if (!parent_root)
p_nd->m_p_prev_or_parent->m_p_next_sibling = p_nd;
if (!nd_direct_child)
{
p_nd->m_p_l_child->m_p_prev_or_parent = p_nd;
p_parent->m_p_prev_or_parent->m_p_next_sibling = p_parent;
}
else
{
_GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child == p_nd);
_GLIBCXX_DEBUG_ASSERT(p_parent->m_p_prev_or_parent == p_parent);
p_nd->m_p_l_child = p_parent;
p_parent->m_p_prev_or_parent = p_nd;
}
_GLIBCXX_DEBUG_ASSERT(parent(p_parent) == p_nd);
}
// Returns the number of children in the corresponding node.
inline size_type
num_children() const
{
if (m_p_nd->m_type == pat_trie_leaf_node_type)
return 0;
_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == pat_trie_internal_node_type);
return std::distance(static_cast<internal_node_pointer>(m_p_nd)->begin(), static_cast<internal_node_pointer>(m_p_nd)->end());
}
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
actual_erase_node(node_pointer p_z)
{
_GLIBCXX_DEBUG_ASSERT(m_size > 0);
--m_size;
_GLIBCXX_DEBUG_ONLY(erase_existing(PB_DS_V2F(p_z->m_value));)
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();
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
clear()
{
clear_imp(m_p_root);
_GLIBCXX_DEBUG_ASSERT(m_size == 0);
m_p_root = 0;
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
assert_min_imp(const node_pointer p_nd) const
{
if (p_nd == NULL)
{
_GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_left == m_p_head);
return;
}
if (p_nd->m_p_left == NULL)
{
_GLIBCXX_DEBUG_ASSERT(p_nd == m_p_head->m_p_left);
return;
}
assert_min_imp(p_nd->m_p_left);
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
assert_valid() const
{
structure_only_assert_valid();
assert_consistent_with_debug_base();
assert_size();
assert_iterators();
if (m_p_head->m_p_parent == NULL)
{
_GLIBCXX_DEBUG_ASSERT(m_size == 0);
}
else
{
_GLIBCXX_DEBUG_ASSERT(m_size > 0);
}
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
assert_size() const
{
if (size_from_node(m_p_root) == m_size)
return;
_GLIBCXX_DEBUG_ASSERT(0);
}
PB_DS_CLASS_T_DEC
inline typename PB_DS_CLASS_C_DEC::const_reference
PB_DS_CLASS_C_DEC::
top() const
{
PB_DS_ASSERT_VALID((*this))
_GLIBCXX_DEBUG_ASSERT(!base_type::empty());
return base_type::m_p_root->m_value;
}
PB_DS_CLASS_T_DEC
typename PB_DS_CLASS_C_DEC::size_type
PB_DS_CLASS_C_DEC::
assert_node_consistent(const node_pointer p_nd) const
{
if (p_nd == 0)
return 1;
const size_type l_height = assert_node_consistent(p_nd->m_p_left);
const size_type r_height = assert_node_consistent(p_nd->m_p_right);
if (p_nd->m_red)
{
_GLIBCXX_DEBUG_ASSERT(is_effectively_black(p_nd->m_p_left));
_GLIBCXX_DEBUG_ASSERT(is_effectively_black(p_nd->m_p_right));
}
_GLIBCXX_DEBUG_ASSERT(l_height == r_height);
return (p_nd->m_red ? 0 : 1) + l_height;
}
PB_DS_CLASS_T_DEC
inline typename PB_DS_CLASS_C_DEC::const_reference
PB_DS_CLASS_C_DEC::
top() const
{
PB_DS_ASSERT_VALID((*this))
_GLIBCXX_DEBUG_ASSERT(!empty());
return top_imp(s_no_throw_copies_ind);
}
bool
operator()(key_const_reference r_lhs_key, size_type lhs_hash,
key_const_reference r_rhs_key, size_type rhs_hash) const
{
_GLIBCXX_DEBUG_ASSERT(!eq_fn_base::operator()(r_lhs_key, r_rhs_key)
|| lhs_hash == rhs_hash);
return (lhs_hash == rhs_hash &&
eq_fn_base::operator()(r_lhs_key, r_rhs_key));
}
// Returns a __const node __iterator to the corresponding node's
// i-th child.
PB_DS_PAT_TRIE_CONST_NODE_ITERATOR_C_DEC
get_child(size_type i) const
{
_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == pat_trie_internal_node_type);
typename Internal_Node::iterator it =
static_cast<internal_node_pointer>(m_p_nd)->begin();
std::advance(it, i);
return PB_DS_PAT_TRIE_CONST_NODE_ITERATOR_C_DEC(*it, m_p_traits);
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
assert_special_imp(const node_pointer p_nd) const
{
if (p_nd == NULL)
return;
if (p_nd == base_type::m_p_head)
{
_GLIBCXX_DEBUG_ASSERT(p_nd->m_special);
assert_special_imp(p_nd->m_p_parent);
return;
}
_GLIBCXX_DEBUG_ASSERT(!p_nd->m_special);
assert_special_imp(p_nd->m_p_left);
assert_special_imp(p_nd->m_p_right);
}
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
pop()
{
make_binomial_heap();
_GLIBCXX_DEBUG_ASSERT(!base_type::empty());
base_type::pop();
base_type::find_max();
}
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
actual_erase_node(node_pointer p_nd)
{
_GLIBCXX_DEBUG_ASSERT(m_size > 0);
--m_size;
p_nd->~node();
s_node_allocator.deallocate(p_nd, 1);
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
assert_iterators() const
{
const size_type calc_size = std::distance(begin(), end());
if (calc_size == size())
return;
_GLIBCXX_DEBUG_ASSERT(0);
}
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
actual_erase_node(node_pointer p_z)
{
_GLIBCXX_DEBUG_ASSERT(m_size > 0);
--m_size;
_GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_z->m_value)));
p_z->~node();
s_node_allocator.deallocate(p_z, 1);
}
PB_DS_CLASS_T_DEC
typename PB_DS_CLASS_C_DEC::subtree_debug_info
PB_DS_CLASS_C_DEC::
assert_valid_imp(const_e_access_traits_pointer p_traits) const
{
_GLIBCXX_DEBUG_ASSERT(base_type::m_type == pat_trie_leaf_node_type);
subtree_debug_info ret;
const_reference r_val = value();
return std::make_pair(p_traits->begin(p_traits->extract_key(r_val)),
p_traits->end(p_traits->extract_key(r_val)));
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
erase(point_iterator it)
{
PB_DS_ASSERT_VALID((*this))
_GLIBCXX_DEBUG_ASSERT(!base_type::empty());
remove_node(it.m_p_nd);
base_type::actual_erase_node(it.m_p_nd);
PB_DS_ASSERT_VALID((*this))
}
PB_DS_CLASS_T_DEC
inline typename PB_DS_CLASS_C_DEC::const_iterator
PB_DS_CLASS_C_DEC::
begin() const
{
if (m_p_l == 0)
{
_GLIBCXX_DEBUG_ASSERT(empty());
return end();
}
return iterator(&m_p_l->m_value, m_p_l, const_cast<PB_DS_CLASS_C_DEC* >(this));
}
PB_DS_CLASS_T_DEC
inline typename PB_DS_CLASS_C_DEC::iterator
PB_DS_CLASS_C_DEC::
begin()
{
if (m_p_l == 0)
{
_GLIBCXX_DEBUG_ASSERT(empty());
return end();
}
return iterator(&m_p_l->m_value, m_p_l, this);
}
inline const_metadata_reference
get_metadata() const
{
enum
{
has_metadata = !is_same<Metadata_Type, null_node_metadata>::value
};
PB_DS_STATIC_ASSERT(should_have_metadata, has_metadata);
_GLIBCXX_DEBUG_ASSERT(m_p_metadata != NULL);
return *m_p_metadata;
}
inline typename E_Access_Traits::const_iterator
pref_end() const
{
if (m_p_nd->m_type == pat_trie_leaf_node_type)
return (m_p_traits->end(
m_p_traits->extract_key(
static_cast<const_leaf_pointer>(m_p_nd)->value())));
_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == pat_trie_internal_node_type);
return (static_cast<const_internal_node_pointer>(m_p_nd)->pref_e_it());
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
assert_valid() const
{
_GLIBCXX_DEBUG_ASSERT(m_p_root == NULL || m_p_root->m_p_prev_or_parent == NULL);
if (m_p_root != NULL)
assert_node_consistent(m_p_root, Single_Link_Roots);
assert_size();
assert_iterators();
}
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);)
}
PB_DS_CLASS_T_DEC
inline bool
PB_DS_CLASS_C_DEC::
operator()(const_key_reference r_lhs_key, size_type lhs_hash,
const_key_reference r_rhs_key, size_type rhs_hash) const
{
_GLIBCXX_DEBUG_ASSERT(!eq_fn_base::operator()(r_lhs_key, r_rhs_key)
|| lhs_hash == rhs_hash);
return (lhs_hash == rhs_hash &&
eq_fn_base::operator()(r_lhs_key, r_rhs_key));
}
