ceph/src/boost/libs/unordered/test/helpers/input_iterator.hpp

   1
   2 // Copyright 2005-2010 Daniel James.
   3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #if !defined(BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER)
   7 #define BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER
   8
   9 #include <boost/config.hpp>
  10 #include <boost/iterator/iterator_traits.hpp>
  11 #include <iterator>
  12
  13 namespace test {
  14   template <class Iterator> struct proxy
  15   {
  16     typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
  17
  18     explicit proxy(value_type const& v) : v_(v) {}
  19     proxy(proxy const& x) : v_(x.v_) {}
  20     operator value_type const&() const { return v_; }
  21
  22     value_type v_;
  23
  24   private:
  25     proxy& operator=(proxy const&);
  26   };
  27
  28   template <class Iterator>
  29   struct input_iterator_adaptor
  30     : public std::iterator<std::input_iterator_tag,
  31         BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
  32         std::ptrdiff_t,
  33         BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
  34         proxy<Iterator> >
  35   {
  36     typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
  37       value_type;
  38
  39     input_iterator_adaptor() : base_() {}
  40     explicit input_iterator_adaptor(Iterator& it) : base_(&it) {}
  41     proxy<Iterator> operator*() const { return proxy<Iterator>(**base_); }
  42     value_type* operator->() const { return &**base_; }
  43     input_iterator_adaptor& operator++()
  44     {
  45       ++*base_;
  46       return *this;
  47     }
  48     // input_iterator_adaptor operator++(int) {
  49     //}
  50     bool operator==(input_iterator_adaptor const& x) const
  51     {
  52       return *base_ == *x.base_;
  53     }
  54     bool operator!=(input_iterator_adaptor const& x) const
  55     {
  56       return *base_ != *x.base_;
  57     }
  58
  59   private:
  60     Iterator* base_;
  61   };
  62
  63   template <class Iterator>
  64   input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
  65   {
  66     return input_iterator_adaptor<Iterator>(it);
  67   }
  68
  69   template <class Iterator>
  70   struct copy_iterator_adaptor
  71     : public std::iterator<
  72         BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
  73         BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
  74         BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,
  75         BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
  76         proxy<Iterator> >
  77   {
  78     typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
  79       value_type;
  80     typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
  81       difference_type;
  82
  83     copy_iterator_adaptor() : base_() {}
  84     explicit copy_iterator_adaptor(Iterator const& it) : base_(it) {}
  85     value_type operator*() const { return *base_; }
  86     value_type* operator->() const { return &*base_; }
  87     value_type operator[](difference_type d) { return base_[d]; }
  88     copy_iterator_adaptor& operator++()
  89     {
  90       ++base_;
  91       return *this;
  92     }
  93     copy_iterator_adaptor operator++(int)
  94     {
  95       copy_iterator_adaptor tmp(*this);
  96       ++base_;
  97       return tmp;
  98     }
  99     copy_iterator_adaptor& operator--()
 100     {
 101       --base_;
 102       return *this;
 103     }
 104     copy_iterator_adaptor operator--(int)
 105     {
 106       copy_iterator_adaptor tmp(*this);
 107       --base_;
 108       return tmp;
 109     }
 110     copy_iterator_adaptor operator+=(difference_type x)
 111     {
 112       base_ += x;
 113       return *this;
 114     }
 115     copy_iterator_adaptor operator-=(difference_type x)
 116     {
 117       base_ -= x;
 118       return *this;
 119     }
 120     copy_iterator_adaptor operator+(difference_type n)
 121     {
 122       return copy_iterator_adaptor(base_ + n);
 123     }
 124     copy_iterator_adaptor operator-(difference_type n)
 125     {
 126       return copy_iterator_adaptor(base_ - n);
 127     }
 128     friend copy_iterator_adaptor operator+(
 129       difference_type n, copy_iterator_adaptor x)
 130     {
 131       return x + n;
 132     }
 133     difference_type operator-(copy_iterator_adaptor const& other)
 134     {
 135       return base_ - other.base_;
 136     }
 137     bool operator==(copy_iterator_adaptor const& x) const
 138     {
 139       return base_ == x.base_;
 140     }
 141     bool operator!=(copy_iterator_adaptor const& x) const
 142     {
 143       return base_ != x.base_;
 144     }
 145     bool operator<(copy_iterator_adaptor const& x) const
 146     {
 147       return base_ < x.base_;
 148     }
 149     bool operator>(copy_iterator_adaptor const& x) const
 150     {
 151       return base_ > x.base_;
 152     }
 153     bool operator<=(copy_iterator_adaptor const& x) const
 154     {
 155       return base_ <= x.base_;
 156     }
 157     bool operator>=(copy_iterator_adaptor const& x) const
 158     {
 159       return base_ >= x.base_;
 160     }
 161
 162   private:
 163     Iterator base_;
 164   };
 165
 166   template <class Iterator>
 167   copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
 168   {
 169     return copy_iterator_adaptor<Iterator>(it);
 170   }
 171 }
 172
 173 #endif