1 // Safe sequence implementation -*- C++ -*- 2 3 // Copyright (C) 2010-2018 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 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU 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 /** @file debug/safe_sequence.tcc 26 * This file is a GNU debug extension to the Standard C++ Library. 27 */ 28 29 #ifndef _GLIBCXX_DEBUG_SAFE_SEQUENCE_TCC 30 #define _GLIBCXX_DEBUG_SAFE_SEQUENCE_TCC 1 31 32 namespace __gnu_debug 33 { 34 template<typename _Sequence> 35 template<typename _Predicate> 36 void 37 _Safe_sequence<_Sequence>:: 38 _M_invalidate_if(_Predicate __pred) 39 { 40 typedef typename _Sequence::iterator iterator; 41 typedef typename _Sequence::const_iterator const_iterator; 42 43 __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex()); 44 for (_Safe_iterator_base* __iter = _M_iterators; __iter;) 45 { 46 iterator* __victim = static_cast<iterator*>(__iter); 47 __iter = __iter->_M_next; 48 if (!__victim->_M_singular() && __pred(__victim->base())) 49 { 50 __victim->_M_invalidate(); 51 } 52 } 53 54 for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2;) 55 { 56 const_iterator* __victim = static_cast<const_iterator*>(__iter2); 57 __iter2 = __iter2->_M_next; 58 if (!__victim->_M_singular() && __pred(__victim->base())) 59 { 60 __victim->_M_invalidate(); 61 } 62 } 63 } 64 65 template<typename _Sequence> 66 template<typename _Predicate> 67 void 68 _Safe_sequence<_Sequence>:: 69 _M_transfer_from_if(_Safe_sequence& __from, _Predicate __pred) 70 { 71 typedef typename _Sequence::iterator iterator; 72 typedef typename _Sequence::const_iterator const_iterator; 73 74 _Safe_iterator_base* __transfered_iterators = 0; 75 _Safe_iterator_base* __transfered_const_iterators = 0; 76 _Safe_iterator_base* __last_iterator = 0; 77 _Safe_iterator_base* __last_const_iterator = 0; 78 { 79 // We lock __from first and detach iterator(s) to transfer 80 __gnu_cxx::__scoped_lock sentry(__from._M_get_mutex()); 81 82 for (_Safe_iterator_base* __iter = __from._M_iterators; __iter;) 83 { 84 _Safe_iterator_base* __victim_base = __iter; 85 iterator* __victim = static_cast<iterator*>(__victim_base); 86 __iter = __iter->_M_next; 87 if (!__victim->_M_singular() && __pred(__victim->base())) 88 { 89 __victim->_M_detach_single(); 90 if (__transfered_iterators) 91 { 92 __victim_base->_M_next = __transfered_iterators; 93 __transfered_iterators->_M_prior = __victim_base; 94 } 95 else 96 __last_iterator = __victim_base; 97 __victim_base->_M_sequence = this; 98 __victim_base->_M_version = this->_M_version; 99 __transfered_iterators = __victim_base; 100 } 101 } 102 103 for (_Safe_iterator_base* __iter2 = __from._M_const_iterators; 104 __iter2;) 105 { 106 _Safe_iterator_base* __victim_base = __iter2; 107 const_iterator* __victim = 108 static_cast<const_iterator*>(__victim_base); 109 __iter2 = __iter2->_M_next; 110 if (!__victim->_M_singular() && __pred(__victim->base())) 111 { 112 __victim->_M_detach_single(); 113 if (__transfered_const_iterators) 114 { 115 __victim_base->_M_next = __transfered_const_iterators; 116 __transfered_const_iterators->_M_prior = __victim_base; 117 } 118 else 119 __last_const_iterator = __victim; 120 __victim_base->_M_sequence = this; 121 __victim_base->_M_version = this->_M_version; 122 __transfered_const_iterators = __victim_base; 123 } 124 } 125 } 126 127 // Now we can lock *this and add the transfered iterators if any 128 if (__last_iterator || __last_const_iterator) 129 { 130 __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex()); 131 if (__last_iterator) 132 { 133 if (this->_M_iterators) 134 { 135 this->_M_iterators->_M_prior = __last_iterator; 136 __last_iterator->_M_next = this->_M_iterators; 137 } 138 this->_M_iterators = __transfered_iterators; 139 } 140 if (__last_const_iterator) 141 { 142 if (this->_M_const_iterators) 143 { 144 this->_M_const_iterators->_M_prior = __last_const_iterator; 145 __last_const_iterator->_M_next = this->_M_const_iterators; 146 } 147 this->_M_const_iterators = __transfered_const_iterators; 148 } 149 } 150 } 151 } // namespace __gnu_debug 152 153 #endif 154