org.fxmisc.wellbehaved.event

Interface InputMap<E extends Event>

Type Parameters:

E - type of events that this InputMap may handle. That is, InputMap<E> certainly does not handle any events that are not of type E; it does not mean it handles any event of type E.

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface InputMap<E extends Event>

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	InputMap.HandlerConsumer<E extends Event>

Field Summary

Fields

Modifier and Type	Field and Description
static InputMap<?>	EMPTY

Method Summary

Modifier and Type	Method and Description
static <T extends Event,U extends T> InputMap<U>	consume(EventPattern<? super T,? extends U> eventPattern)
static <T extends Event,U extends T> InputMap<U>	consume(EventPattern<? super T,? extends U> eventPattern, Consumer<? super U> action)
static <T extends Event> InputMap<T>	consume(EventType<? extends T> eventType)
static <T extends Event> InputMap<T>	consume(EventType<? extends T> eventType, Consumer<? super T> action)
static <T extends Event,U extends T> InputMap<U>	consumeUnless(EventPattern<? super T,? extends U> eventPattern, BooleanSupplier condition, Consumer<? super U> action)
static <T extends Event> InputMap<T>	consumeUnless(EventType<? extends T> eventType, BooleanSupplier condition, Consumer<? super T> action)
static <T extends Event,U extends T> InputMap<U>	consumeWhen(EventPattern<? super T,? extends U> eventPattern, BooleanSupplier condition, Consumer<? super U> action)
static <T extends Event> InputMap<T>	consumeWhen(EventType<? extends T> eventType, BooleanSupplier condition, Consumer<? super T> action)
static <E extends Event> InputMap<E>	empty()
void	forEachEventType(InputMap.HandlerConsumer<? super E> f)
default InputMap<E>	ifConsumed(Consumer<? super E> postConsumption) Executes some additional handler if the event was consumed
static <T extends Event,U extends T> InputMap<U>	ignore(EventPattern<? super T,? extends U> eventPattern)
static <T extends Event> InputMap<T>	ignore(EventType<? extends T> eventType)
default InputMap<E>	orElse(InputMap<? extends E> that)
static <T extends Event,U extends T> InputMap<U>	process(EventPattern<? super T,? extends U> eventPattern, Function<? super U,InputHandler.Result> action)
static <T extends Event> InputMap<T>	process(EventType<? extends T> eventType, Function<? super T,InputHandler.Result> action)
static <E extends Event> InputMap<E>	sequence(InputMap<? extends E>... inputMaps)
static <T extends Event> InputMap<T>	unless(BooleanSupplier condition, InputMap<T> im)
static <E extends Event> InputMap<E>	upCast(InputMap<? extends E> inputMap)
static <T extends Event> InputMap<T>	when(BooleanSupplier condition, InputMap<T> im)
default InputMap<E>	without(InputMap<?> that)

Field Detail

EMPTY

static final InputMap<?> EMPTY

Method Detail

empty

static <E extends Event> InputMap<E> empty()

forEachEventType

void forEachEventType(InputMap.HandlerConsumer<? super E> f)

orElse

default InputMap<E> orElse(InputMap<? extends E> that)

without

default InputMap<E> without(InputMap<?> that)

ifConsumed

default InputMap<E> ifConsumed(Consumer<? super E> postConsumption)

Executes some additional handler if the event was consumed

upCast

static <E extends Event> InputMap<E> upCast(InputMap<? extends E> inputMap)

sequence

@SafeVarargs
static <E extends Event> InputMap<E> sequence(InputMap<? extends E>... inputMaps)

process

static <T extends Event,U extends T> InputMap<U> process(EventPattern<? super T,? extends U> eventPattern,
                                                         Function<? super U,InputHandler.Result> action)

process

static <T extends Event> InputMap<T> process(EventType<? extends T> eventType,
                                             Function<? super T,InputHandler.Result> action)

consume

static <T extends Event,U extends T> InputMap<U> consume(EventPattern<? super T,? extends U> eventPattern,
                                                         Consumer<? super U> action)

consume

static <T extends Event> InputMap<T> consume(EventType<? extends T> eventType,
                                             Consumer<? super T> action)

consume

static <T extends Event,U extends T> InputMap<U> consume(EventPattern<? super T,? extends U> eventPattern)

consume

static <T extends Event> InputMap<T> consume(EventType<? extends T> eventType)

consumeWhen

static <T extends Event,U extends T> InputMap<U> consumeWhen(EventPattern<? super T,? extends U> eventPattern,
                                                             BooleanSupplier condition,
                                                             Consumer<? super U> action)

consumeWhen

static <T extends Event> InputMap<T> consumeWhen(EventType<? extends T> eventType,
                                                 BooleanSupplier condition,
                                                 Consumer<? super T> action)

consumeUnless

static <T extends Event,U extends T> InputMap<U> consumeUnless(EventPattern<? super T,? extends U> eventPattern,
                                                               BooleanSupplier condition,
                                                               Consumer<? super U> action)

consumeUnless

static <T extends Event> InputMap<T> consumeUnless(EventType<? extends T> eventType,
                                                   BooleanSupplier condition,
                                                   Consumer<? super T> action)

ignore

static <T extends Event,U extends T> InputMap<U> ignore(EventPattern<? super T,? extends U> eventPattern)

ignore

static <T extends Event> InputMap<T> ignore(EventType<? extends T> eventType)

when

static <T extends Event> InputMap<T> when(BooleanSupplier condition,
                                          InputMap<T> im)

unless

static <T extends Event> InputMap<T> unless(BooleanSupplier condition,
                                            InputMap<T> im)