boost/bimap/container_adaptor/vector_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/vector_adaptor.hpp
  10 /// \brief Container adaptor to easily build a std::vector signature compatible container.
  11
  12 #ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_ADAPTOR_HPP
  13 #define BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_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/bimap/container_adaptor/sequence_container_adaptor.hpp>
  22 #include <boost/mpl/aux_/na.hpp>
  23 #include <boost/mpl/vector.hpp>
  24
  25 namespace boost {
  26 namespace bimaps {
  27 namespace container_adaptor {
  28
  29 /// \brief Container adaptor to easily build a std::vector signature compatible container.
  30
  31 template
  32 <
  33     class Base,
  34
  35     class Iterator,
  36     class ConstIterator,
  37     class ReverseIterator,
  38     class ConstReverseIterator,
  39
  40     class IteratorToBaseConverter          = ::boost::mpl::na,
  41     class IteratorFromBaseConverter        = ::boost::mpl::na,
  42     class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
  43     class ValueToBaseConverter             = ::boost::mpl::na,
  44     class ValueFromBaseConverter           = ::boost::mpl::na,
  45
  46     class FunctorsFromDerivedClasses = mpl::vector<>
  47 >
  48 class vector_adaptor :
  49
  50     public ::boost::bimaps::container_adaptor::sequence_container_adaptor
  51     <
  52         Base,
  53         Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
  54         IteratorToBaseConverter, IteratorFromBaseConverter,
  55         ReverseIteratorFromBaseConverter,
  56         ValueToBaseConverter, ValueFromBaseConverter,
  57         FunctorsFromDerivedClasses
  58     >
  59 {
  60
  61     typedef ::boost::bimaps::container_adaptor::sequence_container_adaptor
  62     <
  63         Base,
  64         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     vector_adaptor() {}
  77
  78     explicit vector_adaptor(Base & c) :
  79         base_(c) {}
  80
  81     protected:
  82
  83     typedef vector_adaptor vector_adaptor_;
  84
  85     // Interface --------------------------------------------------------------
  86
  87     public:
  88
  89     BOOST_DEDUCED_TYPENAME base_::size_type capacity() const
  90     {
  91         return this->base().capacity();
  92     }
  93
  94     void reserve(BOOST_DEDUCED_TYPENAME base_::size_type m)
  95     {
  96         this->base().resize(m);
  97     }
  98
  99     void resize(BOOST_DEDUCED_TYPENAME base_::size_type n,
 100                 BOOST_DEDUCED_TYPENAME ::boost::call_traits<
 101                     BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x =
 102                         BOOST_DEDUCED_TYPENAME base_::value_type())
 103     {
 104         this->base().resize(n,
 105             this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x)
 106         );
 107     }
 108
 109     BOOST_DEDUCED_TYPENAME base_::const_reference
 110         operator[](BOOST_DEDUCED_TYPENAME base_::size_type n) const
 111     {
 112         return this->base().operator[](n);
 113     }
 114
 115     BOOST_DEDUCED_TYPENAME base_::const_reference
 116         at(BOOST_DEDUCED_TYPENAME base_::size_type n) const
 117     {
 118         return this->base().at(n);
 119     }
 120
 121     BOOST_DEDUCED_TYPENAME base_::reference
 122         operator[](BOOST_DEDUCED_TYPENAME base_::size_type n)
 123     {
 124         return this->base().operator[](n);
 125     }
 126
 127     BOOST_DEDUCED_TYPENAME base_::reference
 128         at(BOOST_DEDUCED_TYPENAME base_::size_type n)
 129     {
 130         return this->base().at(n);
 131     }
 132 };
 133
 134
 135 } // namespace container_adaptor
 136 } // namespace bimaps
 137 } // namespace boost
 138
 139
 140 #endif // BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_ADAPTOR_HPP
 141
 142