blob: d75a9a3d51ee5dd13b9dac458b5efd8b9e1b26f1 (
plain)
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
package bjc.utils.data;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Iterator;
/**
* An iterator that supports queuing elements after/before the current iterator;
*
* @author bjculkin
*
* @param <E>
*/
public class QueuedIterator<E> implements Iterator<E> {
private Iterator<E> cur;
private Deque<Iterator<E>> pending;
/**
* Static method for constructing iterators.
*
* @return A queued iterator.
*/
public static <E> QueuedIterator<E> queued() {
return new QueuedIterator<>();
}
/**
* Static method for constructing iterators.
*
* @param itrs
* The iterators to use.
* @return A queued iterator over the provided iterators.
*/
@SafeVarargs
public static <E> QueuedIterator<E> queued(Iterator<E>... itrs) {
return new QueuedIterator<>(itrs);
}
/**
* Static method for constructing iterators.
*
* @param itrs
* The iterables to use.
* @return A queued iterator over the provided iterables.
*/
@SafeVarargs
public static <E> QueuedIterator<E> queued(Iterable<E>... itrs) {
return new QueuedIterator<>(itrs);
}
/**
* Create a new queued iterator that starts blank.
*/
public QueuedIterator() {
pending = new ArrayDeque<>();
}
/**
* Create a new queued iterator with a set of initial sources.
*
* @param inits
* The set of initial iterators to use.
*/
@SafeVarargs
public QueuedIterator(Iterator<E>... inits) {
this();
for (Iterator<E> init : inits) {
pending.add(init);
}
}
/**
* Create a new queued iterator with a set of initial sources.
*
* @param inits
* The set of initial iterables to use.
*/
@SafeVarargs
public QueuedIterator(Iterable<E>... inits) {
this();
for (Iterable<E> init : inits) {
pending.add(init.iterator());
}
}
/**
* Add a new iterator who we will iterate through first.
*
* @param itr
* The iterator to go through first.
*/
public void before(Iterator<E> itr) {
pending.push(cur);
cur = itr;
}
/**
* Add a new iterable who we will iterate through first.
*
* @param itr
* The iterable to go through first.
*/
public void before(Iterable<E> itr) {
before(itr.iterator());
}
/**
* Add a new iterator who we will iterate through next.
*
* @param itr
* The iterator to go through next.
*/
public void after(Iterator<E> itr) {
pending.push(itr);
}
/**
* Add a new iterable who we will iterate through next.
*
* @param itr
* The iterable to go through next.
*/
public void after(Iterable<E> itr) {
after(itr.iterator());
}
/**
* Add a new iterator who we will iterate through last.
*
* @param itr
* The iterator to go through last.
*/
public void last(Iterator<E> itr) {
pending.add(itr);
}
/**
* Add a new iterable who we will iterate through last.
*
* @param itr
* The iterable to go through last.
*/
public void last(Iterable<E> itr) {
last(itr.iterator());
}
@Override
public boolean hasNext() {
while (cur == null || !cur.hasNext()) {
if (pending.isEmpty()) return false;
cur = pending.pop();
}
return cur.hasNext();
}
@Override
public E next() {
while (cur == null || !cur.hasNext()) {
if (pending.isEmpty()) return null;
cur = pending.pop();
}
return cur.next();
}
}
|
