Reworked state machine
parent
a9e2b1ddd9
commit
d037ada8c5
@ -0,0 +1,123 @@
|
|||||||
|
package eu.jonahbauer.wizard.common.machine;
|
||||||
|
|
||||||
|
import lombok.Getter;
|
||||||
|
import org.jetbrains.annotations.NotNull;
|
||||||
|
|
||||||
|
import java.util.Objects;
|
||||||
|
import java.util.Optional;
|
||||||
|
import java.util.concurrent.locks.ReentrantLock;
|
||||||
|
import java.util.function.Function;
|
||||||
|
import java.util.function.Supplier;
|
||||||
|
|
||||||
|
public abstract class Context<S extends State<S,C>, C extends Context<S,C>> {
|
||||||
|
@Getter
|
||||||
|
private @NotNull S state;
|
||||||
|
private final ReentrantLock lock = new ReentrantLock();
|
||||||
|
|
||||||
|
public Context(@NotNull S initialState) {
|
||||||
|
this.state = initialState;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Atomically executes the given supplier and transitions to the returned state if present.
|
||||||
|
* @see #transition(State)
|
||||||
|
*/
|
||||||
|
public void execute(Supplier<Optional<@NotNull S>> transition) {
|
||||||
|
lock.lock();
|
||||||
|
try {
|
||||||
|
Optional<S> next = transition.get();
|
||||||
|
next.ifPresent(this::transition);
|
||||||
|
} finally {
|
||||||
|
lock.unlock();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Atomically applies the given function to the current state and transitions to the returned state if present.
|
||||||
|
* @see #transition(State)
|
||||||
|
*/
|
||||||
|
public void execute(Function<@NotNull S, Optional<@NotNull S>> transition) {
|
||||||
|
lock.lock();
|
||||||
|
try {
|
||||||
|
Optional<S> next = transition.apply(state);
|
||||||
|
next.ifPresent(this::transition);
|
||||||
|
} finally {
|
||||||
|
lock.unlock();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Atomically transitions to the specified state calling the state lifecycle methods.
|
||||||
|
* When an error occurs during execution of the lifecycle methods {@link #handleError(Throwable)} is called.
|
||||||
|
* @param state the next state
|
||||||
|
* @see State#onExit(Context)
|
||||||
|
* @see State#onEnter(Context)
|
||||||
|
* @see #handleError(Throwable)
|
||||||
|
*/
|
||||||
|
public void transition(@NotNull S state) {
|
||||||
|
lock.lock();
|
||||||
|
try {
|
||||||
|
//noinspection unchecked
|
||||||
|
this.state.onExit((C) this);
|
||||||
|
onTransition(this.state, state);
|
||||||
|
this.state = state;
|
||||||
|
//noinspection unchecked
|
||||||
|
state.onEnter((C) this).ifPresent(this::transition);
|
||||||
|
} catch (Throwable t) {
|
||||||
|
handleError(t);
|
||||||
|
} finally {
|
||||||
|
lock.unlock();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Atomically checks that the current state is {@linkplain Object#equals(Object) equal to} the specified expected
|
||||||
|
* state and transitions to the specified next state.
|
||||||
|
* @param expected the expected current state
|
||||||
|
* @param next the next state
|
||||||
|
* @see #transition(State)
|
||||||
|
* @throws IllegalStateException if the current state is not equal to the expected state
|
||||||
|
*/
|
||||||
|
public void transition(@NotNull S expected, @NotNull S next) {
|
||||||
|
lock.lock();
|
||||||
|
try {
|
||||||
|
if (Objects.equals(expected, this.state)) {
|
||||||
|
transition(next);
|
||||||
|
} else {
|
||||||
|
throw new IllegalStateException("Current state is not " + expected + ".");
|
||||||
|
}
|
||||||
|
} finally {
|
||||||
|
lock.unlock();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Atomically transitions to the specified state without calling the state lifecycle methods. This method can
|
||||||
|
* be used to recover from errors occurring during {@link State#onExit(Context)} which would otherwise prevent
|
||||||
|
* the context from transitioning to another state.
|
||||||
|
* @param state the next state
|
||||||
|
*/
|
||||||
|
protected void forceTransition(@NotNull S state) {
|
||||||
|
lock.lock();
|
||||||
|
try {
|
||||||
|
onTransition(this.state, state);
|
||||||
|
this.state = state;
|
||||||
|
} finally {
|
||||||
|
lock.unlock();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Callback method that will synchronously be called on transitioning between two states.
|
||||||
|
* @param from the previous state
|
||||||
|
* @param to the next state
|
||||||
|
*/
|
||||||
|
protected void onTransition(S from, S to) {}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Callback method that will synchronously be called when an error occurs during execution of state lifecycle
|
||||||
|
* methods.
|
||||||
|
* @param t the cause
|
||||||
|
*/
|
||||||
|
protected abstract void handleError(Throwable t);
|
||||||
|
}
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
package eu.jonahbauer.wizard.common.machine;
|
||||||
|
|
||||||
|
import java.util.Optional;
|
||||||
|
|
||||||
|
public interface State<S extends State<S,C>, C extends Context<S,C>> {
|
||||||
|
default Optional<S> onEnter(C context) {
|
||||||
|
return Optional.empty();
|
||||||
|
}
|
||||||
|
|
||||||
|
default void onExit(C context) {}
|
||||||
|
}
|
||||||
@ -0,0 +1,36 @@
|
|||||||
|
package eu.jonahbauer.wizard.common.machine;
|
||||||
|
|
||||||
|
import org.jetbrains.annotations.NotNull;
|
||||||
|
|
||||||
|
import java.util.Objects;
|
||||||
|
import java.util.Optional;
|
||||||
|
import java.util.concurrent.Executors;
|
||||||
|
import java.util.concurrent.ScheduledExecutorService;
|
||||||
|
import java.util.concurrent.TimeUnit;
|
||||||
|
|
||||||
|
public abstract class TimeoutContext<S extends TimeoutState<S,C>, C extends TimeoutContext<S,C>> extends Context<S,C> {
|
||||||
|
private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
|
||||||
|
|
||||||
|
public TimeoutContext(@NotNull S initialState) {
|
||||||
|
super(initialState);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void timeout(@NotNull S currentState, long delay) {
|
||||||
|
scheduler.schedule(() -> {
|
||||||
|
if (Objects.equals(getState(), currentState)) {
|
||||||
|
execute(() -> {
|
||||||
|
if (Objects.equals(getState(), currentState)) {
|
||||||
|
//noinspection unchecked
|
||||||
|
return currentState.onTimeout((C) this);
|
||||||
|
} else {
|
||||||
|
return Optional.empty();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}, delay, TimeUnit.MILLISECONDS);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void shutdownNow() {
|
||||||
|
scheduler.shutdownNow();
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,9 @@
|
|||||||
|
package eu.jonahbauer.wizard.common.machine;
|
||||||
|
|
||||||
|
import java.util.Optional;
|
||||||
|
|
||||||
|
public interface TimeoutState<S extends TimeoutState<S,C>, C extends TimeoutContext<S,C>> extends State<S,C> {
|
||||||
|
default Optional<S> onTimeout(C context) {
|
||||||
|
return Optional.empty();
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -1,155 +0,0 @@
|
|||||||
package eu.jonahbauer.wizard.core.machine;
|
|
||||||
|
|
||||||
import eu.jonahbauer.wizard.core.machine.states.State;
|
|
||||||
import lombok.Getter;
|
|
||||||
import lombok.RequiredArgsConstructor;
|
|
||||||
import org.jetbrains.annotations.Blocking;
|
|
||||||
import org.jetbrains.annotations.NonBlocking;
|
|
||||||
import org.jetbrains.annotations.NotNull;
|
|
||||||
|
|
||||||
import java.util.Comparator;
|
|
||||||
import java.util.concurrent.*;
|
|
||||||
import java.util.concurrent.atomic.AtomicReference;
|
|
||||||
|
|
||||||
public abstract class Context<S extends State<S,C>, C extends Context<S,C>> {
|
|
||||||
private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
|
|
||||||
private final ThreadPoolExecutor executor = new ThreadPoolExecutor(
|
|
||||||
1, 1,
|
|
||||||
0, TimeUnit.SECONDS,
|
|
||||||
new PriorityBlockingQueue<>(
|
|
||||||
11,
|
|
||||||
Comparator.comparingInt(r -> r instanceof PriorityRunnable prio ? prio.getPriority() : Integer.MAX_VALUE)
|
|
||||||
.thenComparingLong(r -> r instanceof PriorityRunnable prio ? prio.getTimestamp() : Long.MAX_VALUE)
|
|
||||||
),
|
|
||||||
r -> {
|
|
||||||
var t = new Thread(r);
|
|
||||||
t.setUncaughtExceptionHandler((t1, e) -> finish(e));
|
|
||||||
return t;
|
|
||||||
}
|
|
||||||
);
|
|
||||||
|
|
||||||
protected S state;
|
|
||||||
|
|
||||||
private final CompletableFuture<Void> future = new CompletableFuture<>();
|
|
||||||
private final CompletableFuture<Void> finished = future.whenComplete((v, t) -> {
|
|
||||||
executor.shutdownNow();
|
|
||||||
scheduler.shutdownNow();
|
|
||||||
});
|
|
||||||
|
|
||||||
@NonBlocking
|
|
||||||
protected CompletableFuture<Void> submit(Runnable runnable) {
|
|
||||||
var future = new CompletableFuture<Void>();
|
|
||||||
executor.execute(new PriorityRunnable(100, () -> {
|
|
||||||
try {
|
|
||||||
runnable.run();
|
|
||||||
future.complete(null);
|
|
||||||
} catch (Throwable t) {
|
|
||||||
future.completeExceptionally(t);
|
|
||||||
}
|
|
||||||
}));
|
|
||||||
return future;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Blocking
|
|
||||||
protected void start(@NotNull S state) {
|
|
||||||
CountDownLatch latch = new CountDownLatch(1);
|
|
||||||
AtomicReference<RuntimeException> exception = new AtomicReference<>();
|
|
||||||
|
|
||||||
executor.execute(new PriorityRunnable(0, () -> {
|
|
||||||
if (future.isDone()) {
|
|
||||||
exception.set(new IllegalStateException("Context has already finished."));
|
|
||||||
latch.countDown();
|
|
||||||
} else {
|
|
||||||
latch.countDown();
|
|
||||||
doTransition(null, state);
|
|
||||||
}
|
|
||||||
}));
|
|
||||||
|
|
||||||
while (true) {
|
|
||||||
try {
|
|
||||||
latch.await();
|
|
||||||
if (exception.get() != null) {
|
|
||||||
throw exception.get();
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
} catch (InterruptedException ignored) {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@NonBlocking
|
|
||||||
public void transition(S currentState, S newState) {
|
|
||||||
executor.execute(new PriorityRunnable(0, () -> doTransition(currentState, newState)));
|
|
||||||
}
|
|
||||||
|
|
||||||
@NonBlocking
|
|
||||||
public void finish() {
|
|
||||||
finish(null);
|
|
||||||
}
|
|
||||||
|
|
||||||
@NonBlocking
|
|
||||||
public void finish(Throwable exception) {
|
|
||||||
executor.execute(new PriorityRunnable(0, () -> doFinish(exception)));
|
|
||||||
}
|
|
||||||
|
|
||||||
@NonBlocking
|
|
||||||
public void cancel() {
|
|
||||||
finish(new CancellationException());
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* internal methods that are called on the executor
|
|
||||||
*/
|
|
||||||
|
|
||||||
private void doTransition(S currentState, S newState) {
|
|
||||||
if (state == currentState) {
|
|
||||||
state = newState;
|
|
||||||
if (currentState != null) //noinspection unchecked
|
|
||||||
currentState.onExit((C) this);
|
|
||||||
onTransition(currentState, newState);
|
|
||||||
if (newState != null) //noinspection unchecked
|
|
||||||
newState.onEnter((C) this);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void doFinish(Throwable t) {
|
|
||||||
if (future.isDone()) return;
|
|
||||||
|
|
||||||
doTransition(state, null);
|
|
||||||
if (t != null) {
|
|
||||||
future.completeExceptionally(t);
|
|
||||||
} else {
|
|
||||||
future.complete(null);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
protected void onTransition(S from, S to) {}
|
|
||||||
|
|
||||||
@Blocking
|
|
||||||
public void await() throws InterruptedException, ExecutionException, CancellationException {
|
|
||||||
finished.get();
|
|
||||||
}
|
|
||||||
|
|
||||||
public void timeout(@NotNull S currentState, long delay) {
|
|
||||||
scheduler.schedule(() -> {
|
|
||||||
submit(() -> {
|
|
||||||
if (state == currentState) {
|
|
||||||
//noinspection unchecked
|
|
||||||
state.onTimeout((C) this);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}, delay, TimeUnit.MILLISECONDS);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Getter
|
|
||||||
@RequiredArgsConstructor
|
|
||||||
private static class PriorityRunnable implements Runnable {
|
|
||||||
private final int priority;
|
|
||||||
private final long timestamp = System.nanoTime();
|
|
||||||
private final Runnable runnable;
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void run() {
|
|
||||||
runnable.run();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,9 +0,0 @@
|
|||||||
package eu.jonahbauer.wizard.core.machine.states;
|
|
||||||
|
|
||||||
import eu.jonahbauer.wizard.core.machine.Context;
|
|
||||||
|
|
||||||
public interface State<S extends State<S,C>, C extends Context<S,C>> {
|
|
||||||
default void onEnter(C context) {}
|
|
||||||
default void onTimeout(C context) {}
|
|
||||||
default void onExit(C context) {}
|
|
||||||
}
|
|
||||||
@ -0,0 +1,25 @@
|
|||||||
|
package eu.jonahbauer.wizard.core.machine.states.game;
|
||||||
|
|
||||||
|
import eu.jonahbauer.wizard.core.machine.Game;
|
||||||
|
import eu.jonahbauer.wizard.core.machine.states.GameData;
|
||||||
|
import eu.jonahbauer.wizard.core.machine.GameState;
|
||||||
|
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Optional;
|
||||||
|
import java.util.UUID;
|
||||||
|
|
||||||
|
public final class Created extends GameState {
|
||||||
|
public Created() {
|
||||||
|
super(GameData.EMPTY);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Optional<GameState> start(Game game, List<UUID> players) {
|
||||||
|
return transition(new Starting(GameData.EMPTY.with(GameData.PLAYERS, players)));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public boolean equals(Object obj) {
|
||||||
|
return obj instanceof Created;
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,15 @@
|
|||||||
|
package eu.jonahbauer.wizard.core.machine.states.game;
|
||||||
|
|
||||||
|
import eu.jonahbauer.wizard.core.machine.GameState;
|
||||||
|
import eu.jonahbauer.wizard.core.machine.states.GameData;
|
||||||
|
import lombok.Getter;
|
||||||
|
|
||||||
|
@Getter
|
||||||
|
public final class Error extends GameState {
|
||||||
|
private final Throwable cause;
|
||||||
|
|
||||||
|
public Error(Throwable cause) {
|
||||||
|
super(GameData.EMPTY);
|
||||||
|
this.cause = cause;
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,19 @@
|
|||||||
|
package eu.jonahbauer.wizard.core.machine.states.game;
|
||||||
|
|
||||||
|
import eu.jonahbauer.wizard.core.machine.Game;
|
||||||
|
import eu.jonahbauer.wizard.core.machine.states.GameData;
|
||||||
|
import eu.jonahbauer.wizard.core.machine.GameState;
|
||||||
|
|
||||||
|
import java.util.Optional;
|
||||||
|
|
||||||
|
public final class Finished extends GameState {
|
||||||
|
public Finished() {
|
||||||
|
super(GameData.EMPTY);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Optional<GameState> onEnter(Game context) {
|
||||||
|
context.complete(null);
|
||||||
|
return Optional.empty();
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue