boost/bimap/container_adaptor/list_map_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/list_map_adaptor.hpp
  10 /// \brief Container adaptor.
  11
  12 #ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_MAP_ADAPTOR_HPP
  13 #define BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_MAP_ADAPTOR_HPP
  14
  15 #if defined(_MSC_VER) && (_MSC_VER>=1200)
  16 #pragma once
  17 #endif
  18
  19 #include <boost/config.hpp>
  20
  21 #include <boost/mpl/list.hpp>
  22 #include <boost/mpl/push_front.hpp>
  23
  24 #include <boost/bimap/container_adaptor/list_adaptor.hpp>
  25 #include <boost/bimap/container_adaptor/detail/identity_converters.hpp>
  26 #include <boost/bimap/container_adaptor/detail/key_extractor.hpp>
  27 #include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
  28 #include <boost/mpl/vector.hpp>
  29 #include <boost/mpl/aux_/na.hpp>
  30 #include <boost/mpl/if.hpp>
  31
  32 namespace boost {
  33 namespace bimaps {
  34 namespace container_adaptor {
  35
  36 #ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
  37
  38 template
  39 <
  40     class Base, class Iterator, class ConstIterator,
  41     class ReverseIterator, class ConstReverseIterator,
  42     class IteratorToBaseConverter, class IteratorFromBaseConverter,
  43     class ReverseIteratorFromBaseConverter,
  44     class ValueToBaseConverter, class ValueFromBaseConverter,
  45     class KeyFromBaseValueConverter,
  46     class FunctorsFromDerivedClasses
  47 >
  48 struct list_map_adaptor_base
  49 {
  50     typedef list_adaptor
  51     <
  52         Base,
  53
  54         Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
  55
  56         IteratorToBaseConverter, IteratorFromBaseConverter,
  57
  58         ReverseIteratorFromBaseConverter,
  59
  60         ValueToBaseConverter, ValueFromBaseConverter,
  61
  62         BOOST_DEDUCED_TYPENAME mpl::push_front<
  63
  64             FunctorsFromDerivedClasses,
  65
  66             BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyFromBaseValueConverter>,
  67             // {
  68                     detail::key_from_pair_extractor
  69                     <
  70                         BOOST_DEDUCED_TYPENAME Iterator::value_type
  71                     >,
  72             // }
  73             // else
  74             // {
  75                     KeyFromBaseValueConverter
  76             // }
  77
  78             >::type
  79
  80         >::type
  81
  82     > type;
  83 };
  84
  85 #endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
  86
  87 /// \brief Container adaptor to easily build a list map container
  88
  89 template
  90 <
  91     class Base,
  92
  93     class Iterator,
  94     class ConstIterator,
  95     class ReverseIterator,
  96     class ConstReverseIterator,
  97
  98     class IteratorToBaseConverter          = ::boost::mpl::na,
  99     class IteratorFromBaseConverter        = ::boost::mpl::na,
 100     class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
 101     class ValueToBaseConverter             = ::boost::mpl::na,
 102     class ValueFromBaseConverter           = ::boost::mpl::na,
 103     class KeyFromBaseValueConverter        = ::boost::mpl::na,
 104
 105     class FunctorsFromDerivedClasses = mpl::vector<>
 106 >
 107 class list_map_adaptor :
 108
 109     public list_map_adaptor_base
 110     <
 111         Base, Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
 112         IteratorToBaseConverter, IteratorFromBaseConverter,
 113         ReverseIteratorFromBaseConverter,
 114         ValueToBaseConverter, ValueFromBaseConverter,
 115         KeyFromBaseValueConverter,
 116         FunctorsFromDerivedClasses
 117
 118     >::type
 119 {
 120     typedef BOOST_DEDUCED_TYPENAME list_map_adaptor_base
 121     <
 122         Base, Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
 123         IteratorToBaseConverter, IteratorFromBaseConverter,
 124         ReverseIteratorFromBaseConverter,
 125         ValueToBaseConverter, ValueFromBaseConverter,
 126         KeyFromBaseValueConverter,
 127         FunctorsFromDerivedClasses
 128
 129     >::type base_;
 130
 131     // MetaData -------------------------------------------------------------
 132
 133     public:
 134
 135     typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type  key_type;
 136     typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::second_type data_type;
 137
 138     protected:
 139
 140     typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyFromBaseValueConverter>,
 141     // {
 142             detail::key_from_pair_extractor< BOOST_DEDUCED_TYPENAME Iterator::value_type >,
 143     // }
 144     // else
 145     // {
 146             KeyFromBaseValueConverter
 147     // }
 148
 149     >::type key_from_base_value;
 150
 151     // Access -----------------------------------------------------------------
 152
 153     public:
 154
 155     explicit list_map_adaptor(Base & c) :
 156         base_(c) {}
 157
 158     protected:
 159
 160     typedef list_map_adaptor list_map_adaptor_;
 161
 162     // Functions -------------------------------------------------------------
 163
 164     public:
 165
 166     // The following functions are overwritten in order to work
 167     // with key_type instead of value_type
 168
 169     template< class Predicate >
 170     void remove_if(Predicate pred)
 171     {
 172         this->base().remove_if(
 173             ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
 174             <
 175                 Predicate,
 176                 BOOST_DEDUCED_TYPENAME Base::value_type,
 177                 key_from_base_value
 178
 179             >( pred, this->template functor<key_from_base_value>() )
 180         );
 181     }
 182
 183     void unique()
 184     {
 185         this->base().unique(
 186             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 187             <
 188                 std::equal_to<key_type>,
 189                 BOOST_DEDUCED_TYPENAME Base::value_type,
 190                 key_from_base_value
 191
 192             >(
 193                 std::equal_to<key_type>(),
 194                 this->template functor<key_from_base_value>()
 195             )
 196         );
 197     }
 198
 199     template< class BinaryPredicate >
 200     void unique(BinaryPredicate binary_pred)
 201     {
 202         this->base().unique(
 203             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 204             <
 205                 BinaryPredicate,
 206                 BOOST_DEDUCED_TYPENAME Base::value_type,
 207                 key_from_base_value
 208
 209             >( binary_pred, this->template functor<key_from_base_value>() )
 210         );
 211     }
 212
 213     void merge(list_map_adaptor & x)
 214     {
 215         this->base().merge(x.base(),
 216             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 217             <
 218                 std::less<key_type>,
 219                 BOOST_DEDUCED_TYPENAME Base::value_type,
 220                 key_from_base_value
 221
 222             >(
 223                 std::less<key_type>(),
 224                 this->template functor<key_from_base_value>()
 225             )
 226         );
 227     }
 228
 229     template< class Compare >
 230     void merge(list_map_adaptor & x, Compare comp)
 231     {
 232         this->base().merge(x.base(),
 233             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 234             <
 235                 Compare,
 236                 BOOST_DEDUCED_TYPENAME Base::value_type,
 237                 key_from_base_value
 238
 239             >( comp, this->template functor<key_from_base_value>() )
 240         );
 241     }
 242
 243     void sort()
 244     {
 245         this->base().sort(
 246             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 247             <
 248                 std::less<key_type>,
 249                 BOOST_DEDUCED_TYPENAME Base::value_type,
 250                 key_from_base_value
 251
 252             >(
 253                 std::less<key_type>(),
 254                 this->template functor<key_from_base_value>()
 255             )
 256         );
 257     }
 258
 259     template< class Compare >
 260     void sort(Compare comp)
 261     {
 262         this->base().sort(
 263             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 264             <
 265                 Compare,
 266                 BOOST_DEDUCED_TYPENAME Base::value_type,
 267                 key_from_base_value
 268
 269             >( comp, this->template functor<key_from_base_value>() )
 270         );
 271     }
 272
 273 };
 274
 275
 276 } // namespace container_adaptor
 277 } // namespace bimaps
 278 } // namespace boost
 279
 280
 281 #endif // BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_MAP_ADAPTOR_HPP
 282