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/unordered_associative_container_adaptor.hpp
10/// \brief Container adaptor to build a type that is compliant to the concept of an unordered associative container.
11
12#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
13#define BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
14
15#if defined(_MSC_VER)
16#pragma once
17#endif
18
19#include <boost/config.hpp>
20
21#include <boost/bimap/container_adaptor/associative_container_adaptor.hpp>
22#include <boost/mpl/if.hpp>
23#include <boost/mpl/vector.hpp>
24#include <boost/mpl/push_front.hpp>
25#include <boost/mpl/aux_/na.hpp>
26#include <boost/call_traits.hpp>
27
28namespace boost {
29namespace bimaps {
30namespace container_adaptor {
31
32
33#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
34
35template
36<
37 class Base, class Iterator, class ConstIterator,
38 class LocalIterator, class ConstLocalIterator,
39 class KeyType,
40 class IteratorToBaseConverter, class IteratorFromBaseConverter,
41 class LocalIteratorFromBaseConverter,
42 class ValueToBaseConverter, class ValueFromBaseConverter,
43 class KeyToBaseConverter,
44 class FunctorsFromDerivedClasses
45>
46struct unordered_associative_container_adaptor_base
47{
48
49 typedef associative_container_adaptor
50 <
51 Base, Iterator, ConstIterator, KeyType,
52 IteratorToBaseConverter, IteratorFromBaseConverter,
53 ValueToBaseConverter , ValueFromBaseConverter,
54 KeyToBaseConverter,
55
56 BOOST_DEDUCED_TYPENAME mpl::push_front<
57
58 FunctorsFromDerivedClasses,
59
60 BOOST_DEDUCED_TYPENAME mpl::if_<
61 ::boost::mpl::is_na<LocalIteratorFromBaseConverter>,
62 // {
63 detail::iterator_from_base_identity
64 <
65 BOOST_DEDUCED_TYPENAME Base::local_iterator,
66 LocalIterator,
67 BOOST_DEDUCED_TYPENAME Base::const_local_iterator,
68 ConstLocalIterator
69 >,
70 // }
71 // else
72 // {
73 LocalIteratorFromBaseConverter
74 // }
75
76 >::type
77
78 >::type
79
80 > type;
81};
82
83#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
84
85
86/// \brief Container adaptor to build a type that is compliant to the concept of an unordered associative container.
87
88template
89<
90 class Base,
91
92 class Iterator,
93 class ConstIterator,
94
95 class LocalIterator,
96 class ConstLocalIterator,
97
98 class KeyType,
99
100 class IteratorToBaseConverter = ::boost::mpl::na,
101 class IteratorFromBaseConverter = ::boost::mpl::na,
102 class LocalIteratorFromBaseConverter = ::boost::mpl::na,
103 class ValueToBaseConverter = ::boost::mpl::na,
104 class ValueFromBaseConverter = ::boost::mpl::na,
105 class KeyToBaseConverter = ::boost::mpl::na,
106
107 class FunctorsFromDerivedClasses = mpl::vector<>
108
109>
110class unordered_associative_container_adaptor :
111
112 public unordered_associative_container_adaptor_base
113 <
114 Base, Iterator, ConstIterator,
115 LocalIterator, ConstLocalIterator,
116 KeyType,
117 IteratorToBaseConverter, IteratorFromBaseConverter,
118 LocalIteratorFromBaseConverter,
119 ValueToBaseConverter, ValueFromBaseConverter,
120 KeyToBaseConverter,
121 FunctorsFromDerivedClasses
122
123 >::type
124{
125 typedef BOOST_DEDUCED_TYPENAME unordered_associative_container_adaptor_base
126 <
127 Base, Iterator, ConstIterator,
128 LocalIterator, ConstLocalIterator,
129 KeyType,
130 IteratorToBaseConverter, IteratorFromBaseConverter,
131 LocalIteratorFromBaseConverter,
132 ValueToBaseConverter, ValueFromBaseConverter,
133 KeyToBaseConverter,
134 FunctorsFromDerivedClasses
135
136 >::type base_;
137
138 // Metadata ---------------------------------------------------------------
139
140 public:
141
142 typedef BOOST_DEDUCED_TYPENAME Base::key_equal key_equal;
143 typedef BOOST_DEDUCED_TYPENAME Base::hasher hasher;
144
145 typedef LocalIterator local_iterator;
146 typedef ConstLocalIterator const_local_iterator;
147
148 protected:
149
150 typedef BOOST_DEDUCED_TYPENAME mpl::if_<
151 ::boost::mpl::is_na<LocalIteratorFromBaseConverter>,
152 // {
153 detail::iterator_from_base_identity
154 <
155 BOOST_DEDUCED_TYPENAME Base::local_iterator,
156 local_iterator,
157 BOOST_DEDUCED_TYPENAME Base::const_local_iterator,
158 const_local_iterator
159 >,
160 // }
161 // else
162 // {
163 LocalIteratorFromBaseConverter
164 // }
165
166 >::type local_iterator_from_base;
167
168 // Access -----------------------------------------------------------------
169
170 public:
171
172 explicit unordered_associative_container_adaptor(Base & c)
173 : base_(c) {}
174
175 protected:
176
177
178 typedef unordered_associative_container_adaptor
179 unordered_associative_container_adaptor_;
180
181 // Interface --------------------------------------------------------------
182
183 public:
184
185 // bucket interface:
186
187 BOOST_DEDUCED_TYPENAME base_::size_type bucket_count() const
188 {
189 return this->base().bucket_count();
190 }
191
192 BOOST_DEDUCED_TYPENAME base_::size_type max_bucket_count() const
193 {
194 return this->base().max_bucket_count();
195 }
196
197 BOOST_DEDUCED_TYPENAME base_::size_type bucket_size(
198 BOOST_DEDUCED_TYPENAME base_::size_type n) const
199 {
200 return this->base().bucket_size(n);
201 }
202
203 template< class CompatibleKey >
204 BOOST_DEDUCED_TYPENAME base_::size_type bucket(
205 const CompatibleKey & k) const
206 {
207 typedef BOOST_DEDUCED_TYPENAME base_::key_to_base key_to_base;
208 return this->base().bucket(
209 this->template functor<key_to_base>()(k)
210 );
211 }
212
213 local_iterator begin(BOOST_DEDUCED_TYPENAME base_::size_type n)
214 {
215 return this->template functor<
216 local_iterator_from_base
217 >() ( this->base().begin(n) );
218 }
219
220 const_local_iterator begin(BOOST_DEDUCED_TYPENAME base_::size_type n) const
221 {
222 return this->template functor<
223 local_iterator_from_base
224 >() ( this->base().begin(n) );
225 }
226
227 local_iterator end(BOOST_DEDUCED_TYPENAME base_::size_type n)
228 {
229 return this->template functor<
230 local_iterator_from_base
231 >() ( this->base().end(n) );
232 }
233
234 const_local_iterator end(BOOST_DEDUCED_TYPENAME base_::size_type n) const
235 {
236 return this->template functor<
237 local_iterator_from_base
238 >() ( this->base().end(n) );
239 }
240
241 // hash policy
242
243 float load_factor() const
244 {
245 return this->base().load_factor();
246 }
247
248 float max_load_factor() const
249 {
250 return this->base().max_load_factor();
251 }
252
253 void max_load_factor(float z)
254 {
255 return this->base().max_load_factor(z);
256 }
257
258 void rehash(BOOST_DEDUCED_TYPENAME base_::size_type n)
259 {
260 return this->base().rehash(n);
261 }
262
263 // We have redefined end and begin so we have to manually route the old ones
264
265 BOOST_DEDUCED_TYPENAME base_::iterator begin()
266 {
267 return base_::container_adaptor_::begin();
268 }
269
270 BOOST_DEDUCED_TYPENAME base_::iterator end()
271 {
272 return base_::container_adaptor_::end();
273 }
274
275 BOOST_DEDUCED_TYPENAME base_::const_iterator begin() const
276 {
277 return base_::container_adaptor_::begin();
278 }
279
280 BOOST_DEDUCED_TYPENAME base_::const_iterator end() const
281 {
282 return base_::container_adaptor_::end();
283 }
284
285};
286
287
288} // namespace container_adaptor
289} // namespace bimaps
290} // namespace boost
291
292
293#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
294

source code of boost/libs/bimap/include/boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp