ceph/src/boost/boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp

   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
 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