public static void main(String[] args) {
// (Employee e) -> e.getName();
System.out.println("// (Employee e) -> e.getName()");
Employee employee = new Employee("Employee Name", 8000);
System.out.println(getName1.apply(employee));
System.out.println(getName2.apply(employee));
// (Employee emp,String s) -> emp.setName(s)
System.out.println("// (Employee emp,String s) -> emp.setName(s)");
setName1.accept(employee, "New Name 1");
setName2.accept(employee, "New Name 2");
// (Employee e) -> e.getName();
System.out.println("// (Employee e) -> e.getName()");
System.out.println(getName1.apply(employee));
System.out.println(getName2.apply(employee));
// (String s1, String s2) -> s1.compareTo(s2)
System.out.println("// (String s1, String s2) -> s1.compareTo(s2)");
System.out.println(compare1.compare("Employee", "Employee"));
System.out.println(compare1.compare("Employee", "Employee2"));
System.out.println(compare2.compare("Employee", "Employee"));
System.out.println(compare2.compare("Employee", "Employee2"));
// (Integer x, Integer y) -> Math.pow(x, y)
System.out.println("// (Integer x, Integer y) -> Math.pow(x, y)");
System.out.println(power1.apply(3, 4));
System.out.println(power2.apply(5, 3));
// (Apple a) -> a.getWeight()
System.out.println("// (Apple a) -> a.getWeight()");
Apple apple = new Apple(30);
System.out.println(getWeight1.apply(apple));
System.out.println(getWeight2.apply(apple));
// (String x) -> Integer.parseInt(x)
int int1 = parseInt1.apply("33");
int int2 = parseInt1.apply("333");
// (Employee e1, Employee e2) -> comp.compare(e1, e2)
System.out.println("// (Employee e1, Employee e2) -> comp.compare(e1, e2)");
Employee emp1 = new Employee("employee", 6000);
Employee emp2 = new Employee("employee", 6000);
System.out.println(comparator1.compare(emp1, emp2));
System.out.println(comparator2.compare(emp1, emp2));
setName1.accept(emp1, "new Employee");
System.out.println(comparator1.compare(emp1, emp2));
System.out.println(comparator2.compare(emp1, emp2));
}
public void foreach(BiConsumer<K, V> action) {
try {
for (Pair<K, V> pair : pairs) action.accept(pair.key, pair.value);
} catch (Exception ignore) {
throwRuntimeException(ignore);
}
}
@Override
public void forEach(BiConsumer<Integer, ? super Boolean> action) {
int size = bits.size();
for (int i = 0; i < size; i++) {
action.accept(i, get(size));
}
}
@SuppressWarnings("unchecked")
private ModuleConstructor(
List<Consumer<NTree<Class<?>>>> verification,
BiConsumer<S, S> addMethod,
Class<S> moduleClass) {
this.verification = new ArrayList<>(verification);
moduleGeneration =
NTree.traverseUp(
(L, l) -> {
// parent object -- instance of multi module.
S multiModule = l;
// children instance of S, child module.
Iterator<S> it = L.iterator();
while (it.hasNext()) {
S m = it.next();
addMethod.accept(multiModule, m);
}
return multiModule;
},
(Class<?> l) -> {
S re = null;
try {
re = (S) l.newInstance();
} catch (IllegalAccessException | InstantiationException e) {
reflectError("Exception in creating class " + l, e);
} catch (ClassCastException v) {
reflectError(
"Class " + l + " is not an instance of the module class " + moduleClass);
}
return re;
});
}
@Override
protected void forEach(JsonObject object, BiConsumer<String, Object> objectConsumer) {
object.forEach(
entry -> {
objectConsumer.accept(entry.getKey(), entry.getValue());
});
}
public static void forEachRowColumn(BiConsumer<Integer, Integer> consumer) {
for (int row = 0; row < 9; row++) {
for (int column = 0; column < 9; column++) {
consumer.accept(row, column);
}
}
}
@Test
public void canAdaptConsumer() {
final Box<Pair<O, O>> box = Box.empty();
final Consumer<Pair<O, O>> consumer = Spies.spy(new Noop<Pair<O, O>>(), box);
final BiConsumer<O, O> adapted = Tuples.Pairs.untupled(consumer);
adapted.accept(O.ONE, O.ANOTHER);
Assert.assertEquals(Pair.of(O.ONE, O.ANOTHER), box.getContent());
}
@Override
public void forEach(BiConsumer<? super K, ? super V> action) {
bulk(
e -> {
action.accept(e.key, e.value);
return true;
});
}
@Override
public void forEach(BiConsumer<? super K, ? super V> action) {
checkNotNull(action);
ImmutableList<K> keyList = keySet.asList();
for (int i = 0; i < size(); i++) {
action.accept(keyList.get(i), valueList.get(i));
}
}
private void verifyCommands(
Point topLeft, Point bottomRight, BiConsumer<Integer, Integer> verifier) {
for (int x = topLeft.x; x <= bottomRight.x; ++x) {
for (int y = topLeft.y; y <= bottomRight.y; ++y) {
verifier.accept(x, y);
}
}
}
@Test
public void ensureCorrectEventSubject() {
DateMidnight today = DateMidnight.now();
Period period = new Period(today, today, DayLength.FULL);
BiConsumer<EventType, String> assertCorrectEventSubject =
(type, subject) -> {
Absence absence = new Absence(person, period, type, timeConfiguration);
assertThat(absence.getEventType(), is(type));
assertThat(absence.getEventSubject(), is(subject));
};
assertCorrectEventSubject.accept(
EventType.WAITING_APPLICATION, "Antrag auf Urlaub Marlene Muster");
assertCorrectEventSubject.accept(EventType.ALLOWED_APPLICATION, "Urlaub Marlene Muster");
assertCorrectEventSubject.accept(EventType.SICKNOTE, "Marlene Muster krank");
}
@Override
public final <R> R collect(
Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
BinaryOperator<R> operator =
(left, right) -> {
combiner.accept(left, right);
return left;
};
return evaluate(ReduceOps.makeInt(supplier, accumulator, operator));
}
public void visitHalfPlanes(BiConsumer<Segment, Integer> visitor, KDNode node, int depth) {
if (node.isLeaf()) { // || depth > 8) {
return;
} else {
if (node.splittingPlane.dimension == Dimension.X) {
Point2D start = new Point2D(node.splittingPlane.splitValue, node.bounds.min.getY());
Point2D end = new Point2D(node.splittingPlane.splitValue, node.bounds.max.getY());
visitor.accept(new Segment(start, end), depth);
visitHalfPlanes(visitor, node.left, depth + 1);
// visitHalfPlanes(visitor, node.right, depth+1);
} else {
Point2D start = new Point2D(node.bounds.min.getX(), node.splittingPlane.splitValue);
Point2D end = new Point2D(node.bounds.max.getX(), node.splittingPlane.splitValue);
visitor.accept(new Segment(start, end), depth);
visitHalfPlanes(visitor, node.left, depth + 1);
// visitHalfPlanes(visitor, node.right, depth+1);
}
}
}
/**
* Tie this camera to a canvas object, as that object moves then so will the camera
*
* @param tiedTo Canvas Object the camera is tied to
* @param tiedObjectLocator Anonymous function defining the camera's position in relation to the
* tied object
*/
public void setTiedTo(CanvasObject tiedTo, BiConsumer<CanvasObject, Camera> tiedObjectLocator) {
this.tiedTo = tiedTo;
this.tiedObjectLocator = tiedObjectLocator;
tiedObjectLocator.accept(tiedTo, this);
OrientableCanvasObject<?> o = tiedTo.getObjectAs(OrientableCanvasObject.class);
tiedTo.addObserver(this);
if (o != null) {
o.setOrientation(orientation);
}
}
private static void testCorruptRecord(
BiConsumer<LogTransaction, SSTableReader> modifier, boolean isRecoverable)
throws IOException {
ColumnFamilyStore cfs = MockSchema.newCFS(KEYSPACE);
File dataFolder = new Directories(cfs.metadata).getDirectoryForNewSSTables();
SSTableReader sstableOld = sstable(dataFolder, cfs, 0, 128);
SSTableReader sstableNew = sstable(dataFolder, cfs, 1, 128);
// simulate tracking sstables with a committed transaction except the checksum will be wrong
LogTransaction log = new LogTransaction(OperationType.COMPACTION);
assertNotNull(log);
log.trackNew(sstableNew);
log.obsoleted(sstableOld);
// Modify the transaction log or disk state for sstableOld
modifier.accept(log, sstableOld);
assertNull(log.complete(null));
sstableOld.selfRef().release();
sstableNew.selfRef().release();
// The files on disk, for old files make sure to exclude the files that were deleted by the
// modifier
Set<String> newFiles = sstableNew.getAllFilePaths().stream().collect(Collectors.toSet());
Set<String> oldFiles =
sstableOld
.getAllFilePaths()
.stream()
.filter(p -> new File(p).exists())
.collect(Collectors.toSet());
// This should filter as in progress since the last record is corrupt
assertFiles(newFiles, getTemporaryFiles(dataFolder));
assertFiles(oldFiles, getFinalFiles(dataFolder));
if (isRecoverable) { // the corruption is recoverable but the commit record is unreadable so the
// transaction is still in progress
// This should remove new files
LogTransaction.removeUnfinishedLeftovers(cfs.metadata);
// make sure to exclude the old files that were deleted by the modifier
assertFiles(dataFolder.getPath(), oldFiles);
} else { // if an intermediate line was also modified, it should ignore the tx log file
// This should not remove any files
LogTransaction.removeUnfinishedLeftovers(cfs.metadata);
assertFiles(
dataFolder.getPath(),
Sets.newHashSet(Iterables.concat(newFiles, oldFiles, log.logFilePaths())));
}
}
/**
* Executes the given consumer for each tracked object in parallel.
*
* @param consumer the consumer
*/
public void forEachTrackedObject(BiConsumer<Client, Position> consumer) {
requireNonNull(consumer, "consumer is null");
trackedObjects.forEach(
PositionTracker.THRESHOLD,
(t, pt) -> {
// pt.time is from the first time we encountered the position.
// We might have gotten messages with the position but different timestamps
// To avoid confusion we do not export the timestamp out
consumer.accept(t, Position.create(pt.getLatitude(), pt.getLongitude()));
});
}
@Override
public final <R> R collect(
Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
Objects.requireNonNull(combiner);
BinaryOperator<R> operator =
(left, right) -> {
combiner.accept(left, right);
return left;
};
return evaluate(ReduceOps.makeLong(supplier, accumulator, operator));
}
final void forEach(BiConsumer<? super K, ? super V> action) {
for (long a,
tail,
allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)),
allocIndex = 64 - tail;
allocations != 0;
allocations <<= 1, allocIndex--) {
if (allocations < 0)
action.accept(this.<K>readKey(allocIndex), this.<V>readValue(allocIndex));
}
}
@Override
public <R> R collect(
Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
return performOperation(
TerminalFunctions.collectFunction(supplier, accumulator, combiner),
true,
(e1, e2) -> {
combiner.accept(e1, e2);
return e1;
},
null);
}
default <R> R collect(
Supplier<R> supplier, BiConsumer<R, ? super U> accumulator, BiConsumer<R, R> combiner) {
return (R)
this.run(
(Collector)
Collector.of(
supplier,
accumulator,
(a, b) -> {
combiner.accept(a, b);
return a;
}));
}
private <T> void dispatchMsg(ActorContext context, T localMsg, BiConsumer<String, T> biConsumer) {
for (EndpointClusterAddress address : routes.getLocalRoutes()) {
LOG.info("Forwarding {} to local endpoint actor {}", localMsg, address);
ThriftEndpointActorMsg<T> msg =
new ThriftEndpointActorMsg<>(
address.toEndpointAddress(), ActorClassifier.LOCAL, localMsg);
context.parent().tell(msg, context.self());
}
for (EndpointClusterAddress address : routes.getRemoteRoutes()) {
LOG.info("Forwarding {} to remote endpoint actor {}", localMsg, address);
biConsumer.accept(address.getNodeId(), localMsg);
}
}
public <V> Builder write(
Key<? extends V> key, String fieldName, BiConsumer<JsonGenerator, ? super V> serialiser) {
BiConsumer<JsonGenerator, ? extends V> keyValueWriter =
(JsonGenerator generator, V value) -> {
try {
generator.writeFieldName(fieldName);
serialiser.accept(generator, value);
} catch (IOException e) {
throw new SerialisationException(e);
}
};
serialiserMap.put(key, keyValueWriter);
return this;
}
/**
* Wraps a BiConsumer in such a way the it will push the current execution context before any code
* gets executed and pop it afterwards
*
* @param w the functional interface to be wrapped
* @return wrapped object if there is a current execution context, or the same object if not.
*/
public static <T, U> BiConsumer<T, U> wrap(BiConsumer<T, U> w) {
TaskContext c = current();
if (c != null) {
return (t, u) -> {
c.push();
try {
w.accept(t, u);
} finally {
c.pop();
}
};
}
return w;
}
@Override
public void visitLambda(JCLambda node) {
builder
.build(node)
.ifPresent(
expr -> {
JCExpression ne = parseExpression(expr);
fixPos(ne, node.pos);
changeNode.accept(node, ne);
});
super.visitLambda(node);
}
/** Apply transformations to this camera */
public synchronized void doTransforms() {
if (this.tiedObjectUpdated) {
tiedObjectLocator.accept(tiedTo, this);
this.tiedObjectUpdated = false;
} else if (transforms.size() == 0) return;
for (CameraTransform t : this.transforms.values()) {
t.doTransform(this);
}
ot.saveCurrentTransforms(orientation);
this.setChanged();
this.notifyObservers(CAMERA_MOVED);
}
/**
* {@inheritDoc}
*
* @implSpec The default implementation is equivalent to, for this {@code map}:
* <pre>{@code
* for ((Map.Entry<K, V> entry : map.entrySet())
* action.accept(entry.getKey(), entry.getValue());
* }</pre>
*
* @implNote The default implementation assumes that {@code IllegalStateException} thrown by
* {@code getKey()} or {@code getValue()} indicates that the entry has been removed and cannot
* be processed. Operation continues for subsequent entries.
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*/
@Override
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch (IllegalStateException ise) {
// this usually means the entry is no longer in the map.
continue;
}
action.accept(k, v);
}
}
@SuppressWarnings("unchecked")
@Override
public synchronized void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action); // explicit check required in case
// table is empty.
final int expectedModCount = modCount;
Entry<?, ?>[] tab = table;
for (Entry<?, ?> entry : tab) {
while (entry != null) {
action.accept((K) entry.key, (V) entry.value);
entry = entry.next;
if (expectedModCount != modCount) {
throw new ConcurrentModificationException();
}
}
}
}
@Override
protected void describeMismatchSafely(T item, Description description) {
descibeMismatchSafely.accept(item, description);
}
private void createTermBuffer(
final BiConsumer<RetransmitHandlerTest, Integer> creator, final int num) {
IntStream.range(0, num).forEach((i) -> creator.accept(this, i));
}
public <T> AggregateInstant<I, A> action(BiConsumer<A, T> aggregateConsumer, T argument) {
actions.add(a -> aggregateConsumer.accept(a, argument));
return this;
}