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
|
/*******************************************************************************
* Copyright (c) 2005, 2010 Oracle. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0, which accompanies this distribution
* and is available at http://www.eclipse.org/legal/epl-v10.html.
*
* Contributors:
* Oracle - initial API and implementation
******************************************************************************/
package org.eclipse.jpt.common.utility.internal.iterators;
import java.util.List;
import java.util.ListIterator;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.common.utility.internal.Transformer;
import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
/**
* A <code>TransformationListIterator</code> wraps another {@link ListIterator}
* and transforms its results for client consumption. To use, supply a
* {@link Transformer} or subclass <code>TransformationIterator</code>
* and override the {@link #transform(Object)} method.
* <p>
* The methods {@link #set(Object)} and {@link #add(Object)}
* are left unsupported in this class.
*
* @param <E1> input: the type of elements to be transformed
* @param <E2> output: the type of elements returned by the iterator
*
* @see org.eclipse.jpt.common.utility.internal.iterables.TransformationListIterable
*/
public class TransformationListIterator<E1, E2>
implements ListIterator<E2>
{
private final ListIterator<? extends E1> listIterator;
private final Transformer<E1, ? extends E2> transformer;
/**
* Construct an iterator with the specified list
* and a disabled transformer.
* Use this constructor if you want to override the
* {@link #transform(Object)} method instead of building
* a {@link Transformer}.
*/
public TransformationListIterator(List<? extends E1> list) {
this(list.listIterator());
}
/**
* Construct an iterator with the specified nested listed iterator
* and a disabled transformer.
* Use this constructor if you want to override the
* {@link #transform(Object)} method instead of building
* a {@link Transformer}.
*/
public TransformationListIterator(ListIterator<? extends E1> listIterator) {
this(listIterator, Transformer.Disabled.<E1, E2>instance());
}
/**
* Construct an iterator with the specified list
* and a disabled transformer.
* Use this constructor if you want to override the
* {@link #transform(Object)} method instead of building
* a {@link Transformer}.
*/
public TransformationListIterator(ListIterable<? extends E1> listIterable) {
this(listIterable.iterator());
}
/**
* Construct an iterator with the specified list and transformer.
*/
public TransformationListIterator(List<? extends E1> list, Transformer<E1, ? extends E2> transformer) {
this(list.listIterator(), transformer);
}
/**
* Construct an iterator with the specified list and transformer.
*/
public TransformationListIterator(ListIterable<? extends E1> listIterable, Transformer<E1, ? extends E2> transformer) {
this(listIterable.iterator(), transformer);
}
/**
* Construct an iterator with the specified nested iterator
* and transformer.
*/
public TransformationListIterator(ListIterator<? extends E1> listIterator, Transformer<E1, ? extends E2> transformer) {
super();
this.listIterator = listIterator;
this.transformer = transformer;
}
public boolean hasNext() {
// delegate to the nested iterator
return this.listIterator.hasNext();
}
public E2 next() {
// transform the object returned by the nested iterator before returning it
return this.transform(this.listIterator.next());
}
public int nextIndex() {
// delegate to the nested iterator
return this.listIterator.nextIndex();
}
public boolean hasPrevious() {
// delegate to the nested iterator
return this.listIterator.hasPrevious();
}
public E2 previous() {
// transform the object returned by the nested iterator before returning it
return this.transform(this.listIterator.previous());
}
public int previousIndex() {
// delegate to the nested iterator
return this.listIterator.previousIndex();
}
public void add(E2 o) {
throw new UnsupportedOperationException();
}
public void set(E2 o) {
throw new UnsupportedOperationException();
}
public void remove() {
// delegate to the nested iterator
this.listIterator.remove();
}
/**
* Transform the specified object and return the result.
*/
protected E2 transform(E1 next) {
return this.transformer.transform(next);
}
@Override
public String toString() {
return StringTools.buildToStringFor(this, this.listIterator);
}
}
|
