]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Bimap |
2 | // | |
3 | // Copyright (c) 2006-2007 Matias Capeletto | |
4 | // | |
5 | // Distributed under the Boost Software License, Version 1.0. | |
6 | // (See accompanying file LICENSE_1_0.txt or copy at | |
7 | // http://www.boost.org/LICENSE_1_0.txt) | |
8 | ||
9 | /// \file container_adaptor/container_adaptor.hpp | |
10 | /// \brief Container adaptor to build a type that is compliant to the concept of a container. | |
11 | ||
12 | #ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_CONTAINER_ADAPTOR_HPP | |
13 | #define BOOST_BIMAP_CONTAINER_ADAPTOR_CONTAINER_ADAPTOR_HPP | |
14 | ||
15 | #if defined(_MSC_VER) | |
16 | #pragma once | |
17 | #endif | |
18 | ||
19 | #include <boost/config.hpp> | |
20 | ||
21 | #include <utility> | |
22 | ||
23 | #include <boost/mpl/if.hpp> | |
24 | #include <boost/mpl/aux_/na.hpp> | |
25 | #include <boost/bimap/container_adaptor/detail/identity_converters.hpp> | |
26 | #include <boost/iterator/iterator_traits.hpp> | |
27 | ||
28 | #include <boost/bimap/container_adaptor/detail/functor_bag.hpp> | |
29 | #include <boost/mpl/vector.hpp> | |
30 | #include <boost/mpl/copy.hpp> | |
31 | #include <boost/mpl/front_inserter.hpp> | |
32 | #include <boost/call_traits.hpp> | |
33 | ||
34 | ||
35 | ||
36 | namespace boost { | |
37 | namespace bimaps { | |
38 | ||
39 | /// \brief Container Adaptor toolbox, easy way to build new containers from existing ones. | |
40 | ||
41 | namespace container_adaptor { | |
42 | ||
43 | /// \brief Container adaptor to build a type that is compliant to the concept of a container. | |
44 | ||
45 | template | |
46 | < | |
47 | class Base, | |
48 | ||
49 | class Iterator, | |
50 | class ConstIterator, | |
51 | ||
52 | class IteratorToBaseConverter = ::boost::mpl::na, | |
53 | class IteratorFromBaseConverter = ::boost::mpl::na, | |
54 | class ValueToBaseConverter = ::boost::mpl::na, | |
55 | class ValueFromBaseConverter = ::boost::mpl::na, | |
56 | ||
57 | class FunctorsFromDerivedClasses = mpl::vector<> | |
58 | > | |
59 | class container_adaptor | |
60 | { | |
61 | // MetaData ------------------------------------------------------------- | |
62 | ||
63 | public: | |
64 | ||
65 | typedef Iterator iterator; | |
66 | typedef ConstIterator const_iterator; | |
67 | ||
68 | typedef BOOST_DEDUCED_TYPENAME iterator_value < iterator >::type value_type; | |
69 | typedef BOOST_DEDUCED_TYPENAME iterator_pointer < iterator >::type pointer; | |
70 | typedef BOOST_DEDUCED_TYPENAME iterator_reference< iterator >::type reference; | |
71 | typedef BOOST_DEDUCED_TYPENAME iterator_reference< const_iterator >::type const_reference; | |
72 | ||
73 | typedef BOOST_DEDUCED_TYPENAME Base::size_type size_type; | |
74 | typedef BOOST_DEDUCED_TYPENAME Base::difference_type difference_type; | |
75 | ||
76 | typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<IteratorToBaseConverter>, | |
77 | // { | |
78 | ::boost::bimaps::container_adaptor::detail:: | |
79 | iterator_to_base_identity | |
80 | < | |
81 | BOOST_DEDUCED_TYPENAME Base::iterator , iterator, | |
82 | BOOST_DEDUCED_TYPENAME Base::const_iterator , const_iterator | |
83 | >, | |
84 | // } | |
85 | // else | |
86 | // { | |
87 | IteratorToBaseConverter | |
88 | // } | |
89 | ||
90 | >::type iterator_to_base; | |
91 | ||
92 | typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<IteratorFromBaseConverter>, | |
93 | // { | |
94 | ::boost::bimaps::container_adaptor::detail:: | |
95 | iterator_from_base_identity | |
96 | < | |
97 | BOOST_DEDUCED_TYPENAME Base::iterator , iterator, | |
98 | BOOST_DEDUCED_TYPENAME Base::const_iterator , const_iterator | |
99 | >, | |
100 | // } | |
101 | // else | |
102 | // { | |
103 | IteratorFromBaseConverter | |
104 | // } | |
105 | ||
106 | >::type iterator_from_base; | |
107 | ||
108 | typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<ValueToBaseConverter>, | |
109 | // { | |
110 | ::boost::bimaps::container_adaptor::detail:: | |
111 | value_to_base_identity | |
112 | < | |
113 | BOOST_DEDUCED_TYPENAME Base::value_type, | |
114 | value_type | |
115 | >, | |
116 | // } | |
117 | // else | |
118 | // { | |
119 | ValueToBaseConverter | |
120 | // } | |
121 | ||
122 | >::type value_to_base; | |
123 | ||
124 | typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<ValueFromBaseConverter>, | |
125 | // { | |
126 | ::boost::bimaps::container_adaptor::detail:: | |
127 | value_from_base_identity | |
128 | < | |
129 | BOOST_DEDUCED_TYPENAME Base::value_type, | |
130 | value_type | |
131 | >, | |
132 | // } | |
133 | // else | |
134 | // { | |
135 | ValueFromBaseConverter | |
136 | // } | |
137 | ||
138 | >::type value_from_base; | |
139 | ||
140 | // ACCESS ----------------------------------------------------------------- | |
141 | ||
142 | public: | |
143 | ||
144 | explicit container_adaptor(Base & c) : dwfb(c) {} | |
145 | ||
146 | protected: | |
147 | ||
148 | typedef Base base_type; | |
149 | ||
150 | typedef container_adaptor container_adaptor_; | |
151 | ||
152 | const Base & base() const { return dwfb.data; } | |
153 | Base & base() { return dwfb.data; } | |
154 | ||
155 | // Interface -------------------------------------------------------------- | |
156 | ||
157 | public: | |
158 | ||
159 | size_type size() const { return base().size(); } | |
160 | size_type max_size() const { return base().max_size(); } | |
161 | bool empty() const { return base().empty(); } | |
162 | ||
163 | iterator begin() | |
164 | { | |
165 | return this->template functor<iterator_from_base>()( base().begin() ); | |
166 | } | |
167 | ||
168 | iterator end() | |
169 | { | |
170 | return this->template functor<iterator_from_base>()( base().end() ); | |
171 | } | |
172 | ||
173 | const_iterator begin() const | |
174 | { | |
175 | return this->template functor<iterator_from_base>()( base().begin() ); | |
176 | } | |
177 | ||
178 | const_iterator end() const | |
179 | { | |
180 | return this->template functor<iterator_from_base>()( base().end() ); | |
181 | } | |
182 | ||
183 | ||
184 | iterator erase(iterator pos) | |
185 | { | |
186 | return this->template functor<iterator_from_base>()( | |
187 | base().erase(this->template functor<iterator_to_base>()(pos)) | |
188 | ); | |
189 | } | |
190 | ||
191 | iterator erase(iterator first, iterator last) | |
192 | { | |
193 | return this->template functor<iterator_from_base>()( | |
194 | base().erase( | |
195 | this->template functor<iterator_to_base>()(first), | |
196 | this->template functor<iterator_to_base>()(last) | |
197 | ) | |
198 | ); | |
199 | } | |
200 | ||
201 | void clear() | |
202 | { | |
203 | base().clear(); | |
204 | } | |
205 | ||
206 | template< class InputIterator > | |
207 | void insert(InputIterator iterBegin, InputIterator iterEnd) | |
208 | { | |
209 | for( ; iterBegin != iterEnd ; ++iterBegin ) | |
210 | { | |
211 | base().insert( this->template | |
212 | functor<value_to_base>()( *iterBegin ) | |
213 | ); | |
214 | } | |
215 | } | |
216 | ||
217 | std::pair<iterator, bool> insert( | |
218 | BOOST_DEDUCED_TYPENAME ::boost::call_traits< value_type >::param_type x) | |
219 | { | |
220 | std::pair< BOOST_DEDUCED_TYPENAME Base::iterator, bool > r( | |
221 | base().insert( this->template functor<value_to_base>()(x) ) | |
222 | ); | |
223 | ||
224 | return std::pair<iterator, bool>( this->template | |
225 | functor<iterator_from_base>()(r.first),r.second | |
226 | ); | |
227 | } | |
228 | ||
229 | iterator insert(iterator pos, | |
230 | BOOST_DEDUCED_TYPENAME ::boost::call_traits< value_type >::param_type x) | |
231 | { | |
232 | return this->template functor<iterator_from_base>()( | |
233 | base().insert( | |
234 | this->template functor<iterator_to_base>()(pos), | |
235 | this->template functor<value_to_base>()(x)) | |
236 | ); | |
237 | } | |
238 | ||
239 | void swap( container_adaptor & c ) | |
240 | { | |
241 | base().swap( c.base() ); | |
242 | } | |
243 | ||
244 | // Access to functors ---------------------------------------------------- | |
245 | ||
246 | protected: | |
247 | ||
248 | template< class Functor > | |
249 | Functor & functor() | |
250 | { | |
251 | return dwfb.template functor<Functor>(); | |
252 | } | |
253 | ||
254 | template< class Functor > | |
255 | Functor const & functor() const | |
256 | { | |
257 | return dwfb.template functor<Functor>(); | |
258 | } | |
259 | ||
260 | // Data ------------------------------------------------------------------ | |
261 | ||
262 | private: | |
263 | ||
264 | ::boost::bimaps::container_adaptor::detail::data_with_functor_bag | |
265 | < | |
266 | Base &, | |
267 | ||
268 | BOOST_DEDUCED_TYPENAME mpl::copy | |
269 | < | |
270 | mpl::vector | |
271 | < | |
272 | iterator_to_base, | |
273 | iterator_from_base, | |
274 | value_to_base, | |
275 | value_from_base | |
276 | >, | |
277 | ||
278 | mpl::front_inserter< FunctorsFromDerivedClasses > | |
279 | ||
280 | >::type | |
281 | ||
282 | > dwfb; | |
283 | }; | |
284 | ||
285 | ||
286 | } // namespace container_adaptor | |
287 | } // namespace bimaps | |
288 | } // namespace boost | |
289 | ||
290 | ||
291 | #endif // BOOST_BIMAP_CONTAINER_ADAPTOR_CONTAINER_ADAPTOR_HPP |