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.hpp> 11 #include <boost/iterator/iterator_traits.hpp> 12 13 namespace test 14 { 15 template <class Iterator> 16 struct proxy 17 { 18 typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type; 19 proxytest::proxy20 explicit proxy(value_type const& v) : v_(v) {} proxytest::proxy21 proxy(proxy const& x) : v_(x.v_) {} operator value_type const&test::proxy22 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 boost::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 input_iterator_adaptortest::input_iterator_adaptor42 input_iterator_adaptor() 43 : base_() {} input_iterator_adaptortest::input_iterator_adaptor44 explicit input_iterator_adaptor(Iterator& it) 45 : base_(&it) {} operator *test::input_iterator_adaptor46 proxy<Iterator> operator*() const { 47 return proxy<Iterator>(**base_); 48 } operator ->test::input_iterator_adaptor49 value_type* operator->() const { 50 return &**base_; 51 } operator ++test::input_iterator_adaptor52 input_iterator_adaptor& operator++() { 53 ++*base_; return *this; 54 } 55 //input_iterator_adaptor operator++(int) { 56 //} operator ==test::input_iterator_adaptor57 bool operator==(input_iterator_adaptor const& x) const { 58 return *base_ == *x.base_; 59 } operator !=test::input_iterator_adaptor60 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> input_iterator(Iterator & it)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 boost::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 copy_iterator_adaptortest::copy_iterator_adaptor88 copy_iterator_adaptor() 89 : base_() {} copy_iterator_adaptortest::copy_iterator_adaptor90 explicit copy_iterator_adaptor(Iterator const& it) 91 : base_(it) {} operator *test::copy_iterator_adaptor92 value_type operator*() const { 93 return *base_; 94 } operator ->test::copy_iterator_adaptor95 value_type* operator->() const { 96 return &*base_; 97 } operator []test::copy_iterator_adaptor98 value_type operator[](difference_type d) { 99 return base_[d]; 100 } operator ++test::copy_iterator_adaptor101 copy_iterator_adaptor& operator++() { 102 ++base_; return *this; 103 } operator ++test::copy_iterator_adaptor104 copy_iterator_adaptor operator++(int) { 105 copy_iterator_adaptor tmp(*this); ++base_; return tmp; 106 } operator --test::copy_iterator_adaptor107 copy_iterator_adaptor& operator--() { 108 --base_; return *this; 109 } operator --test::copy_iterator_adaptor110 copy_iterator_adaptor operator--(int) { 111 copy_iterator_adaptor tmp(*this); --base_; return tmp; 112 } operator +=test::copy_iterator_adaptor113 copy_iterator_adaptor operator+=(difference_type x) { 114 base_ += x; 115 return *this; 116 } operator -=test::copy_iterator_adaptor117 copy_iterator_adaptor operator-=(difference_type x) { 118 base_ -= x; 119 return *this; 120 } operator +test::copy_iterator_adaptor121 copy_iterator_adaptor operator+(difference_type n) { 122 return copy_iterator_adaptor(base_+n); 123 } operator -test::copy_iterator_adaptor124 copy_iterator_adaptor operator-(difference_type n) { 125 return copy_iterator_adaptor(base_-n); 126 } operator +(difference_type n,copy_iterator_adaptor x)127 friend copy_iterator_adaptor operator+( 128 difference_type n, copy_iterator_adaptor x) { 129 return x+n; 130 } operator -test::copy_iterator_adaptor131 difference_type operator-(copy_iterator_adaptor const& other) { 132 return base_-other.base_; 133 } operator ==test::copy_iterator_adaptor134 bool operator==(copy_iterator_adaptor const& x) const { 135 return base_ == x.base_; 136 } operator !=test::copy_iterator_adaptor137 bool operator!=(copy_iterator_adaptor const& x) const { 138 return base_ != x.base_; 139 } operator <test::copy_iterator_adaptor140 bool operator<(copy_iterator_adaptor const& x) const { 141 return base_ < x.base_; 142 } operator >test::copy_iterator_adaptor143 bool operator>(copy_iterator_adaptor const& x) const { 144 return base_ > x.base_; 145 } operator <=test::copy_iterator_adaptor146 bool operator<=(copy_iterator_adaptor const& x) const { 147 return base_ <= x.base_; 148 } operator >=test::copy_iterator_adaptor149 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> copy_iterator(Iterator const & it)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 166