ceph/src/boost/boost/bimap/views/vector_set_view.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 views/vector_set_view.hpp
  10 /// \brief View of a side of a bimap that is signature compatible with std::vector.
  11
  12 #ifndef BOOST_BIMAP_VIEWS_VECTOR_SET_VIEW_HPP
  13 #define BOOST_BIMAP_VIEWS_VECTOR_SET_VIEW_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/vector_adaptor.hpp>
  22 #include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
  23 #include <boost/bimap/detail/set_view_base.hpp>
  24 #include <boost/bimap/detail/map_view_base.hpp>
  25
  26 namespace boost {
  27 namespace bimaps {
  28 namespace views {
  29
  30 /// \brief View of a bimap that is signature compatible with std::vector.
  31 /**
  32
  33 This class uses container_adaptor and iterator_adaptor to wrapped a index of the
  34 multi_index bimap core so it can be used as a std::vector.
  35
  36 See also const_set_view.
  37                                                                                     **/
  38
  39 template< class CoreIndex >
  40 class vector_set_view
  41 :
  42     public BOOST_BIMAP_SEQUENCED_SET_VIEW_CONTAINER_ADAPTOR(
  43         vector_adaptor,
  44         CoreIndex,
  45         reverse_iterator, const_reverse_iterator
  46     ),
  47
  48     public ::boost::bimaps::detail::
  49                 set_view_base< vector_set_view< CoreIndex >, CoreIndex >
  50 {
  51     BOOST_BIMAP_SET_VIEW_BASE_FRIEND(vector_set_view,CoreIndex)
  52
  53     typedef BOOST_BIMAP_SEQUENCED_SET_VIEW_CONTAINER_ADAPTOR(
  54         vector_adaptor,
  55         CoreIndex,
  56         reverse_iterator, const_reverse_iterator
  57
  58     ) base_;
  59
  60     public:
  61
  62     vector_set_view(BOOST_DEDUCED_TYPENAME base_::base_type & c) :
  63         base_(c) {}
  64
  65     vector_set_view & operator=(const vector_set_view & v)
  66     {
  67         this->base() = v.base();
  68         return *this;
  69     }
  70
  71         BOOST_DEDUCED_TYPENAME base_::const_reference
  72         operator[](BOOST_DEDUCED_TYPENAME base_::size_type n) const
  73     {
  74         return this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()(
  75             this->base().operator[](n)
  76         );
  77     }
  78
  79     BOOST_DEDUCED_TYPENAME base_::const_reference
  80         at(BOOST_DEDUCED_TYPENAME base_::size_type n) const
  81     {
  82         return this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()(
  83             this->base().at(n)
  84         );
  85     }
  86
  87     BOOST_DEDUCED_TYPENAME base_::reference
  88         operator[](BOOST_DEDUCED_TYPENAME base_::size_type n)
  89     {
  90         return this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()(
  91             const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type &>(
  92                 this->base().operator[](n)
  93         ));
  94     }
  95
  96     BOOST_DEDUCED_TYPENAME base_::reference
  97         at(BOOST_DEDUCED_TYPENAME base_::size_type n)
  98     {
  99         return this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()(
 100             const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type &>(
 101                 this->base().at(n)
 102         ));
 103     }
 104
 105     BOOST_BIMAP_VIEW_ASSIGN_IMPLEMENTATION(base_)
 106
 107     BOOST_BIMAP_VIEW_FRONT_BACK_IMPLEMENTATION(base_)
 108
 109     // List operations
 110
 111     void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
 112                 vector_set_view & x)
 113     {
 114         this->base().splice(
 115             this->template functor<
 116                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
 117             x.base()
 118         );
 119     }
 120
 121     void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
 122                 vector_set_view & x,
 123                 BOOST_DEDUCED_TYPENAME base_::iterator i)
 124     {
 125         this->base().splice(
 126             this->template functor<
 127                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
 128             x.base(),
 129             this->template functor<
 130                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
 131         );
 132     }
 133
 134     void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
 135                 vector_set_view & x,
 136                 BOOST_DEDUCED_TYPENAME base_::iterator first,
 137                 BOOST_DEDUCED_TYPENAME base_::iterator last)
 138     {
 139         this->base().splice(
 140             this->template functor<
 141                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
 142             x.base(),
 143             this->template functor<
 144                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
 145             this->template functor<
 146                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
 147         );
 148     }
 149
 150     void remove(BOOST_DEDUCED_TYPENAME ::boost::call_traits<
 151                     BOOST_DEDUCED_TYPENAME base_::value_type >::param_type value)
 152     {
 153         this->base().remove(
 154             this->template functor<
 155                 BOOST_DEDUCED_TYPENAME base_::value_to_base>()(value)
 156         );
 157     }
 158
 159     template<typename Predicate>
 160     void remove_if(Predicate pred)
 161     {
 162         this->base().remove_if(
 163             ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
 164             <
 165                 Predicate,
 166                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 167                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 168
 169             >( pred, this->template functor<
 170                             BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 171         );
 172     }
 173
 174     void unique()
 175     {
 176         this->base().unique(
 177             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 178             <
 179                 std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>,
 180                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 181                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 182
 183             >(
 184                 std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>(),
 185                 this->template functor<
 186                     BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 187             )
 188         );
 189     }
 190
 191     template< class BinaryPredicate >
 192     void unique(BinaryPredicate binary_pred)
 193     {
 194         this->base().unique(
 195             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 196             <
 197                 BinaryPredicate,
 198                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 199                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 200
 201             >( binary_pred,
 202                this->template functor<
 203                     BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 204             )
 205         );
 206     }
 207
 208     void merge(vector_set_view & x)
 209     {
 210         this->base().merge(x.base(),
 211             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 212             <
 213                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
 214                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 215                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 216
 217             >(
 218                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
 219                 this->template functor<
 220                         BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 221             )
 222         );
 223     }
 224
 225     template< class Compare >
 226     void merge(vector_set_view & x, Compare comp)
 227     {
 228         this->base().merge(x.base(),
 229             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 230             <
 231                 Compare,
 232                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 233                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 234
 235             >( comp, this->template functor<
 236                         BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 237         );
 238     }
 239
 240     void sort()
 241     {
 242         this->base().sort(
 243             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 244             <
 245                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
 246                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 247                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 248
 249             >(
 250                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
 251                 this->template functor<
 252                     BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 253             )
 254         );
 255     }
 256
 257     template< class Compare >
 258     void sort(Compare comp)
 259     {
 260         this->base().sort(
 261             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 262             <
 263                 Compare,
 264                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 265                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 266
 267             >( comp, this->template functor<
 268                         BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 269         );
 270     }
 271
 272     void reverse()
 273     {
 274         this->base().reverse();
 275     }
 276
 277     // Rearrange Operations
 278
 279     void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
 280                   BOOST_DEDUCED_TYPENAME base_::iterator i)
 281     {
 282         this->base().relocate(
 283             this->template functor<
 284                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
 285             this->template functor<
 286                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
 287         );
 288     }
 289
 290     void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
 291                   BOOST_DEDUCED_TYPENAME base_::iterator first,
 292                   BOOST_DEDUCED_TYPENAME base_::iterator last)
 293     {
 294         this->base().relocate(
 295             this->template functor<
 296                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
 297             this->template functor<
 298                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
 299             this->template functor<
 300                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
 301         );
 302     }
 303
 304 };
 305
 306
 307 } // namespace views
 308 } // namespace bimaps
 309 } // namespace boost
 310
 311
 312 #endif // BOOST_BIMAP_VIEWS_VECTOR_SET_VIEW_HPP
 313