ceph/src/boost/libs/bimap/include/boost/bimap/container_adaptor/list_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_adaptor.hpp
  10 /// \brief Container adaptor to easily build a std::list signature compatible container.
  11
  12 #ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_ADAPTOR_HPP
  13 #define BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_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/sequence_container_adaptor.hpp>
  22 #include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
  23 #include <boost/mpl/aux_/na.hpp>
  24 #include <boost/mpl/vector.hpp>
  25 #include <boost/call_traits.hpp>
  26 #include <functional>
  27
  28 namespace boost {
  29 namespace bimaps {
  30 namespace container_adaptor {
  31
  32 /// \brief Container adaptor to easily build a std::list signature compatible container.
  33
  34 template
  35 <
  36     class Base,
  37
  38     class Iterator,
  39     class ConstIterator,
  40     class ReverseIterator,
  41     class ConstReverseIterator,
  42
  43     class IteratorToBaseConverter          = ::boost::mpl::na,
  44     class IteratorFromBaseConverter        = ::boost::mpl::na,
  45     class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
  46     class ValueToBaseConverter             = ::boost::mpl::na,
  47     class ValueFromBaseConverter           = ::boost::mpl::na,
  48
  49     class FunctorsFromDerivedClasses = mpl::vector<>
  50 >
  51 class list_adaptor :
  52
  53     public ::boost::bimaps::container_adaptor::sequence_container_adaptor
  54     <
  55         Base, Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
  56         IteratorToBaseConverter, IteratorFromBaseConverter,
  57         ReverseIteratorFromBaseConverter,
  58         ValueToBaseConverter, ValueFromBaseConverter,
  59         FunctorsFromDerivedClasses
  60     >
  61 {
  62     typedef ::boost::bimaps::container_adaptor::sequence_container_adaptor
  63     <
  64         Base, Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
  65         IteratorToBaseConverter, IteratorFromBaseConverter,
  66         ReverseIteratorFromBaseConverter,
  67         ValueToBaseConverter, ValueFromBaseConverter,
  68         FunctorsFromDerivedClasses
  69
  70     > base_;
  71
  72     // Access -----------------------------------------------------------------
  73
  74     public:
  75
  76     explicit list_adaptor(Base & c) :
  77         base_(c) {}
  78
  79     protected:
  80
  81     typedef list_adaptor list_adaptor_;
  82
  83     // Interface -------------------------------------------------------------
  84
  85     public:
  86
  87     void splice(Iterator position, list_adaptor & x)
  88     {
  89         this->base().splice(
  90             this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()
  91                 (position),
  92             x.base()
  93         );
  94     }
  95
  96     void splice(Iterator position, list_adaptor & x, Iterator i)
  97     {
  98         this->base().splice(
  99             this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()
 100                 (position),
 101             x.base(),
 102             this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
 103         );
 104     }
 105
 106     void splice(Iterator position, list_adaptor & x,
 107                 Iterator first, Iterator last)
 108     {
 109         this->base().splice(
 110             this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()
 111                 (position),
 112             x.base(),
 113             this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
 114             this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
 115         );
 116     }
 117
 118     void remove(
 119         BOOST_DEDUCED_TYPENAME ::boost::call_traits<
 120             BOOST_DEDUCED_TYPENAME base_::value_type
 121         >::param_type value
 122     )
 123     {
 124         this->base().remove(
 125             this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(value)
 126         );
 127     }
 128
 129     template< class Predicate >
 130     void remove_if(Predicate pred)
 131     {
 132         this->base().remove_if(
 133             ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
 134             <
 135                 Predicate,
 136                 BOOST_DEDUCED_TYPENAME Base::value_type,
 137                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 138
 139             >( pred, this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 140         );
 141     }
 142
 143     void unique()
 144     {
 145         this->base().unique(
 146             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 147             <
 148                 std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>,
 149                 BOOST_DEDUCED_TYPENAME Base::value_type,
 150                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 151
 152             >(
 153                 std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>(),
 154                 this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 155             )
 156         );
 157     }
 158
 159     template< class BinaryPredicate >
 160     void unique(BinaryPredicate binary_pred)
 161     {
 162         this->base().unique(
 163             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 164             <
 165                 BinaryPredicate,
 166                 BOOST_DEDUCED_TYPENAME Base::value_type,
 167                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 168
 169             >( binary_pred,
 170                this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 171         );
 172     }
 173
 174     void merge(list_adaptor & x)
 175     {
 176         this->base().merge(x.base(),
 177             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 178             <
 179                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
 180                 BOOST_DEDUCED_TYPENAME Base::value_type,
 181                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 182
 183             >(
 184                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
 185                 this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 186             )
 187         );
 188     }
 189
 190     template< class Compare >
 191     void merge(list_adaptor & x, Compare comp)
 192     {
 193         this->base().merge(x.base(),
 194             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 195             <
 196                 Compare,
 197                 BOOST_DEDUCED_TYPENAME Base::value_type,
 198                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 199
 200             >( comp, this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 201         );
 202     }
 203
 204     void sort()
 205     {
 206         this->base().sort(
 207             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 208             <
 209                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
 210                 BOOST_DEDUCED_TYPENAME Base::value_type,
 211                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 212
 213             >(
 214                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
 215                 this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 216             )
 217         );
 218     }
 219
 220     template< class Compare >
 221     void sort(Compare comp)
 222     {
 223         this->base().sort(
 224             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 225             <
 226                 Compare,
 227                 BOOST_DEDUCED_TYPENAME Base::value_type,
 228                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 229
 230             >( comp, this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 231         );
 232     }
 233
 234     void reverse()
 235     {
 236         this->base().reverse();
 237     }
 238
 239 };
 240
 241
 242 } // namespace container_adaptor
 243 } // namespace bimaps
 244 } // namespace boost
 245
 246
 247 #endif // BOOST_BIMAP_CONTAINER_ADAPTOR_SET_ADAPTOR_HPP
 248
 249