boost/interprocess/detail/transform_iterator.hpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2005-2008.
   4 // (C) Copyright Gennaro Prota 2003 - 2004.
   5 //
   6 // Distributed under the Boost Software License, Version 1.0.
   7 // (See accompanying file LICENSE_1_0.txt or copy at
   8 // http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10 // See http://www.boost.org/libs/interprocess for documentation.
  11 //
  12 //////////////////////////////////////////////////////////////////////////////
  13
  14 #ifndef BOOST_INTERPROCESS_DETAIL_TRANSFORM_ITERATORS_HPP
  15 #define BOOST_INTERPROCESS_DETAIL_TRANSFORM_ITERATORS_HPP
  16
  17 #if (defined _MSC_VER) && (_MSC_VER >= 1200)
  18 #  pragma once
  19 #endif
  20
  21 #include <boost/interprocess/detail/config_begin.hpp>
  22 #include <boost/interprocess/detail/workaround.hpp>
  23
  24 #include <boost/interprocess/interprocess_fwd.hpp>
  25
  26 #include <iterator>
  27 #include <boost/interprocess/detail/type_traits.hpp>
  28
  29 namespace boost {
  30 namespace interprocess {
  31
  32 template <class PseudoReference>
  33 struct operator_arrow_proxy
  34 {
  35    operator_arrow_proxy(const PseudoReference &px)
  36       :  m_value(px)
  37    {}
  38
  39    PseudoReference* operator->() const { return &m_value; }
  40    // This function is needed for MWCW and BCC, which won't call operator->
  41    // again automatically per 13.3.1.2 para 8
  42 //   operator T*() const { return &m_value; }
  43    mutable PseudoReference m_value;
  44 };
  45
  46 template <class T>
  47 struct operator_arrow_proxy<T&>
  48 {
  49    operator_arrow_proxy(T &px)
  50       :  m_value(px)
  51    {}
  52
  53    T* operator->() const { return &m_value; }
  54    // This function is needed for MWCW and BCC, which won't call operator->
  55    // again automatically per 13.3.1.2 para 8
  56 //   operator T*() const { return &m_value; }
  57    mutable T &m_value;
  58 };
  59
  60 template <class Iterator, class UnaryFunction>
  61 class transform_iterator
  62    : public UnaryFunction
  63    , public std::iterator
  64       < typename Iterator::iterator_category
  65       , typename detail::remove_reference<typename UnaryFunction::result_type>::type
  66       , typename Iterator::difference_type
  67       , operator_arrow_proxy<typename UnaryFunction::result_type>
  68       , typename UnaryFunction::result_type>
  69 {
  70    public:
  71    explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
  72       :  UnaryFunction(f), m_it(it)
  73    {}
  74
  75    explicit transform_iterator()
  76       :  UnaryFunction(), m_it()
  77    {}
  78
  79    //Constructors
  80    transform_iterator& operator++()
  81    { increment();   return *this;   }
  82
  83    transform_iterator operator++(int)
  84    {
  85       transform_iterator result (*this);
  86       increment();
  87       return result;
  88    }
  89
  90    friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
  91    { return i.equal(i2); }
  92
  93    friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
  94    { return !(i == i2); }
  95
  96 /*
  97    friend bool operator> (const transform_iterator& i, const transform_iterator& i2)
  98    { return i2 < i; }
  99
 100    friend bool operator<= (const transform_iterator& i, const transform_iterator& i2)
 101    { return !(i > i2); }
 102
 103    friend bool operator>= (const transform_iterator& i, const transform_iterator& i2)
 104    { return !(i < i2); }
 105 */
 106    friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
 107    { return i2.distance_to(i); }
 108
 109    //Arithmetic
 110    transform_iterator& operator+=(typename Iterator::difference_type off)
 111    {  this->advance(off); return *this;   }
 112
 113    transform_iterator operator+(typename Iterator::difference_type off) const
 114    {
 115       transform_iterator other(*this);
 116       other.advance(off);
 117       return other;
 118    }
 119
 120    friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
 121    {  return right + off; }
 122
 123    transform_iterator& operator-=(typename Iterator::difference_type off)
 124    {  this->advance(-off); return *this;   }
 125
 126    transform_iterator operator-(typename Iterator::difference_type off) const
 127    {  return *this + (-off);  }
 128
 129    typename UnaryFunction::result_type operator*() const
 130    { return dereference(); }
 131
 132    operator_arrow_proxy<typename UnaryFunction::result_type>
 133       operator->() const
 134    { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference());  }
 135
 136    Iterator & base()
 137    {  return m_it;   }
 138
 139    const Iterator & base() const
 140    {  return m_it;   }
 141
 142    private:
 143    Iterator m_it;
 144
 145    void increment()
 146    { ++m_it; }
 147
 148    void decrement()
 149    { --m_it; }
 150
 151    bool equal(const transform_iterator &other) const
 152    {  return m_it == other.m_it;   }
 153
 154    bool less(const transform_iterator &other) const
 155    {  return other.m_it < m_it;   }
 156
 157    typename UnaryFunction::result_type dereference() const
 158    { return UnaryFunction::operator()(*m_it); }
 159
 160    void advance(typename Iterator::difference_type n)
 161    {  std::advance(m_it, n); }
 162
 163    typename Iterator::difference_type distance_to(const transform_iterator &other)const
 164    {  return std::distance(other.m_it, m_it); }
 165 };
 166
 167 template <class Iterator, class UnaryFunc>
 168 transform_iterator<Iterator, UnaryFunc>
 169 make_transform_iterator(Iterator it, UnaryFunc fun)
 170 {
 171    return transform_iterator<Iterator, UnaryFunc>(it, fun);
 172 }
 173
 174 }  //namespace interprocess {
 175 }  //namespace boost {
 176
 177 #include <boost/interprocess/detail/config_end.hpp>
 178
 179 #endif   //#ifndef BOOST_INTERPROCESS_DETAIL_TRANSFORM_ITERATORS_HPP
 180