bimap/container_adaptor/unordered_associative_container_adaptor.hpp

0001 // Boost.Bimap
0002 //
0003 // Copyright (c) 2006-2007 Matias Capeletto
0004 //
0005 // Distributed under the Boost Software License, Version 1.0.
0006 // (See accompanying file LICENSE_1_0.txt or copy at
0007 // http://www.boost.org/LICENSE_1_0.txt)
0008
0009 /// \file container_adaptor/unordered_associative_container_adaptor.hpp
0010 /// \brief Container adaptor to build a type that is compliant to the concept of an unordered associative container.
0011
0012 #ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
0013 #define BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
0014
0015 #if defined(_MSC_VER)
0016 #pragma once
0017 #endif
0018
0019 #include <boost/config.hpp>
0020
0021 #include <boost/bimap/container_adaptor/associative_container_adaptor.hpp>
0022 #include <boost/mpl/if.hpp>
0023 #include <boost/mpl/vector.hpp>
0024 #include <boost/mpl/push_front.hpp>
0025 #include <boost/mpl/aux_/na.hpp>
0026 #include <boost/call_traits.hpp>
0027
0028 namespace boost {
0029 namespace bimaps {
0030 namespace container_adaptor {
0031
0032
0033 #ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
0034
0035 template
0036 <
0037     class Base, class Iterator, class ConstIterator,
0038     class LocalIterator, class ConstLocalIterator,
0039     class KeyType,
0040     class IteratorToBaseConverter, class IteratorFromBaseConverter,
0041     class LocalIteratorFromBaseConverter,
0042     class ValueToBaseConverter, class ValueFromBaseConverter,
0043     class KeyToBaseConverter,
0044     class FunctorsFromDerivedClasses
0045 >
0046 struct unordered_associative_container_adaptor_base
0047 {
0048
0049     typedef associative_container_adaptor
0050     <
0051         Base, Iterator, ConstIterator, KeyType,
0052         IteratorToBaseConverter, IteratorFromBaseConverter,
0053         ValueToBaseConverter   , ValueFromBaseConverter,
0054         KeyToBaseConverter,
0055
0056         BOOST_DEDUCED_TYPENAME mpl::push_front<
0057
0058             FunctorsFromDerivedClasses,
0059
0060             BOOST_DEDUCED_TYPENAME mpl::if_<
0061                 ::boost::mpl::is_na<LocalIteratorFromBaseConverter>,
0062             // {
0063                     detail::iterator_from_base_identity
0064                     <
0065                         BOOST_DEDUCED_TYPENAME Base::local_iterator,
0066                         LocalIterator,
0067                         BOOST_DEDUCED_TYPENAME Base::const_local_iterator,
0068                         ConstLocalIterator
0069                     >,
0070             // }
0071             // else
0072             // {
0073                     LocalIteratorFromBaseConverter
0074             // }
0075
0076             >::type
0077
0078         >::type
0079
0080     > type;
0081 };
0082
0083 #endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
0084
0085
0086 /// \brief Container adaptor to build a type that is compliant to the concept of an unordered associative container.
0087
0088 template
0089 <
0090     class Base,
0091
0092     class Iterator,
0093     class ConstIterator,
0094
0095     class LocalIterator,
0096     class ConstLocalIterator,
0097
0098     class KeyType,
0099
0100     class IteratorToBaseConverter        = ::boost::mpl::na,
0101     class IteratorFromBaseConverter      = ::boost::mpl::na,
0102     class LocalIteratorFromBaseConverter = ::boost::mpl::na,
0103     class ValueToBaseConverter           = ::boost::mpl::na,
0104     class ValueFromBaseConverter         = ::boost::mpl::na,
0105     class KeyToBaseConverter             = ::boost::mpl::na,
0106
0107     class FunctorsFromDerivedClasses     = mpl::vector<>
0108
0109 >
0110 class unordered_associative_container_adaptor :
0111
0112     public unordered_associative_container_adaptor_base
0113     <
0114         Base, Iterator, ConstIterator,
0115         LocalIterator, ConstLocalIterator,
0116         KeyType,
0117         IteratorToBaseConverter, IteratorFromBaseConverter,
0118         LocalIteratorFromBaseConverter,
0119         ValueToBaseConverter, ValueFromBaseConverter,
0120         KeyToBaseConverter,
0121         FunctorsFromDerivedClasses
0122
0123     >::type
0124 {
0125     typedef BOOST_DEDUCED_TYPENAME unordered_associative_container_adaptor_base
0126     <
0127         Base, Iterator, ConstIterator,
0128         LocalIterator, ConstLocalIterator,
0129         KeyType,
0130         IteratorToBaseConverter, IteratorFromBaseConverter,
0131         LocalIteratorFromBaseConverter,
0132         ValueToBaseConverter, ValueFromBaseConverter,
0133         KeyToBaseConverter,
0134         FunctorsFromDerivedClasses
0135
0136     >::type base_;
0137
0138     // Metadata ---------------------------------------------------------------
0139
0140     public:
0141
0142     typedef BOOST_DEDUCED_TYPENAME Base::key_equal key_equal;
0143     typedef BOOST_DEDUCED_TYPENAME Base::hasher hasher;
0144
0145     typedef LocalIterator      local_iterator;
0146     typedef ConstLocalIterator const_local_iterator;
0147
0148     protected:
0149
0150     typedef BOOST_DEDUCED_TYPENAME mpl::if_<
0151         ::boost::mpl::is_na<LocalIteratorFromBaseConverter>,
0152         // {
0153                 detail::iterator_from_base_identity
0154                 <
0155                     BOOST_DEDUCED_TYPENAME Base::local_iterator,
0156                     local_iterator,
0157                     BOOST_DEDUCED_TYPENAME Base::const_local_iterator,
0158                     const_local_iterator
0159                 >,
0160         // }
0161         // else
0162         // {
0163                 LocalIteratorFromBaseConverter
0164         // }
0165
0166         >::type local_iterator_from_base;
0167
0168     // Access -----------------------------------------------------------------
0169
0170     public:
0171
0172     explicit unordered_associative_container_adaptor(Base & c)
0173         : base_(c) {}
0174
0175     protected:
0176
0177
0178     typedef unordered_associative_container_adaptor
0179                 unordered_associative_container_adaptor_;
0180
0181     // Interface --------------------------------------------------------------
0182
0183     public:
0184
0185     // bucket interface:
0186
0187     BOOST_DEDUCED_TYPENAME base_::size_type bucket_count() const
0188     {
0189         return this->base().bucket_count();
0190     }
0191
0192     BOOST_DEDUCED_TYPENAME base_::size_type max_bucket_count() const
0193     {
0194         return this->base().max_bucket_count();
0195     }
0196
0197     BOOST_DEDUCED_TYPENAME base_::size_type bucket_size(
0198         BOOST_DEDUCED_TYPENAME base_::size_type n) const
0199     {
0200         return this->base().bucket_size(n);
0201     }
0202
0203     template< class CompatibleKey >
0204     BOOST_DEDUCED_TYPENAME base_::size_type bucket(
0205         const CompatibleKey & k) const
0206     {
0207         typedef BOOST_DEDUCED_TYPENAME base_::key_to_base key_to_base;
0208         return this->base().bucket(
0209             this->template functor<key_to_base>()(k)
0210         );
0211     }
0212
0213     local_iterator       begin(BOOST_DEDUCED_TYPENAME base_::size_type n)
0214     {
0215         return this->template functor<
0216             local_iterator_from_base
0217         >()                          ( this->base().begin(n) );
0218     }
0219
0220     const_local_iterator begin(BOOST_DEDUCED_TYPENAME base_::size_type n) const
0221     {
0222         return this->template functor<
0223             local_iterator_from_base
0224         >()                          ( this->base().begin(n) );
0225     }
0226
0227     local_iterator       end(BOOST_DEDUCED_TYPENAME base_::size_type n)
0228     {
0229         return this->template functor<
0230             local_iterator_from_base
0231         >()                          ( this->base().end(n) );
0232     }
0233
0234     const_local_iterator end(BOOST_DEDUCED_TYPENAME base_::size_type n) const
0235     {
0236         return this->template functor<
0237             local_iterator_from_base
0238         >()                          ( this->base().end(n) );
0239     }
0240
0241     // hash policy
0242
0243     float load_factor() const
0244     {
0245         return this->base().load_factor();
0246     }
0247
0248     float max_load_factor() const
0249     {
0250         return this->base().max_load_factor();
0251     }
0252
0253     void max_load_factor(float z)
0254     {
0255         return this->base().max_load_factor(z);
0256     }
0257
0258     void rehash(BOOST_DEDUCED_TYPENAME base_::size_type n)
0259     {
0260         return this->base().rehash(n);
0261     }
0262
0263     // We have redefined end and begin so we have to manually route the old ones
0264
0265     BOOST_DEDUCED_TYPENAME base_::iterator begin()
0266     {
0267         return base_::container_adaptor_::begin();
0268     }
0269
0270     BOOST_DEDUCED_TYPENAME base_::iterator end()
0271     {
0272         return base_::container_adaptor_::end();
0273     }
0274
0275     BOOST_DEDUCED_TYPENAME base_::const_iterator begin() const
0276     {
0277         return base_::container_adaptor_::begin();
0278     }
0279
0280     BOOST_DEDUCED_TYPENAME base_::const_iterator end() const
0281     {
0282         return base_::container_adaptor_::end();
0283     }
0284
0285 };
0286
0287
0288 } // namespace container_adaptor
0289 } // namespace bimaps
0290 } // namespace boost
0291
0292
0293 #endif // BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP