lazy-iterators/invertible_function_sequence.h at master · cwzx/lazy-iterators · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#ifndef INCLUDED_INVERTIBLE_FUNCTION_SEQUENCE
#define INCLUDED_INVERTIBLE_FUNCTION_SEQUENCE
#include <iterator>
#include <utility>
#include <type_traits>

template<typename F,typename Finverse,typename State>
struct invertible_function_sequence_iterator {

	typedef typename std::result_of<F(State)>::type value_type;
	typedef const value_type& reference;
	typedef const value_type* pointer;

	typedef ptrdiff_t difference_type;
	typedef std::bidirectional_iterator_tag iterator_category;
	typedef invertible_function_sequence_iterator<F,Finverse,State> iterator;

	invertible_function_sequence_iterator( const F& f, const Finverse& inverse ) : f(f), inverse(inverse), infinity(true) {}

	invertible_function_sequence_iterator( const F& f, const Finverse& inverse, const State& state ) : f(f), inverse(inverse), state(state), infinity(false) {
		this->operator++();
	}

	reference operator*() const {
		return value;
	}

	pointer operator->() const {
		return &value;
	}

	iterator& operator++() {
		value = f(state);
		return *this;
	}

	iterator operator++(int) {
		iterator temp = *this;
		++(*this);
		return temp;
	}

	iterator& operator--() {
		value = inverse(state);
		return *this;
	}

	iterator operator--(int) {
		iterator temp = *this;
		--(*this);
		return temp;
	}

	iterator& operator+=( difference_type offset ) {
		for(difference_type i=0;i<offset;++i)
			++(*this);
		for(difference_type i=0;i>offset;--i)
			++(*this);
		return *this;
	}

	iterator operator+( difference_type offset ) const {
		iterator temp = *this;
		return temp += offset;
	}

	iterator& operator-=( difference_type offset ) {
		return *this += -offset;
	}

	iterator operator-( difference_type offset ) const {
		iterator temp = *this;
		return temp -= offset;
	}

	reference operator[]( difference_type offset ) const {
		return *(*this + offset);
	}

	bool operator==( const iterator& rhs ) const {
		return infinity == rhs.infinity && ( infinity || state == rhs.state );
	}

	bool operator!=( const iterator& rhs ) const {
		return !(*this == rhs);
	}

protected:

	F f;
	Finverse inverse;
	State state;
	value_type value;
	bool infinity;
};

template<typename F,typename Finverse,typename State>
struct invertible_function_sequence_range {

	typedef typename std::result_of<F(State)>::type value_type;
	typedef const value_type& reference;
	typedef const value_type* pointer;

	typedef ptrdiff_t difference_type;
	typedef std::bidirectional_iterator_tag iterator_category;
	typedef invertible_function_sequence_iterator<F,Finverse,State> iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;

	invertible_function_sequence_range( const F& f, const Finverse& inverse, const State& initial ) : f(f), inverse(inverse), initial(initial) {}

	iterator begin() const {
		return iterator( f, inverse, initial );
	}

	iterator end() const {
		return iterator( f, inverse );
	}

protected:
	F f;
	Finverse inverse;
	State initial;
};

template<typename F,typename Finverse,typename State>
invertible_function_sequence_range<F,Finverse,State> invertible_function_sequence( State&& initial, F&& f, Finverse&& inverse ) {
	return invertible_function_sequence_range<F,Finverse,State>(
		std::forward<F>(f),
		std::forward<Finverse>(inverse),
		std::forward<State>(initial)
	);
}

#endif