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
172
173
174
175
176
177
178
179
180
181
182
|
package bjc.utils.data.lazy;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import bjc.utils.data.IHolder;
import bjc.utils.funcdata.FunctionalList;
import bjc.utils.funcdata.IFunctionalList;
/**
* Holds a single value of a specific type. This is used for indirect
* references to data, and more specifically for accessing non-final
* variables from a lambda. AKA the identity monad
*
* This is a lazy variant of {@link IHolder}
*
* @author ben
*
* @param <T>
* The type of the data being held
*/
public class LazyHolder<T> implements IHolder<T>, ILazy {
private final class LazyHolderSupplier<NewT>
implements Supplier<NewT> {
private IFunctionalList<Function<T, T>> pendingActions;
private Function<T, NewT> pendingTransform;
public LazyHolderSupplier(IFunctionalList<Function<T, T>> actons,
Function<T, NewT> transform) {
// Resolve latent bug I just realized. After a map, adding new
// actions to the original holder could've resulted in changes
// to all unactualized mapped values from that holder
pendingActions = new FunctionalList<>();
for (Function<T, T> action : actons.toIterable()) {
pendingActions.add(action);
}
this.pendingTransform = transform;
}
@Override
public NewT get() {
if (heldValue == null) {
return pendingActions.reduceAux(heldSource.get(),
Function<T, T>::apply, pendingTransform::apply);
}
return pendingActions.reduceAux(heldValue,
Function<T, T>::apply, pendingTransform::apply);
}
}
/**
* List of queued actions to be performed on realized values
*/
private IFunctionalList<Function<T, T>> actions = new FunctionalList<>();
/**
* The value internally held by this lazy holder
*/
private T heldValue;
/**
* The source for a value held by this lazy holder
*/
private Supplier<T> heldSource;
/**
* Create a new lazy holder with the given supplier
*
* @param source
* The supplier for a value when it is neededs
*/
public LazyHolder(Supplier<T> source) {
if (source == null) {
throw new NullPointerException("Source must be non-null");
}
heldSource = source;
heldValue = null;
}
/**
* Create a new lazy holder with the given value
*
* @param value
* The value held in the holder
*/
public LazyHolder(T value) {
heldValue = value;
}
@Override
public void doWith(Consumer<T> action) {
if (action == null) {
throw new NullPointerException("Action must be non-null");
}
transform((value) -> {
// Do the action with the value
action.accept(value);
// Return the untransformed value
return value;
});
}
@Override
public <NewT> IHolder<NewT> map(Function<T, NewT> transform) {
if (transform == null) {
throw new NullPointerException("Transform must be non-null");
}
// Don't actually map until we need to
return new LazyHolder<>(
new LazyHolderSupplier<>(actions, transform));
}
@Override
public IHolder<T> transform(Function<T, T> transform) {
if (transform == null) {
throw new NullPointerException("Transform must be non-null");
}
// Queue the transform until we need to apply it
actions.add(transform);
return this;
}
@Override
public <E> E unwrap(Function<T, E> unwrapper) {
if (unwrapper == null) {
throw new NullPointerException("Unwrapper must be null");
}
// Actualize ourselves
if (heldValue == null) {
heldValue = heldSource.get();
}
// Apply all pending transforms
actions.forEach((action) -> heldValue = action.apply(heldValue));
return unwrapper.apply(heldValue);
}
@Override
public boolean isMaterialized() {
if (heldSource != null) {
// We're materialized if a value exists
return heldValue == null;
}
// We're materialized by default
return true;
}
@Override
public boolean hasPendingActions() {
return actions.isEmpty();
}
@Override
public void materialize() {
// Only materialize if we haven't already
if (!isMaterialized()) {
heldValue = heldSource.get();
}
}
@Override
public void applyPendingActions() {
materialize();
actions.forEach((action) -> {
heldValue = action.apply(heldValue);
});
}
}
|
