stlab.adobe.com Adobe Systems Incorporated
erase_if.hpp
Go to the documentation of this file.
1 /*
2  Copyright 2005-2007 Adobe Systems Incorporated
3  Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
4  or a copy at http://stlab.adobe.com/licenses.html)
5 */
6 
7 /*************************************************************************************************/
8 
9 #ifndef ADOBE_ALGORITHM_ERASE_IF_HPP
10 #define ADOBE_ALGORITHM_ERASE_IF_HPP
11 
12 #include <adobe/config.hpp>
13 
14 #include <cassert>
15 
16 #include <boost/range/begin.hpp>
17 #include <boost/range/end.hpp>
18 #include <boost/next_prior.hpp>
19 
21 #include <adobe/algorithm/find.hpp>
22 #include <adobe/container/storage.hpp>
23 
24 /*************************************************************************************************/
25 
26 namespace adobe {
27 
28 /*************************************************************************************************/
42 /*************************************************************************************************/
43 
44 namespace implementation {
45 
46 
47 template <typename T> // T models Container
48 typename T::iterator erase(T& x, typename T::iterator f, typename T::iterator l, block_tag)
49 { return x.erase(f, l); }
50 
51 template <typename T> // T models Container
52 typename T::iterator erase(T& x, typename T::iterator f, typename T::iterator l, node_tag)
53 { x.erase(f, l); return l; }
54 
55 } // implementation
56 
57 /*************************************************************************************************/
58 
62 template <typename T> // T models Container
63 typename T::iterator erase(T& x, typename T::iterator f, typename T::iterator l)
64 {
65  return implementation::erase(x, f, l, typename storage_category<T>::type());
66 }
67 
68 /*************************************************************************************************/
69 
73 template < typename T, // T models Container
74  typename R> // R models Range(iterator(T), iterator(T))
75 typename T::iterator erase(T& x, const R& r)
76 {
77  return erase(x, boost::begin(r), boost::end(r));
78 }
79 
84 template <typename T> // T models Container
85 typename T::iterator erase(T& x, typename T::iterator f)
86 {
87  assert(f != end(x) && "FATAL (sparent) : Attempt to erase the end of a container.");
88  return erase(x, f, boost::next(f));
89 }
90 
91 /*************************************************************************************************/
92 
93 namespace implementation {
94 
95 template < typename T, // T models Container
96  typename P> // P models UnaryPredicate
97 void erase_if(T& x, typename T::iterator f, typename T::iterator l, P p, block_tag)
98 { x.erase(adobe::remove_if(f, l, p), l); }
99 
100 template < typename T, // T models Container
101  typename P> // P models UnaryPredicate
102 void erase_if(T& x, typename T::iterator f, typename T::iterator l, P p, node_tag)
103 {
104  while (f != l) {
105  f = adobe::erase(x, find_range_if(f, l, p));
106  }
107 }
108 
109 } // implementation
110 
111 /*************************************************************************************************/
112 
117 template < typename T, // T models Container
118  typename P> // P models UnaryPredicate
119 void erase_if(T& x, typename T::iterator f, typename T::iterator l, P p)
120 {
121  implementation::erase_if(x, f, l, p, typename storage_category<T>::type());
122 }
123 
128 template < typename T, // T models Container
129  typename P> // P models UnaryPredicate
130 void erase_if(T& x, P p)
131 {
132  erase_if(x, boost::begin(x), boost::end(x), p);
133 }
134 
135 /*************************************************************************************************/
136 
137 } // namespace adobe
138 
139 /*************************************************************************************************/
140 
141 #endif
142 
143 /*************************************************************************************************/
InputIterator remove_if(InputIterator first, InputIterator last, Predicate pred)
remove implementation
Definition: remove.hpp:53
T::iterator erase(T &x, typename T::iterator f)
Definition: erase_if.hpp:85
std::pair< I, I > find_range_if(I f, I l, P p)
Definition: find.hpp:222
void erase_if(T &x, typename T::iterator f, typename T::iterator l, P p)
Definition: erase_if.hpp:119
T::iterator erase(T &x, typename T::iterator f, typename T::iterator l)
Definition: erase_if.hpp:63
void erase_if(T &x, P p)
Definition: erase_if.hpp:130

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google