State machine

controls/build.gradle

@@ -44,14 +44,13 @@ compileJava.dependsOn 'spotlessApply'
 dependencies {
 	// Use JUnit Jupiter for testing.
 	testImplementation libs.junit.jupiter
-
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
-
 	// This dependency is exported to consumers, that is to say found on their compile classpath.
 	api libs.commons.math3
 
 	// This dependency is used internally, and not exposed to consumers on their own compile classpath.
 	implementation libs.guava
+	implementation project(":parameter_tools")
 }
 
 // Apply a specific Java toolchain to ease working on different environments.
@@ -66,6 +65,12 @@ tasks.named('test') {
 	useJUnitPlatform()
 }
 
+
+
+test {
+	useJUnitPlatform()
+}
+
 compileJava.dependsOn 'spotlessApply'
 
 

controls/src/main/java/state_machine/State/PeriodicStateInterface.java

@@ -0,0 +1,6 @@
+package coppercore.controls;
+
+public interface PeriodicStateInterface extends StateInterface {
+
+    public default void periodic() {}
+}

controls/src/main/java/state_machine/State/StateConfiguration.java

@@ -0,0 +1,151 @@
+package coppercore.controls;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.BooleanSupplier;
+import java.util.function.Consumer;
+
+public class StateConfiguration<State, Trigger> {
+
+    private List<Transition<State, Trigger>> transitions;
+    private State source;
+    private Consumer<Transition> onEntryAction;
+    private Consumer<Transition> onExitAction;
+    private Consumer<Transition> transitionAction;
+    private boolean runDefaultTransitionAction = true;
+    private boolean runDefaultEntryAction = true;
+    private boolean runDefaultExitAction = true;
+
+    public StateConfiguration(State source) {
+        this.source = source;
+        // Temp solution
+        transitions = new ArrayList<>();
+    }
+
+    public StateConfiguration<State, Trigger> permit(Trigger trigger, State destination) {
+        if (getFilteredTransition(trigger).isEmpty()) {
+            transitions.add(new Transition<>(source, destination, trigger, false));
+        }
+        return this;
+    }
+
+    public StateConfiguration<State, Trigger> permitInternal(Trigger trigger, State destination) {
+        if (getFilteredTransition(trigger).isEmpty()) {
+            transitions.add(new Transition<>(source, destination, trigger, true));
+        }
+        return this;
+    }
+
+    public StateConfiguration<State, Trigger> permitIf(
+            Trigger trigger, State destination, BooleanSupplier check) {
+        if (getFilteredTransition(trigger).isEmpty()) {
+            transitions.add(new ConditinalTransition<>(source, destination, trigger, check, false));
+        }
+        return this;
+    }
+
+    public StateConfiguration<State, Trigger> permitInternalIf(
+            Trigger trigger, State destination, BooleanSupplier check) {
+        if (getFilteredTransition(trigger).isEmpty()) {
+            transitions.add(new ConditinalTransition<>(source, destination, trigger, check, true));
+        }
+        return this;
+    }
+
+    public List<Transition<State, Trigger>> getTransitions(Trigger trigger) {
+        List<Transition<State, Trigger>> matchedTransitions = new ArrayList<>();
+        if (trigger == null) return matchedTransitions;
+        for (Transition<State, Trigger> transition : transitions) {
+            if (trigger.equals(transition.getTrigger())) {
+                matchedTransitions.add(transition);
+            }
+        }
+        return matchedTransitions;
+    }
+
+    private Optional<Transition<State, Trigger>> filterTransitions(
+            List<Transition<State, Trigger>> transitions) {
+        Optional<Transition<State, Trigger>> returnOptional = Optional.empty();
+        boolean conditinal = false;
+        for (Transition<State, Trigger> transition : transitions) {
+            if (transition instanceof ConditinalTransition) {
+                if (conditinal
+                        && ((ConditinalTransition<State, Trigger>) transition).isCheckTrue()) {
+                    return Optional.empty();
+                } else {
+                    returnOptional = Optional.of(transition);
+                    conditinal = true;
+                }
+            } else if (!conditinal) {
+                returnOptional = Optional.of(transition);
+            }
+        }
+        return returnOptional;
+    }
+
+    public Optional<Transition<State, Trigger>> getFilteredTransition(Trigger trigger) {
+        return filterTransitions(getTransitions(trigger));
+    }
+
+    public void runOnEntry(Transition transition) {
+        if (onEntryAction != null) {
+            onEntryAction.accept(transition);
+        }
+    }
+
+    public void runOnExit(Transition transition) {
+        if (onExitAction != null) {
+            onExitAction.accept(transition);
+        }
+    }
+
+    public void runTransition(Transition transition) {
+        if (transitionAction != null) {
+            transitionAction.accept(transition);
+        }
+    }
+
+    public StateConfiguration<State, Trigger> disableDefaultTransitionAction(){
+        this.runDefaultTransitionAction = false;
+        return this;
+    }
+
+    public StateConfiguration<State, Trigger> disableDefualtOnEntry(){
+        this.runDefaultEntryAction = false;
+        return this;
+    }
+
+    public StateConfiguration<State, Trigger> disableDefualtOnExit(){
+        this.runDefaultExitAction = false;
+        return this;
+    }
+
+    public StateConfiguration<State, Trigger> configureOnEntryAction(Consumer<Transition> action){
+        this.onEntryAction = action;
+        return this;
+    }
+
+    public StateConfiguration<State, Trigger> configureOnExitAction(Consumer<Transition> action){
+        this.onExitAction = action;
+        return this;
+    }
+
+    public StateConfiguration<State, Trigger> configureTransitionAction(Consumer<Transition> action){
+        this.transitionAction = action;
+        return this;
+    }
+
+    public boolean doRunDefaultEntryAction(){
+        return runDefaultEntryAction;
+    }
+
+    public boolean doRunDefaultExitAction(){
+        return runDefaultExitAction;
+    }
+
+    public boolean doRunDefaultTransitionAction(){
+        return runDefaultTransitionAction;
+    }
+
+}

controls/src/main/java/state_machine/State/StateContainer.java

@@ -0,0 +1,7 @@
+package coppercore.controls;
+
+public interface StateContainer {
+
+    public StateInterface getState();
+
+}

controls/src/main/java/state_machine/State/StateInterface.java

@@ -0,0 +1,8 @@
+package coppercore.controls;
+
+public interface StateInterface {
+
+    public default void onEntry(Transition transition) {}
+
+    public default void onExit(Transition transition) {}
+}

controls/src/main/java/state_machine/StateMachine.java

@@ -0,0 +1,60 @@
+package coppercore.controls;
+
+import java.util.Optional;
+
+public class StateMachine<State, Trigger> {
+    private StateMachineConfiguration configuration;
+    private TransitionInfo transitionInfo;
+    private State currentState;
+
+    public StateMachine(StateMachineConfiguration config, State initialState) {
+        configuration = config;
+        currentState = initialState;
+    }
+
+    public void fire(Trigger trigger) {
+        transitionInfo = new TransitionInfo(currentState, trigger);
+        Optional<Transition<State, Trigger>> transitionOptional =
+                configuration.getTransition(currentState, trigger);
+        if (transitionOptional.isEmpty()) {
+            transitionInfo.fail();
+            return;
+        }
+        Transition<State, Trigger> transition = transitionOptional.get();
+        if (!transition.canTransition()) {
+            transitionInfo.fail();
+            return;
+        }
+        transitionInfo.setTransition(transition);
+        if (!transition.isInternal()) {
+            Optional<StateConfiguration> currentStateConfigurationOptional =
+                    configuration.getStateConfiguration(currentState);
+            Optional<StateConfiguration> nextStateConfigurationOptional =
+                    configuration.getStateConfiguration(transition.getDestination());
+            if (currentStateConfigurationOptional.isPresent()) {
+                currentStateConfigurationOptional.get().runOnEntry(transition);
+            }
+            transition.runAction();
+            if (nextStateConfigurationOptional.isPresent()) {
+                nextStateConfigurationOptional.get().runOnExit(transition);
+            }
+        }
+        currentState = transition.getDestination();
+    }
+
+    public State getCurrentState() {
+        return currentState;
+    }
+
+    public boolean successfulTransition() {
+        return !transitionInfo.wasFail();
+    }
+
+    public TransitionInfo getTransitionInfo() {
+        return transitionInfo;
+    }
+
+    public boolean inState(State state){
+        return currentState.equals(state);
+    }
+}

controls/src/main/java/state_machine/StateMachineConfiguration.java

@@ -0,0 +1,71 @@
+package coppercore.controls;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.BiConsumer;
+
+public class StateMachineConfiguration<State, Trigger> {
+    private Map<State, StateConfiguration<State, Trigger>> stateConfigurations;
+    private BiConsumer<State, Transition> onEntryAction;
+    private BiConsumer<State, Transition> onExitAction;
+    private BiConsumer<State, Transition> transitionAction;
+
+    public StateMachineConfiguration() {
+        // temp solution
+        stateConfigurations = new HashMap<>();
+    }
+
+    public StateConfiguration<State, Trigger> configure(State source) {
+        StateConfiguration<State, Trigger> configuration = stateConfigurations.get(source);
+        if (configuration == null) {
+            configuration = new StateConfiguration<>(source);
+            stateConfigurations.put(source, configuration);
+        }
+
+        return configuration;
+    }
+
+    public Optional<StateConfiguration<State, Trigger>> getStateConfiguration(State source) {
+        Optional<StateConfiguration<State, Trigger>> configurationOptional = Optional.empty();
+
+        if (stateConfigurations.containsKey(source)) {
+            StateConfiguration<State, Trigger> configuration = stateConfigurations.get(source);
+            if (configuration != null) {
+                configurationOptional = Optional.of(configuration);
+            }
+        }
+
+        return configurationOptional;
+    }
+
+    public Optional<Transition<State, Trigger>> getTransition(State state, Trigger trigger) {
+        Optional<Transition<State, Trigger>> transition = Optional.empty();
+        Optional<StateConfiguration<State, Trigger>> configurationOptional =
+                getStateConfiguration(state);
+
+        if (configurationOptional.isPresent()) {
+            StateConfiguration<State, Trigger> configuration = configurationOptional.get();
+            Optional<Transition<State, Trigger>> transitionOptional =
+                    configuration.getFilteredTransition(trigger);
+            transition = transition.or(() -> transitionOptional);
+        }
+
+        return transition;
+    }
+
+    public StateMachineConfiguration<State, Trigger> configureDefaultOnEntryAction(BiConsumer<State, Transition> action){
+        this.onEntryAction = action;
+        return this;
+    }
+
+    public StateMachineConfiguration<State, Trigger> configureDefaultOnExitAction(BiConsumer<State, Transition> action){
+        this.onExitAction = action;
+        return this;
+    }
+
+    public StateMachineConfiguration<State, Trigger> configureDefaultTransitionAction(BiConsumer<State, Transition> action){
+        this.transitionAction = action;
+        return this;
+    }
+}

controls/src/main/java/state_machine/Transition/ConditinalTransition.java

@@ -0,0 +1,31 @@
+package coppercore.controls;
+
+import java.util.function.BooleanSupplier;
+
+public class ConditinalTransition<State, Trigger> extends Transition<State, Trigger> {
+
+    private final BooleanSupplier check;
+
+    public ConditinalTransition(
+            State source, State destination, Trigger trigger, BooleanSupplier check) {
+        this(source, destination, trigger, check, false);
+    }
+
+    public ConditinalTransition(
+            State source,
+            State destination,
+            Trigger trigger,
+            BooleanSupplier check,
+            boolean internalTransition) {
+        super(source, destination, trigger, internalTransition);
+        this.check = check;
+    }
+
+    public boolean canTransition() {
+        return isCheckTrue();
+    }
+
+    public boolean isCheckTrue() {
+        return check != null && check.getAsBoolean();
+    }
+}