Skip to content
This repository has been archived by the owner on Jan 13, 2025. It is now read-only.

Commit

Permalink
Rename TriggerType to TriggerState
Browse files Browse the repository at this point in the history
  • Loading branch information
@rcahoon
rcahoon committed Dec 14, 2024
1 parent 850a86a commit 5e49fed
Show file tree
Hide file tree
Showing 3 changed files with 53 additions and 51 deletions.
67 changes: 34 additions & 33 deletions src/main/java/com/team766/framework3/Rule.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,7 +16,7 @@
* "predicate" that will be evaluated in each call to {@link RuleEngine#run}, typically
* in an OperatorInterface loop or Display (LED lights, etc) loop. The Rule keeps track of
* when the predicate starts triggering and has finished triggering, via
* a {@link TriggerType}, eg when a driver or boxop starts pressing a button and then releases the button.
* a {@link TriggerState}, eg when a driver or boxop starts pressing a button and then releases the button.
* Each Rule has optional {@link Procedure} actions for each of these trigger types, which the
* {@link RuleEngine} will consider running, after checking if higher priority rules have reserved the
* same {@link Mechanism}s that the candidate rule would use.
Expand Down Expand Up @@ -46,7 +46,7 @@ public class Rule {
* FINISHED - rule was triggering in the last evaluation and is no longer triggering.
*
*/
enum TriggerType {
enum TriggerState {
NONE,
NEWLY,
CONTINUING,
Expand Down Expand Up @@ -219,13 +219,13 @@ private List<Rule> build(BooleanSupplier parentPredicate) {

private final String name;
private final BooleanSupplier predicate;
private final Map<TriggerType, Supplier<Procedure>> triggerProcedures =
Maps.newEnumMap(TriggerType.class);
private final Map<TriggerType, Set<Mechanism<?>>> triggerReservations =
Maps.newEnumMap(TriggerType.class);
private final Map<TriggerState, Supplier<Procedure>> triggerProcedures =
Maps.newEnumMap(TriggerState.class);
private final Map<TriggerState, Set<Mechanism<?>>> triggerReservations =
Maps.newEnumMap(TriggerState.class);
private final Cancellation cancellationOnFinish;

private TriggerType currentTriggerType = TriggerType.NONE;
private TriggerState currentTriggerState = TriggerState.NONE;

public static Builder create(String name, BooleanSupplier predicate) {
return new Builder(name, predicate);
Expand All @@ -248,17 +248,18 @@ private Rule(
this.name = name;
this.predicate = predicate;
if (onTriggeringProcedure != null) {
triggerProcedures.put(TriggerType.NEWLY, onTriggeringProcedure);
triggerProcedures.put(TriggerState.NEWLY, onTriggeringProcedure);
triggerReservations.put(
TriggerType.NEWLY, getReservationsForProcedure(onTriggeringProcedure));
TriggerState.NEWLY, getReservationsForProcedure(onTriggeringProcedure));
}

this.cancellationOnFinish = cancellationOnFinish;

if (finishedTriggeringProcedure != null) {
triggerProcedures.put(TriggerType.FINISHED, finishedTriggeringProcedure);
triggerProcedures.put(TriggerState.FINISHED, finishedTriggeringProcedure);
triggerReservations.put(
TriggerType.FINISHED, getReservationsForProcedure(finishedTriggeringProcedure));
TriggerState.FINISHED,
getReservationsForProcedure(finishedTriggeringProcedure));
}
}

Expand All @@ -276,12 +277,12 @@ public String getName() {
return name;
}

/* package */ TriggerType getCurrentTriggerType() {
return currentTriggerType;
/* package */ TriggerState getCurrentTriggerState() {
return currentTriggerState;
}

/* package */ boolean isTriggering() {
return switch (currentTriggerType) {
return switch (currentTriggerState) {
case NEWLY -> true;
case CONTINUING -> true;
case FINISHED -> false;
Expand All @@ -290,41 +291,41 @@ public String getName() {
}

/* package */ void reset() {
currentTriggerType = TriggerType.NONE;
currentTriggerState = TriggerState.NONE;
}

/* package */ void evaluate() {
if (predicate.getAsBoolean()) {
currentTriggerType =
switch (currentTriggerType) {
case NONE -> TriggerType.NEWLY;
case NEWLY -> TriggerType.CONTINUING;
case CONTINUING -> TriggerType.CONTINUING;
case FINISHED -> TriggerType.NEWLY;
currentTriggerState =
switch (currentTriggerState) {
case NONE -> TriggerState.NEWLY;
case NEWLY -> TriggerState.CONTINUING;
case CONTINUING -> TriggerState.CONTINUING;
case FINISHED -> TriggerState.NEWLY;
};
} else {
currentTriggerType =
switch (currentTriggerType) {
case NONE -> TriggerType.NONE;
case NEWLY -> TriggerType.FINISHED;
case CONTINUING -> TriggerType.FINISHED;
case FINISHED -> TriggerType.NONE;
currentTriggerState =
switch (currentTriggerState) {
case NONE -> TriggerState.NONE;
case NEWLY -> TriggerState.FINISHED;
case CONTINUING -> TriggerState.FINISHED;
case FINISHED -> TriggerState.NONE;
};
}
}

/* package */ Set<Mechanism<?>> getMechanismsToReserve() {
return triggerReservations.getOrDefault(currentTriggerType, Collections.emptySet());
return triggerReservations.getOrDefault(currentTriggerState, Collections.emptySet());
}

/* package */ Cancellation getCancellationOnFinish() {
return cancellationOnFinish;
}

/* package */ Procedure getProcedureToRun() {
if (currentTriggerType != TriggerType.NONE) {
if (triggerProcedures.containsKey(currentTriggerType)) {
Supplier<Procedure> supplier = triggerProcedures.get(currentTriggerType);
if (currentTriggerState != TriggerState.NONE) {
if (triggerProcedures.containsKey(currentTriggerState)) {
Supplier<Procedure> supplier = triggerProcedures.get(currentTriggerState);
if (supplier != null) {
return supplier.get();
}
Expand All @@ -340,8 +341,8 @@ public String toString() {
builder.append(name);
builder.append(", predicate: ");
builder.append(predicate);
builder.append(", currentTriggerType: ");
builder.append(currentTriggerType);
builder.append(", currentTriggerState: ");
builder.append(currentTriggerState);
builder.append("]");
return builder.toString();
}
Expand Down
15 changes: 8 additions & 7 deletions src/main/java/com/team766/framework3/RuleEngine.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,7 @@
*/
public class RuleEngine implements LoggingBase {

private static record RuleAction(Rule rule, Rule.TriggerType triggerType) {}
private static record RuleAction(Rule rule, Rule.TriggerState triggerState) {}

private final List<Rule> rules = new LinkedList<>();
private final Map<Rule, Integer> rulePriorities = new HashMap<>();
Expand Down Expand Up @@ -87,9 +87,9 @@ public final void run() {
rule.evaluate();

// see if the rule is triggering
final Rule.TriggerType triggerType = rule.getCurrentTriggerType();
if (triggerType != Rule.TriggerType.NONE) {
log(Severity.INFO, "Rule " + rule.getName() + " triggering: " + triggerType);
final Rule.TriggerState triggerState = rule.getCurrentTriggerState();
if (triggerState != Rule.TriggerState.NONE) {
log(Severity.INFO, "Rule " + rule.getName() + " triggering: " + triggerState);

int priority = getPriorityForRule(rule);

Expand Down Expand Up @@ -150,11 +150,12 @@ public final void run() {

// we're good to proceed

if (triggerType == Rule.TriggerType.FINISHED
if (triggerState == Rule.TriggerState.FINISHED
&& rule.getCancellationOnFinish()
== Rule.Cancellation.CANCEL_NEWLY_ACTION) {
var newlyCommand =
ruleMap.inverse().get(new RuleAction(rule, Rule.TriggerType.NEWLY));
ruleMap.inverse()
.get(new RuleAction(rule, Rule.TriggerState.NEWLY));
if (newlyCommand != null) {
newlyCommand.cancel();
}
Expand All @@ -174,7 +175,7 @@ public final void run() {
// TODO(MF3): check that the reservations have not changed
Command command = procedure.createCommandToRunProcedure();
mechanismsToUse.addAll(reservations);
ruleMap.forcePut(command, new RuleAction(rule, triggerType));
ruleMap.forcePut(command, new RuleAction(rule, triggerState));
command.schedule();
}
} catch (Exception ex) {
Expand Down
22 changes: 11 additions & 11 deletions src/test/java/com/team766/framework3/RuleTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,7 @@
import static org.junit.jupiter.api.Assertions.assertNull;

import com.team766.framework3.Rule.Cancellation;
import com.team766.framework3.Rule.TriggerType;
import com.team766.framework3.Rule.TriggerState;
import java.util.Collections;
import java.util.List;
import java.util.Set;
Expand Down Expand Up @@ -68,31 +68,31 @@ public void testEvaluate() {
Rule.create("always true", () -> true)
.withOnTriggeringProcedure(ONCE, () -> Procedure.NO_OP)
.build());
assertEquals(Rule.TriggerType.NONE, alwaysTrue.getCurrentTriggerType());
assertEquals(Rule.TriggerState.NONE, alwaysTrue.getCurrentTriggerState());
alwaysTrue.evaluate();
assertEquals(TriggerType.NEWLY, alwaysTrue.getCurrentTriggerType());
assertEquals(TriggerState.NEWLY, alwaysTrue.getCurrentTriggerState());
alwaysTrue.evaluate();
assertEquals(TriggerType.CONTINUING, alwaysTrue.getCurrentTriggerType());
assertEquals(TriggerState.CONTINUING, alwaysTrue.getCurrentTriggerState());
alwaysTrue.evaluate();
assertEquals(TriggerType.CONTINUING, alwaysTrue.getCurrentTriggerType());
assertEquals(TriggerState.CONTINUING, alwaysTrue.getCurrentTriggerState());

// test a full cycle: NONE->NEWLY->CONTINUING->FINISHED->NONE->NEWLY->...
Rule duckDuckGooseGoose =
getSingleElement(
Rule.create("duck duck goose goose", new DuckDuckGooseGoosePredicate())
.withOnTriggeringProcedure(ONCE, () -> Procedure.NO_OP)
.build());
assertEquals(Rule.TriggerType.NONE, duckDuckGooseGoose.getCurrentTriggerType());
assertEquals(Rule.TriggerState.NONE, duckDuckGooseGoose.getCurrentTriggerState());
duckDuckGooseGoose.evaluate();
assertEquals(TriggerType.NEWLY, duckDuckGooseGoose.getCurrentTriggerType());
assertEquals(TriggerState.NEWLY, duckDuckGooseGoose.getCurrentTriggerState());
duckDuckGooseGoose.evaluate();
assertEquals(TriggerType.CONTINUING, duckDuckGooseGoose.getCurrentTriggerType());
assertEquals(TriggerState.CONTINUING, duckDuckGooseGoose.getCurrentTriggerState());
duckDuckGooseGoose.evaluate();
assertEquals(TriggerType.FINISHED, duckDuckGooseGoose.getCurrentTriggerType());
assertEquals(TriggerState.FINISHED, duckDuckGooseGoose.getCurrentTriggerState());
duckDuckGooseGoose.evaluate();
assertEquals(TriggerType.NONE, duckDuckGooseGoose.getCurrentTriggerType());
assertEquals(TriggerState.NONE, duckDuckGooseGoose.getCurrentTriggerState());
duckDuckGooseGoose.evaluate();
assertEquals(TriggerType.NEWLY, duckDuckGooseGoose.getCurrentTriggerType());
assertEquals(TriggerState.NEWLY, duckDuckGooseGoose.getCurrentTriggerState());
}

@Test
Expand Down

0 comments on commit 5e49fed

Please sign in to comment.