Java FxTimer.create方法代码示例

import org.reactfx.util.FxTimer; //导入方法依赖的package包/类
@Override
public Timer runLater(Duration delay, Runnable runnable) {
    if (timer == null) {
        timer = FxTimer.create(delay, runnable);
        timer.restart();
    } else {
        log.warn("runLater called on an already running timer.");
    }
    return this;
}
 

import org.reactfx.util.FxTimer; //导入方法依赖的package包/类
/**
 * Returns an event stream that emits the first event emitted from this
 * stream and then, if the next event arrives within the given duration
 * since the last emitted event, it is converted to an accumulator value
 * using {@code initialTransformation}. Any further events that still
 * arrive within {@code duration} are accumulated to the accumulator value
 * using the given reduction function. After {@code duration} has passed
 * since the last emitted event, the accumulator value is deconstructed
 * into a series of events using the given {@code deconstruction} function
 * and these events are emitted, the accumulator value is cleared and any
 * events that arrive within {@code duration} are accumulated, and so on.
 */
default <A> AwaitingEventStream<T> thenAccumulateFor(
        Duration duration,
        Function<? super T, ? extends A> initialTransformation,
        BiFunction<? super A, ? super T, ? extends A> reduction,
        Function<? super A, List<T>> deconstruction) {
    return new ThenAccumulateForStream<>(
            this,
            initialTransformation,
            reduction,
            deconstruction,
            action -> FxTimer.create(duration, action));
}
 

import org.reactfx.util.FxTimer; //导入方法依赖的package包/类
/**
 * A more general version of
 * {@link #reduceSuccessions(BinaryOperator, Duration)}
 * that allows the accumulated event to be of different type.
 *
 * <p><b>Note:</b> This function can be used only when this stream and
 * the returned stream are used from the JavaFX application thread. If
 * you are using the event streams on a different thread, use
 * {@link #reduceSuccessions(Function, BiFunction, Duration, ScheduledExecutorService, Executor)}
 * instead.</p>
 *
 * @param initialTransformation function to transform a single event
 * from this stream to an event that can be emitted from the returned
 * stream.
 * @param reduction function to add an event to the accumulated value.
 * @param timeout the maximum time difference between two subsequent
 * events that can still be accumulated.
 * @param <U> type of events emitted from the returned stream.
 */
default <U> AwaitingEventStream<U> reduceSuccessions(
        Function<? super T, ? extends U> initialTransformation,
        BiFunction<? super U, ? super T, ? extends U> reduction,
        Duration timeout) {

    Function<Runnable, Timer> timerFactory =
            action -> FxTimer.create(timeout, action);
    return new SuccessionReducingStream<T, U>(
            this, initialTransformation, reduction, timerFactory);
}