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 {
  15     template <class Iterator>
  16     struct proxy
  17     {
  18         typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
  19
  20         explicit proxy(value_type const& v) : v_(v) {}
  21         proxy(proxy const& x) : v_(x.v_) {}
  22         operator value_type const&() const { return v_; }
  23
  24         value_type v_;
  25     private:
  26         proxy& operator=(proxy const&);
  27     };
  28
  29     template <class Iterator>
  30     struct input_iterator_adaptor
  31         : public std::iterator<
  32             std::input_iterator_tag,
  33             BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
  34             std::ptrdiff_t,
  35             BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
  36             proxy<Iterator>
  37         >
  38     {
  39         typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
  40             value_type;
  41
  42         input_iterator_adaptor()
  43             : base_() {}
  44         explicit input_iterator_adaptor(Iterator& it)
  45             : base_(&it) {}
  46         proxy<Iterator> operator*() const {
  47             return proxy<Iterator>(**base_);
  48         }
  49         value_type* operator->() const {
  50             return &**base_;
  51         }
  52         input_iterator_adaptor& operator++() {
  53             ++*base_; return *this;
  54         }
  55         //input_iterator_adaptor operator++(int) {
  56         //}
  57         bool operator==(input_iterator_adaptor const& x) const {
  58             return *base_ == *x.base_;
  59         }
  60         bool operator!=(input_iterator_adaptor const& x) const {
  61             return *base_ != *x.base_;
  62         }
  63     private:
  64         Iterator* base_;
  65     };
  66
  67     template <class Iterator>
  68     input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
  69     {
  70         return input_iterator_adaptor<Iterator>(it);
  71     }
  72
  73     template <class Iterator>
  74     struct copy_iterator_adaptor
  75         : public std::iterator<
  76             BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
  77             BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
  78             BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,
  79             BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
  80             proxy<Iterator>
  81         >
  82     {
  83         typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
  84             value_type;
  85         typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
  86             difference_type;
  87
  88         copy_iterator_adaptor()
  89             : base_() {}
  90         explicit copy_iterator_adaptor(Iterator const& it)
  91             : base_(it) {}
  92         value_type operator*() const {
  93             return *base_;
  94         }
  95         value_type* operator->() const {
  96             return &*base_;
  97         }
  98         value_type operator[](difference_type d) {
  99             return base_[d];
 100         }
 101         copy_iterator_adaptor& operator++() {
 102             ++base_; return *this;
 103         }
 104         copy_iterator_adaptor operator++(int) {
 105             copy_iterator_adaptor tmp(*this); ++base_; return tmp;
 106         }
 107         copy_iterator_adaptor& operator--() {
 108             --base_; return *this;
 109         }
 110         copy_iterator_adaptor operator--(int) {
 111             copy_iterator_adaptor tmp(*this); --base_; return tmp;
 112         }
 113         copy_iterator_adaptor operator+=(difference_type x) {
 114             base_ += x;
 115             return *this;
 116         }
 117         copy_iterator_adaptor operator-=(difference_type x) {
 118             base_ -= x;
 119             return *this;
 120         }
 121         copy_iterator_adaptor operator+(difference_type n) {
 122             return copy_iterator_adaptor(base_+n);
 123         }
 124         copy_iterator_adaptor operator-(difference_type n) {
 125             return copy_iterator_adaptor(base_-n);
 126         }
 127         friend copy_iterator_adaptor operator+(
 128                 difference_type n, copy_iterator_adaptor x) {
 129             return x+n;
 130         }
 131         difference_type operator-(copy_iterator_adaptor const& other) {
 132             return base_-other.base_;
 133         }
 134         bool operator==(copy_iterator_adaptor const& x) const {
 135             return base_ == x.base_;
 136         }
 137         bool operator!=(copy_iterator_adaptor const& x) const {
 138             return base_ != x.base_;
 139         }
 140         bool operator<(copy_iterator_adaptor const& x) const {
 141             return base_ < x.base_;
 142         }
 143         bool operator>(copy_iterator_adaptor const& x) const {
 144             return base_ > x.base_;
 145         }
 146         bool operator<=(copy_iterator_adaptor const& x) const {
 147             return base_ <= x.base_;
 148         }
 149         bool operator>=(copy_iterator_adaptor const& x) const {
 150             return base_ >= x.base_;
 151         }
 152     private:
 153         Iterator base_;
 154     };
 155
 156     template <class Iterator>
 157     copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
 158     {
 159         return copy_iterator_adaptor<Iterator>(it);
 160     }
 161
 162 }
 163
 164 #endif
 165