boost_ext/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) && (_MSC_VER>=1200)
  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
  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_BIMAP_VIEW_ASSIGN_IMPLEMENTATION(base_)
  72
  73     BOOST_BIMAP_VIEW_FRONT_BACK_IMPLEMENTATION(base_)
  74
  75     // List operations
  76
  77     void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
  78                 vector_set_view & x)
  79     {
  80         this->base().splice(
  81             this->template functor<
  82                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
  83             x.base()
  84         );
  85     }
  86
  87     void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
  88                 vector_set_view & x,
  89                 BOOST_DEDUCED_TYPENAME base_::iterator i)
  90     {
  91         this->base().splice(
  92             this->template functor<
  93                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
  94             x.base(),
  95             this->template functor<
  96                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
  97         );
  98     }
  99
 100     void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
 101                 vector_set_view & x,
 102                 BOOST_DEDUCED_TYPENAME base_::iterator first,
 103                 BOOST_DEDUCED_TYPENAME base_::iterator last)
 104     {
 105         this->base().splice(
 106             this->template functor<
 107                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
 108             x.base(),
 109             this->template functor<
 110                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
 111             this->template functor<
 112                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
 113         );
 114     }
 115
 116     void remove(BOOST_DEDUCED_TYPENAME ::boost::call_traits<
 117                     BOOST_DEDUCED_TYPENAME base_::value_type >::param_type value)
 118     {
 119         this->base().remove(
 120             this->template functor<
 121                 BOOST_DEDUCED_TYPENAME base_::value_to_base>()(value)
 122         );
 123     }
 124
 125     template<typename Predicate>
 126     void remove_if(Predicate pred)
 127     {
 128         this->base().remove_if(
 129             ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
 130             <
 131                 Predicate,
 132                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 133                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 134
 135             >( pred, this->template functor<
 136                             BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 137         );
 138     }
 139
 140     void unique()
 141     {
 142         this->base().unique(
 143             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 144             <
 145                 std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>,
 146                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 147                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 148
 149             >(
 150                 std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>(),
 151                 this->template functor<
 152                     BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 153             )
 154         );
 155     }
 156
 157     template< class BinaryPredicate >
 158     void unique(BinaryPredicate binary_pred)
 159     {
 160         this->base().unique(
 161             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 162             <
 163                 BinaryPredicate,
 164                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 165                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 166
 167             >( binary_pred,
 168                this->template functor<
 169                     BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 170             )
 171         );
 172     }
 173
 174     void merge(vector_set_view & 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_::base_type::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<
 186                         BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 187             )
 188         );
 189     }
 190
 191     template< class Compare >
 192     void merge(vector_set_view & x, Compare comp)
 193     {
 194         this->base().merge(x.base(),
 195             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 196             <
 197                 Compare,
 198                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 199                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 200
 201             >( comp, this->template functor<
 202                         BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 203         );
 204     }
 205
 206     void sort()
 207     {
 208         this->base().sort(
 209             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 210             <
 211                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
 212                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 213                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 214
 215             >(
 216                 std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
 217                 this->template functor<
 218                     BOOST_DEDUCED_TYPENAME base_::value_from_base>()
 219             )
 220         );
 221     }
 222
 223     template< class Compare >
 224     void sort(Compare comp)
 225     {
 226         this->base().sort(
 227             ::boost::bimaps::container_adaptor::detail::comparison_adaptor
 228             <
 229                 Compare,
 230                 BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
 231                 BOOST_DEDUCED_TYPENAME base_::value_from_base
 232
 233             >( comp, this->template functor<
 234                         BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
 235         );
 236     }
 237
 238     void reverse()
 239     {
 240         this->base().reverse();
 241     }
 242
 243     // Rearrange Operations
 244
 245     void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
 246                   BOOST_DEDUCED_TYPENAME base_::iterator i)
 247     {
 248         this->base().relocate(
 249             this->template functor<
 250                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
 251             this->template functor<
 252                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
 253         );
 254     }
 255
 256     void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
 257                   BOOST_DEDUCED_TYPENAME base_::iterator first,
 258                   BOOST_DEDUCED_TYPENAME base_::iterator last)
 259     {
 260         this->base().relocate(
 261             this->template functor<
 262                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
 263             this->template functor<
 264                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
 265             this->template functor<
 266                 BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
 267         );
 268     }
 269
 270 };
 271
 272
 273 } // namespace views
 274 } // namespace bimaps
 275 } // namespace boost
 276
 277
 278 #endif // BOOST_BIMAP_VIEWS_VECTOR_SET_VIEW_HPP
 279