libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp

   1 // -*- C++ -*-
   2
   3 // Copyright (C) 2005-2023 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the terms
   7 // of the GNU General Public License as published by the Free Software
   8 // Foundation; either version 3, or (at your option) any later
   9 // version.
  10
  11 // This library is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
  26
  27 // Permission to use, copy, modify, sell, and distribute this software
  28 // is hereby granted without fee, provided that the above copyright
  29 // notice appears in all copies, and that both that copyright notice
  30 // and this permission notice appear in supporting documentation. None
  31 // of the above authors, nor IBM Haifa Research Laboratories, make any
  32 // representation about the suitability of this software for any
  33 // purpose. It is provided "as is" without express or implied
  34 // warranty.
  35
  36 /**
  37  * @file pat_trie_/erase_fn_imps.hpp
  38  * Contains an implementation class for pat_trie.
  39  */
  40
  41 #ifdef PB_DS_CLASS_C_DEC
  42
  43 PB_DS_CLASS_T_DEC
  44 inline bool
  45 PB_DS_CLASS_C_DEC::
  46 erase(key_const_reference r_key)
  47 {
  48   node_pointer p_nd = find_imp(r_key);
  49   if (p_nd == 0 || p_nd->m_type == i_node)
  50     {
  51       PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
  52       return false;
  53     }
  54
  55   _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == leaf_node);
  56   if (!synth_access_traits::equal_keys(PB_DS_V2F(reinterpret_cast<leaf_pointer>(p_nd)->value()), r_key))
  57     {
  58       PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
  59       return false;
  60     }
  61
  62   PB_DS_CHECK_KEY_EXISTS(r_key)
  63   erase_leaf(static_cast<leaf_pointer>(p_nd));
  64   PB_DS_ASSERT_VALID((*this))
  65   return true;
  66 }
  67
  68 PB_DS_CLASS_T_DEC
  69 void
  70 PB_DS_CLASS_C_DEC::
  71 erase_fixup(inode_pointer p_nd)
  72 {
  73   _GLIBCXX_DEBUG_ASSERT(std::distance(p_nd->begin(), p_nd->end()) >= 1);
  74   if (std::distance(p_nd->begin(), p_nd->end()) == 1)
  75     {
  76       node_pointer p_parent = p_nd->m_p_parent;
  77       if (p_parent == m_p_head)
  78         m_p_head->m_p_parent = *p_nd->begin();
  79       else
  80         {
  81           _GLIBCXX_DEBUG_ASSERT(p_parent->m_type == i_node);
  82           node_pointer p_new_child = *p_nd->begin();
  83
  84           typedef inode_pointer inode_ptr;
  85           inode_ptr p_internal = static_cast<inode_ptr>(p_parent);
  86           p_internal->replace_child(p_new_child, pref_begin(p_new_child),
  87                                     pref_end(p_new_child), this);
  88         }
  89       (*p_nd->begin())->m_p_parent = p_nd->m_p_parent;
  90       p_nd->~inode();
  91       s_inode_allocator.deallocate(p_nd, 1);
  92
  93       if (p_parent == m_p_head)
  94         return;
  95
  96       _GLIBCXX_DEBUG_ASSERT(p_parent->m_type == i_node);
  97       p_nd = static_cast<inode_pointer>(p_parent);
  98     }
  99
 100   while (true)
 101     {
 102       _GLIBCXX_DEBUG_ASSERT(std::distance(p_nd->begin(), p_nd->end()) > 1);
 103       p_nd->update_prefixes(this);
 104       apply_update(p_nd, (node_update*)this);
 105       PB_DS_ASSERT_NODE_VALID(p_nd)
 106       if (p_nd->m_p_parent->m_type == head_node)
 107         return;
 108
 109       _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_parent->m_type == i_node);
 110
 111       p_nd = static_cast<inode_pointer>(p_nd->m_p_parent);
 112     }
 113 }
 114
 115 PB_DS_CLASS_T_DEC
 116 inline void
 117 PB_DS_CLASS_C_DEC::
 118 actual_erase_leaf(leaf_pointer p_l)
 119 {
 120   _GLIBCXX_DEBUG_ASSERT(m_size > 0);
 121   --m_size;
 122   _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_l->value())));
 123   p_l->~leaf();
 124   s_leaf_allocator.deallocate(p_l, 1);
 125 }
 126
 127 PB_DS_CLASS_T_DEC
 128 void
 129 PB_DS_CLASS_C_DEC::
 130 clear()
 131 {
 132   if (!empty())
 133     {
 134       clear_imp(m_p_head->m_p_parent);
 135       m_size = 0;
 136       initialize();
 137       _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
 138       PB_DS_ASSERT_VALID((*this))
 139     }
 140 }
 141
 142 PB_DS_CLASS_T_DEC
 143 void
 144 PB_DS_CLASS_C_DEC::
 145 clear_imp(node_pointer p_nd)
 146 {
 147   if (p_nd->m_type == i_node)
 148     {
 149       _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == i_node);
 150       for (typename inode::iterator it =
 151              static_cast<inode_pointer>(p_nd)->begin();
 152            it != static_cast<inode_pointer>(p_nd)->end();
 153            ++it)
 154         {
 155           node_pointer p_child =* it;
 156           clear_imp(p_child);
 157         }
 158       s_inode_allocator.deallocate(static_cast<inode_pointer>(p_nd), 1);
 159       return;
 160     }
 161
 162   _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == leaf_node);
 163   static_cast<leaf_pointer>(p_nd)->~leaf();
 164   s_leaf_allocator.deallocate(static_cast<leaf_pointer>(p_nd), 1);
 165 }
 166
 167 PB_DS_CLASS_T_DEC
 168 inline typename PB_DS_CLASS_C_DEC::const_iterator
 169 PB_DS_CLASS_C_DEC::
 170 erase(const_iterator it)
 171 {
 172   PB_DS_ASSERT_VALID((*this))
 173
 174   if (it == end())
 175     return it;
 176
 177   const_iterator ret_it = it;
 178   ++ret_it;
 179   _GLIBCXX_DEBUG_ASSERT(it.m_p_nd->m_type == leaf_node);
 180   erase_leaf(static_cast<leaf_pointer>(it.m_p_nd));
 181   PB_DS_ASSERT_VALID((*this))
 182   return ret_it;
 183 }
 184
 185 #ifdef PB_DS_DATA_TRUE_INDICATOR
 186 PB_DS_CLASS_T_DEC
 187 inline typename PB_DS_CLASS_C_DEC::iterator
 188 PB_DS_CLASS_C_DEC::
 189 erase(iterator it)
 190 {
 191   PB_DS_ASSERT_VALID((*this))
 192
 193   if (it == end())
 194     return it;
 195   iterator ret_it = it;
 196   ++ret_it;
 197   _GLIBCXX_DEBUG_ASSERT(it.m_p_nd->m_type == leaf_node);
 198   erase_leaf(static_cast<leaf_pointer>(it.m_p_nd));
 199   PB_DS_ASSERT_VALID((*this))
 200   return ret_it;
 201 }
 202 #endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
 203
 204 PB_DS_CLASS_T_DEC
 205 inline typename PB_DS_CLASS_C_DEC::const_reverse_iterator
 206 PB_DS_CLASS_C_DEC::
 207 erase(const_reverse_iterator it)
 208 {
 209   PB_DS_ASSERT_VALID((*this))
 210
 211   if (it.m_p_nd == m_p_head)
 212     return it;
 213   const_reverse_iterator ret_it = it;
 214   ++ret_it;
 215
 216   _GLIBCXX_DEBUG_ASSERT(it.m_p_nd->m_type == leaf_node);
 217   erase_leaf(static_cast<leaf_pointer>(it.m_p_nd));
 218   PB_DS_ASSERT_VALID((*this))
 219   return ret_it;
 220 }
 221
 222 #ifdef PB_DS_DATA_TRUE_INDICATOR
 223 PB_DS_CLASS_T_DEC
 224 inline typename PB_DS_CLASS_C_DEC::reverse_iterator
 225 PB_DS_CLASS_C_DEC::
 226 erase(reverse_iterator it)
 227 {
 228   PB_DS_ASSERT_VALID((*this))
 229
 230   if (it.m_p_nd == m_p_head)
 231     return it;
 232   reverse_iterator ret_it = it;
 233   ++ret_it;
 234
 235   _GLIBCXX_DEBUG_ASSERT(it.m_p_nd->m_type == leaf_node);
 236   erase_leaf(static_cast<leaf_pointer>(it.m_p_nd));
 237   PB_DS_ASSERT_VALID((*this))
 238   return ret_it;
 239 }
 240 #endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
 241
 242 PB_DS_CLASS_T_DEC
 243 template<typename Pred>
 244 inline typename PB_DS_CLASS_C_DEC::size_type
 245 PB_DS_CLASS_C_DEC::
 246 erase_if(Pred pred)
 247 {
 248   size_type num_ersd = 0;
 249   PB_DS_ASSERT_VALID((*this))
 250
 251   iterator it = begin();
 252   while (it != end())
 253     {
 254       PB_DS_ASSERT_VALID((*this))
 255       if (pred(*it))
 256         {
 257           ++num_ersd;
 258           it = erase(it);
 259         }
 260       else
 261         ++it;
 262     }
 263
 264   PB_DS_ASSERT_VALID((*this))
 265   return num_ersd;
 266 }
 267
 268 PB_DS_CLASS_T_DEC
 269 void
 270 PB_DS_CLASS_C_DEC::
 271 erase_leaf(leaf_pointer p_l)
 272 {
 273   update_min_max_for_erased_leaf(p_l);
 274   if (p_l->m_p_parent->m_type == head_node)
 275     {
 276       _GLIBCXX_DEBUG_ASSERT(size() == 1);
 277       clear();
 278       return;
 279     }
 280
 281   _GLIBCXX_DEBUG_ASSERT(size() > 1);
 282   _GLIBCXX_DEBUG_ASSERT(p_l->m_p_parent->m_type == i_node);
 283
 284   inode_pointer p_parent = static_cast<inode_pointer>(p_l->m_p_parent);
 285
 286   p_parent->remove_child(p_l);
 287   erase_fixup(p_parent);
 288   actual_erase_leaf(p_l);
 289 }
 290
 291 PB_DS_CLASS_T_DEC
 292 void
 293 PB_DS_CLASS_C_DEC::
 294 update_min_max_for_erased_leaf(leaf_pointer p_l)
 295 {
 296   if (m_size == 1)
 297     {
 298       m_p_head->m_p_min = m_p_head;
 299       m_p_head->m_p_max = m_p_head;
 300       return;
 301     }
 302
 303   if (p_l == static_cast<leaf_const_pointer>(m_p_head->m_p_min))
 304     {
 305       iterator it(p_l);
 306       ++it;
 307       m_p_head->m_p_min = it.m_p_nd;
 308       return;
 309     }
 310
 311   if (p_l == static_cast<leaf_const_pointer>(m_p_head->m_p_max))
 312     {
 313       iterator it(p_l);
 314       --it;
 315       m_p_head->m_p_max = it.m_p_nd;
 316     }
 317 }
 318 #endif