ceph/src/boost/libs/bimap/include/boost/bimap/container_adaptor/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/associative_container_adaptor.hpp
  10 /// \brief Container adaptor to build a type that is compliant to the concept of an associative container.
  11
  12 #ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
  13 #define BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_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/vector.hpp>
  24 #include <boost/mpl/if.hpp>
  25 #include <boost/mpl/aux_/na.hpp>
  26 #include <boost/bimap/container_adaptor/detail/identity_converters.hpp>
  27 #include <boost/bimap/container_adaptor/container_adaptor.hpp>
  28 #include <boost/call_traits.hpp>
  29
  30 namespace boost {
  31 namespace bimaps {
  32 namespace container_adaptor {
  33
  34 #ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
  35
  36 template
  37 <
  38     class Base, class Iterator, class ConstIterator, class KeyType,
  39     class IteratorToBaseConverter, class IteratorFromBaseConverter,
  40     class ValueToBaseConverter, class ValueFromBaseConverter, class KeyToBaseConverter,
  41     class FunctorsFromDerivedClasses
  42 >
  43 struct associative_container_adaptor_base
  44 {
  45     typedef container_adaptor
  46     <
  47         Base,
  48
  49         Iterator, ConstIterator,
  50
  51         IteratorToBaseConverter, IteratorFromBaseConverter,
  52         ValueToBaseConverter   , ValueFromBaseConverter,
  53
  54         BOOST_DEDUCED_TYPENAME mpl::push_front<
  55
  56             FunctorsFromDerivedClasses,
  57
  58             BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyToBaseConverter>,
  59             // {
  60                     detail::key_to_base_identity
  61                     <
  62                         BOOST_DEDUCED_TYPENAME Base::key_type, KeyType
  63                     >,
  64             // }
  65             // else
  66             // {
  67                     KeyToBaseConverter
  68             // }
  69
  70             >::type
  71
  72         >::type
  73
  74     > type;
  75 };
  76
  77 #endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
  78
  79
  80 /// \brief Container adaptor to build a type that is compliant to the concept of an associative container.
  81
  82 template
  83 <
  84     class Base,
  85
  86     class Iterator,
  87     class ConstIterator,
  88
  89     class KeyType,
  90
  91     class IteratorToBaseConverter   = ::boost::mpl::na,
  92     class IteratorFromBaseConverter = ::boost::mpl::na,
  93     class ValueToBaseConverter      = ::boost::mpl::na,
  94     class ValueFromBaseConverter    = ::boost::mpl::na,
  95     class KeyToBaseConverter        = ::boost::mpl::na,
  96
  97     class FunctorsFromDerivedClasses = mpl::vector<>
  98 >
  99 class associative_container_adaptor :
 100
 101     public associative_container_adaptor_base
 102     <
 103         Base, Iterator, ConstIterator, KeyType,
 104         IteratorToBaseConverter, IteratorFromBaseConverter,
 105         ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,
 106         FunctorsFromDerivedClasses
 107
 108     >::type
 109 {
 110
 111     // MetaData -------------------------------------------------------------
 112
 113     typedef typename associative_container_adaptor_base
 114     <
 115         Base, Iterator, ConstIterator, KeyType,
 116         IteratorToBaseConverter, IteratorFromBaseConverter,
 117         ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,
 118         FunctorsFromDerivedClasses
 119
 120     >::type base_;
 121
 122     public:
 123
 124     typedef KeyType key_type;
 125
 126     protected:
 127
 128     typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyToBaseConverter>,
 129     // {
 130             detail::key_to_base_identity
 131             <
 132                 BOOST_DEDUCED_TYPENAME Base::key_type, KeyType
 133             >,
 134     // }
 135     // else
 136     // {
 137             KeyToBaseConverter
 138     // }
 139
 140     >::type key_to_base;
 141
 142     public:
 143
 144     explicit associative_container_adaptor(Base & c)
 145         : base_(c) {}
 146
 147     protected:
 148
 149
 150     typedef associative_container_adaptor associative_container_adaptor_;
 151
 152     // Interface --------------------------------------------------------------
 153
 154     public:
 155
 156     template< class CompatibleKey >
 157     BOOST_DEDUCED_TYPENAME base_::size_type erase(const CompatibleKey & k)
 158     {
 159         return this->base().erase
 160         (
 161             this->template functor<key_to_base>()(k)
 162         );
 163     }
 164
 165     // As we redefine erase, the other overloads need to be manually routed
 166
 167     BOOST_DEDUCED_TYPENAME base_::iterator erase(
 168         BOOST_DEDUCED_TYPENAME base_::iterator pos)
 169     {
 170         return base_::container_adaptor_::erase(pos);
 171     }
 172
 173     BOOST_DEDUCED_TYPENAME base_::iterator erase(
 174         BOOST_DEDUCED_TYPENAME base_::iterator first,
 175         BOOST_DEDUCED_TYPENAME base_::iterator last)
 176     {
 177         return base_::container_adaptor_::erase(first,last);
 178     }
 179
 180     template< class CompatibleKey >
 181     BOOST_DEDUCED_TYPENAME base_::size_type count(const CompatibleKey & k) const
 182     {
 183         return this->base().count(
 184             this->template functor<key_to_base>()(k)
 185         );
 186     }
 187
 188     template< class CompatibleKey >
 189     BOOST_DEDUCED_TYPENAME base_::iterator find(const CompatibleKey & k)
 190     {
 191         return this->template functor<typename base_::iterator_from_base>()
 192         (
 193             this->base().find(
 194                 this->template functor<key_to_base>()(k)
 195             )
 196         );
 197     }
 198
 199     template< class CompatibleKey >
 200     BOOST_DEDUCED_TYPENAME base_::const_iterator
 201         find(const CompatibleKey & k) const
 202     {
 203         return this->template functor<
 204             BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()
 205         (
 206             this->base().find(
 207                 this->template functor<key_to_base>()(k)
 208             )
 209         );
 210     }
 211
 212     template< class CompatibleKey >
 213     std::pair
 214     <
 215         BOOST_DEDUCED_TYPENAME base_::iterator,
 216         BOOST_DEDUCED_TYPENAME base_::iterator
 217     >
 218         equal_range(const CompatibleKey & k)
 219     {
 220         std::pair<
 221
 222             BOOST_DEDUCED_TYPENAME Base::iterator,
 223             BOOST_DEDUCED_TYPENAME Base::iterator
 224
 225         > r( this->base().equal_range(
 226                 this->template functor<key_to_base>()(k)
 227             )
 228         );
 229
 230         return std::pair
 231         <
 232             BOOST_DEDUCED_TYPENAME base_::iterator,
 233             BOOST_DEDUCED_TYPENAME base_::iterator
 234         >(
 235             this->template functor<
 236                 BOOST_DEDUCED_TYPENAME base_::iterator_from_base
 237             >()                                         ( r.first ),
 238             this->template functor<
 239                 BOOST_DEDUCED_TYPENAME base_::iterator_from_base
 240             >()                                         ( r.second )
 241         );
 242     }
 243
 244     template< class CompatibleKey >
 245     std::pair
 246     <
 247         BOOST_DEDUCED_TYPENAME base_::const_iterator,
 248         BOOST_DEDUCED_TYPENAME base_::const_iterator
 249     >
 250         equal_range(const CompatibleKey & k) const
 251     {
 252         std::pair<
 253
 254             BOOST_DEDUCED_TYPENAME Base::const_iterator,
 255             BOOST_DEDUCED_TYPENAME Base::const_iterator
 256
 257         > r( this->base().equal_range(
 258                 this->template functor<key_to_base>()(k)
 259             )
 260         );
 261
 262         return std::pair
 263         <
 264             BOOST_DEDUCED_TYPENAME base_::const_iterator,
 265             BOOST_DEDUCED_TYPENAME base_::const_iterator
 266         >(
 267             this->template functor<
 268                 BOOST_DEDUCED_TYPENAME base_::iterator_from_base
 269             >()                                         ( r.first ),
 270             this->template functor<
 271                 BOOST_DEDUCED_TYPENAME base_::iterator_from_base
 272             >()                                         ( r.second )
 273         );
 274     }
 275
 276 };
 277
 278
 279 } // namespace container_adaptor
 280 } // namespace bimaps
 281 } // namespace boost
 282
 283
 284 #endif // BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
 285
 286
 287