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 28 namespace boost { 29 namespace bimaps { 30 namespace container_adaptor { 31 32 33 #ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES 34 35 template 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 > 46 struct 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 88 template 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 > 110 class 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 unordered_associative_container_adaptor(Base & c)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 bucket_count() const187 BOOST_DEDUCED_TYPENAME base_::size_type bucket_count() const 188 { 189 return this->base().bucket_count(); 190 } 191 max_bucket_count() const192 BOOST_DEDUCED_TYPENAME base_::size_type max_bucket_count() const 193 { 194 return this->base().max_bucket_count(); 195 } 196 bucket_size(BOOST_DEDUCED_TYPENAME base_::size_type n) const197 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 > bucket(const CompatibleKey & k) const204 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 begin(BOOST_DEDUCED_TYPENAME base_::size_type n)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 begin(BOOST_DEDUCED_TYPENAME base_::size_type n) const220 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 end(BOOST_DEDUCED_TYPENAME base_::size_type n)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 end(BOOST_DEDUCED_TYPENAME base_::size_type n) const234 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 load_factor() const243 float load_factor() const 244 { 245 return this->base().load_factor(); 246 } 247 max_load_factor() const248 float max_load_factor() const 249 { 250 return this->base().max_load_factor(); 251 } 252 max_load_factor(float z)253 void max_load_factor(float z) 254 { 255 return this->base().max_load_factor(z); 256 } 257 rehash(BOOST_DEDUCED_TYPENAME base_::size_type n)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 begin()265 BOOST_DEDUCED_TYPENAME base_::iterator begin() 266 { 267 return base_::container_adaptor_::begin(); 268 } 269 end()270 BOOST_DEDUCED_TYPENAME base_::iterator end() 271 { 272 return base_::container_adaptor_::end(); 273 } 274 begin() const275 BOOST_DEDUCED_TYPENAME base_::const_iterator begin() const 276 { 277 return base_::container_adaptor_::begin(); 278 } 279 end() const280 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