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