diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/builders/StateMachineTransitionBuilder.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/builders/StateMachineTransitionBuilder.java index 74395a2e..c1fa85a9 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/builders/StateMachineTransitionBuilder.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/builders/StateMachineTransitionBuilder.java @@ -54,7 +54,6 @@ import org.springframework.statemachine.config.model.HistoryData; import org.springframework.statemachine.config.model.JunctionData; import org.springframework.statemachine.config.model.TransitionData; import org.springframework.statemachine.config.model.TransitionsData; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.transition.TransitionKind; @@ -179,8 +178,8 @@ public class StateMachineTransitionBuilder * @param securityRule the security rule */ public void addTransition(S source, S target, S state, E event, Long period, Integer count, - Collection, Mono>> actions, Guard guard, TransitionKind kind, - SecurityRule securityRule) { + Collection, Mono>> actions, + Function, Mono> guard, TransitionKind kind, SecurityRule securityRule) { // if rule not given, get it from global if (securityRule == null) { @SuppressWarnings("unchecked") diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/AbstractTransitionConfigurer.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/AbstractTransitionConfigurer.java index eb4200e6..ae9cdf87 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/AbstractTransitionConfigurer.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/AbstractTransitionConfigurer.java @@ -27,6 +27,7 @@ import org.springframework.statemachine.config.builders.StateMachineTransitionCo import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter; import org.springframework.statemachine.config.model.TransitionsData; import org.springframework.statemachine.guard.Guard; +import org.springframework.statemachine.guard.Guards; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.security.SecurityRule.ComparisonType; @@ -50,7 +51,7 @@ public abstract class AbstractTransitionConfigurer extends private Long period; private Integer count; private final Collection, Mono>> actions = new ArrayList<>(); - private Guard guard; + private Function, Mono> guard; private SecurityRule securityRule; protected S getSource() { @@ -85,7 +86,7 @@ public abstract class AbstractTransitionConfigurer extends return actions; } - protected Guard getGuard() { + protected Function, Mono> getGuard() { return guard; } @@ -134,6 +135,10 @@ public abstract class AbstractTransitionConfigurer extends } protected void setGuard(Guard guard) { + this.guard = Guards.from(guard); + } + + protected void setGuardFunction(Function, Mono> guard) { this.guard = guard; } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/TransitionData.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/TransitionData.java index cbea4d10..e6aebf7f 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/TransitionData.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/TransitionData.java @@ -19,7 +19,6 @@ import java.util.Collection; import java.util.function.Function; import org.springframework.statemachine.StateContext; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.transition.TransitionKind; @@ -39,7 +38,7 @@ public class TransitionData { private final Long period; private final Integer count; private final Collection, Mono>> actions; - private final Guard guard; + private final Function, Mono> guard; private final TransitionKind kind; private final SecurityRule securityRule; @@ -65,7 +64,7 @@ public class TransitionData { * @param kind the kind */ public TransitionData(S source, S target, E event, Collection, Mono>> actions, - Guard guard, TransitionKind kind) { + Function, Mono> guard, TransitionKind kind) { this(source, target, null, event, null, null, actions, guard, kind, null); } @@ -81,7 +80,8 @@ public class TransitionData { * @param kind the kind */ public TransitionData(S source, S target, Long period, Integer count, - Collection, Mono>> actions, Guard guard, TransitionKind kind) { + Collection, Mono>> actions, + Function, Mono> guard, TransitionKind kind) { this(source, target, null, null, period, count, actions, guard, kind, null); } @@ -100,8 +100,8 @@ public class TransitionData { * @param securityRule the security rule */ public TransitionData(S source, S target, S state, E event, Long period, Integer count, - Collection, Mono>> actions, Guard guard, TransitionKind kind, - SecurityRule securityRule) { + Collection, Mono>> actions, + Function, Mono> guard, TransitionKind kind, SecurityRule securityRule) { this.source = source; this.target = target; this.state = state; @@ -182,7 +182,7 @@ public class TransitionData { * * @return the guard */ - public Guard getGuard() { + public Function, Mono> getGuard() { return guard; } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/guard/Guards.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/guard/Guards.java new file mode 100644 index 00000000..6580de15 --- /dev/null +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/guard/Guards.java @@ -0,0 +1,49 @@ +/* + * Copyright 2019 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.statemachine.guard; + +import java.util.function.Function; + +import org.springframework.statemachine.StateContext; + +import reactor.core.publisher.Mono; + +/** + * Guard Utilities. + * + * @author Janne Valkealahti + * + */ +public final class Guards { + + /** + * Builds a {@link ReactiveGuard} from a {@link Guard}. + * + * @param the type of state + * @param the type of event + * @param guard the guard + * @return the function + */ + public static Function, Mono> from(Guard guard) { + if (guard != null) { + return context -> Mono.fromSupplier(() -> guard.evaluate(context)); + } else { + // TODO: REACTOR think if should just return funtion evaluating true as null guard + // essentially is like a guard evaluating true, thought we'd prevent on dummy call. + return null; + } + } +} diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/guard/ReactiveGuard.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/guard/ReactiveGuard.java new file mode 100644 index 00000000..c8ac343a --- /dev/null +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/guard/ReactiveGuard.java @@ -0,0 +1,34 @@ +/* + * Copyright 2019 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.statemachine.guard; + +import java.util.function.Function; + +import org.springframework.statemachine.StateContext; + +import reactor.core.publisher.Mono; + +/** + * Reactive counterpart of a {@link Guard} being simply a {@link Function} of a + * return type of a {@link Mono} wrapping {@link Boolean}. + * + * @author Janne Valkealahti + * + * @param the type of state + * @param the type of event + */ +public interface ReactiveGuard extends Function, Mono> { +} diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/state/JoinPseudoState.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/state/JoinPseudoState.java index e07076a4..bc5fdce5 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/state/JoinPseudoState.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/state/JoinPseudoState.java @@ -19,6 +19,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; +import java.util.function.Function; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -27,6 +28,8 @@ import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.state.PseudoStateContext.PseudoAction; import org.springframework.util.Assert; +import reactor.core.publisher.Mono; + /** * Join implementation of a {@link PseudoState}. * @@ -94,9 +97,13 @@ public class JoinPseudoState extends AbstractPseudoState { tracker.reset(ids); } - private boolean evaluateInternal(Guard guard, StateContext context) { + private boolean evaluateInternal(Function, Mono> guard, StateContext context) { try { - return guard.evaluate(context); + // Function, Mono> + // TODO: REACTOR no blocking! + // return guard.evaluate(context); + return guard.apply(context).block(); + } catch (Throwable t) { log.warn("Deny guard due to throw as GUARD should not error", t); return false; @@ -179,7 +186,7 @@ public class JoinPseudoState extends AbstractPseudoState { */ public static class JoinStateData { private final StateHolder state; - private final Guard guard; + private final Function, Mono> guard; /** * Instantiates a new join state data. @@ -187,7 +194,7 @@ public class JoinPseudoState extends AbstractPseudoState { * @param state the state holder * @param guard the guard */ - public JoinStateData(StateHolder state, Guard guard) { + public JoinStateData(StateHolder state, Function, Mono> guard) { Assert.notNull(state, "Holder must be set"); this.state = state; this.guard = guard; @@ -216,7 +223,7 @@ public class JoinPseudoState extends AbstractPseudoState { * * @return the guard */ - public Guard getGuard() { + public Function, Mono> getGuard() { return guard; } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractExternalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractExternalTransition.java index adfd92c2..1b0509cf 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractExternalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractExternalTransition.java @@ -19,7 +19,6 @@ import java.util.Collection; import java.util.function.Function; import org.springframework.statemachine.StateContext; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.state.State; import org.springframework.statemachine.trigger.Trigger; @@ -40,8 +39,8 @@ public abstract class AbstractExternalTransition extends AbstractTransitio * @param securityRule the security rule */ public AbstractExternalTransition(State source, State target, - Collection, Mono>> actions, E event, Guard guard, - Trigger trigger, SecurityRule securityRule) { + Collection, Mono>> actions, E event, + Function, Mono> guard, Trigger trigger, SecurityRule securityRule) { super(source, target, actions, event, TransitionKind.EXTERNAL, guard, trigger, securityRule); } @@ -56,8 +55,8 @@ public abstract class AbstractExternalTransition extends AbstractTransitio * @param trigger the trigger */ public AbstractExternalTransition(State source, State target, - Collection, Mono>> actions, E event, Guard guard, - Trigger trigger) { + Collection, Mono>> actions, E event, + Function, Mono> guard, Trigger trigger) { super(source, target, actions, event, TransitionKind.EXTERNAL, guard, trigger); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractInternalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractInternalTransition.java index 4c9a4f73..811d3aac 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractInternalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractInternalTransition.java @@ -19,7 +19,6 @@ import java.util.Collection; import java.util.function.Function; import org.springframework.statemachine.StateContext; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.state.State; import org.springframework.statemachine.trigger.Trigger; @@ -38,7 +37,7 @@ public class AbstractInternalTransition extends AbstractTransition i * @param trigger the trigger */ public AbstractInternalTransition(State source, Collection, Mono>> actions, - E event, Guard guard, Trigger trigger) { + E event, Function, Mono> guard, Trigger trigger) { super(source, source, actions, event, TransitionKind.INTERNAL, guard, trigger); } @@ -53,7 +52,8 @@ public class AbstractInternalTransition extends AbstractTransition i * @param securityRule the security rule */ public AbstractInternalTransition(State source, Collection, Mono>> actions, - E event, Guard guard, Trigger trigger, SecurityRule securityRule) { + E event, Function, Mono> guard, Trigger trigger, + SecurityRule securityRule) { super(source, source, actions, event, TransitionKind.INTERNAL, guard, trigger, securityRule); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractLocalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractLocalTransition.java index 06b01368..2a121e37 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractLocalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractLocalTransition.java @@ -19,7 +19,6 @@ import java.util.Collection; import java.util.function.Function; import org.springframework.statemachine.StateContext; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.state.State; import org.springframework.statemachine.trigger.Trigger; @@ -39,8 +38,8 @@ public class AbstractLocalTransition extends AbstractTransition impl * @param trigger the trigger */ public AbstractLocalTransition(State source, State target, - Collection, Mono>> actions, E event, Guard guard, - Trigger trigger) { + Collection, Mono>> actions, E event, + Function, Mono> guard, Trigger trigger) { super(source, target, actions, event, TransitionKind.LOCAL, guard, trigger); } @@ -56,8 +55,8 @@ public class AbstractLocalTransition extends AbstractTransition impl * @param securityRule the security rule */ public AbstractLocalTransition(State source, State target, - Collection, Mono>> actions, E event, Guard guard, - Trigger trigger, SecurityRule securityRule) { + Collection, Mono>> actions, E event, + Function, Mono> guard, Trigger trigger, SecurityRule securityRule) { super(source, target, actions, event, TransitionKind.LOCAL, guard, trigger, securityRule); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractTransition.java index 547d6078..0e5a54b0 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractTransition.java @@ -23,7 +23,6 @@ import org.apache.commons.logging.LogFactory; import org.springframework.statemachine.StateContext; import org.springframework.statemachine.action.ActionListener; import org.springframework.statemachine.action.CompositeActionListener; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.state.State; import org.springframework.statemachine.trigger.Trigger; @@ -47,7 +46,7 @@ public abstract class AbstractTransition implements Transition { protected final Collection, Mono>> actions; private final State source; private final TransitionKind kind; - private final Guard guard; + private final Function, Mono> guard; private final Trigger trigger; private final SecurityRule securityRule; private CompositeActionListener actionListener; @@ -65,7 +64,7 @@ public abstract class AbstractTransition implements Transition { */ public AbstractTransition(State source, State target, Collection, Mono>> actions, E event, TransitionKind kind, - Guard guard, Trigger trigger) { + Function, Mono> guard, Trigger trigger) { this(source, target, actions, event, kind, guard, trigger, null); } @@ -83,7 +82,7 @@ public abstract class AbstractTransition implements Transition { */ public AbstractTransition(State source, State target, Collection, Mono>> actions, E event, TransitionKind kind, - Guard guard, Trigger trigger, SecurityRule securityRule) { + Function, Mono> guard, Trigger trigger, SecurityRule securityRule) { Assert.notNull(kind, "Transition type must be set"); this.source = source; this.target = target; @@ -108,7 +107,8 @@ public abstract class AbstractTransition implements Transition { public boolean transit(StateContext context) { if (guard != null) { try { - if (!guard.evaluate(context)) { + // TODO: REACTOR change not to block + if (!guard.apply(context).block()) { return false; } } @@ -121,7 +121,7 @@ public abstract class AbstractTransition implements Transition { } @Override - public Guard getGuard() { + public Function, Mono> getGuard() { return guard; } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultExternalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultExternalTransition.java index 89f82c31..a03c631e 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultExternalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultExternalTransition.java @@ -19,7 +19,6 @@ import java.util.Collection; import java.util.function.Function; import org.springframework.statemachine.StateContext; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.state.State; import org.springframework.statemachine.trigger.Trigger; @@ -39,8 +38,8 @@ public class DefaultExternalTransition extends AbstractExternalTransition< * @param trigger the trigger */ public DefaultExternalTransition(State source, State target, - Collection, Mono>> actions, E event, Guard guard, - Trigger trigger) { + Collection, Mono>> actions, E event, + Function, Mono> guard, Trigger trigger) { super(source, target, actions, event, guard, trigger); } @@ -56,8 +55,8 @@ public class DefaultExternalTransition extends AbstractExternalTransition< * @param securityRule the security rule */ public DefaultExternalTransition(State source, State target, - Collection, Mono>> actions, E event, Guard guard, - Trigger trigger, SecurityRule securityRule) { + Collection, Mono>> actions, E event, + Function, Mono> guard, Trigger trigger, SecurityRule securityRule) { super(source, target, actions, event, guard, trigger, securityRule); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultInternalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultInternalTransition.java index 020ad532..6aa1ddd4 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultInternalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultInternalTransition.java @@ -19,7 +19,6 @@ import java.util.Collection; import java.util.function.Function; import org.springframework.statemachine.StateContext; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.state.State; import org.springframework.statemachine.trigger.Trigger; @@ -38,7 +37,7 @@ public class DefaultInternalTransition extends AbstractInternalTransition< * @param trigger the trigger */ public DefaultInternalTransition(State source, Collection, Mono>> actions, - E event, Guard guard, Trigger trigger) { + E event, Function, Mono> guard, Trigger trigger) { super(source, actions, event, guard, trigger); } @@ -53,7 +52,8 @@ public class DefaultInternalTransition extends AbstractInternalTransition< * @param securityRule the security rule */ public DefaultInternalTransition(State source, Collection, Mono>> actions, - E event, Guard guard, Trigger trigger, SecurityRule securityRule) { + E event, Function, Mono> guard, Trigger trigger, + SecurityRule securityRule) { super(source, actions, event, guard, trigger, securityRule); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultLocalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultLocalTransition.java index 46b37f9b..2b455be6 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultLocalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultLocalTransition.java @@ -39,8 +39,8 @@ public class DefaultLocalTransition extends AbstractLocalTransition * @param trigger the trigger */ public DefaultLocalTransition(State source, State target, - Collection, Mono>> actions, E event, Guard guard, - Trigger trigger) { + Collection, Mono>> actions, E event, + Function, Mono> guard, Trigger trigger) { super(source, target, actions, event, guard, trigger); } @@ -56,8 +56,8 @@ public class DefaultLocalTransition extends AbstractLocalTransition * @param securityRule the security rule */ public DefaultLocalTransition(State source, State target, - Collection, Mono>> actions, E event, Guard guard, - Trigger trigger, SecurityRule securityRule) { + Collection, Mono>> actions, E event, + Function, Mono> guard, Trigger trigger, SecurityRule securityRule) { super(source, target, actions, event, guard, trigger, securityRule); } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/Transition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/Transition.java index 650bc615..f57564b9 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/Transition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/Transition.java @@ -20,7 +20,6 @@ import java.util.function.Function; import org.springframework.statemachine.StateContext; import org.springframework.statemachine.action.ActionListener; -import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.security.SecurityRule; import org.springframework.statemachine.state.State; import org.springframework.statemachine.trigger.Trigger; @@ -73,7 +72,7 @@ public interface Transition { * * @return the guard */ - Guard getGuard(); + Function, Mono> getGuard(); /** * Gets the transition actions. diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java index 8ddccc8b..4f8fec76 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java @@ -125,7 +125,7 @@ public class StateContextExpressionMethodsTests { } @Override - public Guard getGuard() { + public Function, Mono> getGuard() { return null; } diff --git a/spring-statemachine-data/src/main/java/org/springframework/statemachine/data/RepositoryStateMachineModelFactory.java b/spring-statemachine-data/src/main/java/org/springframework/statemachine/data/RepositoryStateMachineModelFactory.java index e8b4f968..09178ec0 100644 --- a/spring-statemachine-data/src/main/java/org/springframework/statemachine/data/RepositoryStateMachineModelFactory.java +++ b/spring-statemachine-data/src/main/java/org/springframework/statemachine/data/RepositoryStateMachineModelFactory.java @@ -45,6 +45,7 @@ import org.springframework.statemachine.config.model.StatesData; import org.springframework.statemachine.config.model.TransitionData; import org.springframework.statemachine.config.model.TransitionsData; import org.springframework.statemachine.guard.Guard; +import org.springframework.statemachine.guard.Guards; import org.springframework.statemachine.guard.SpelExpressionGuard; import org.springframework.statemachine.state.PseudoStateKind; import org.springframework.statemachine.transition.TransitionKind; @@ -225,7 +226,8 @@ public class RepositoryStateMachineModelFactory extends AbstractStateMachineMode TransitionKind kind = t.getKind(); Guard guard = resolveGuard(t); - transitionData.add(new TransitionData<>(t.getSource().getState(), t.getTarget().getState(), t.getEvent(), actions, guard, kind != null ? kind : TransitionKind.EXTERNAL)); + transitionData.add(new TransitionData<>(t.getSource().getState(), t.getTarget().getState(), t.getEvent(), + actions, Guards.from(guard), kind != null ? kind : TransitionKind.EXTERNAL)); if (t.getSource().getKind() == PseudoStateKind.ENTRY) { entrys.add(new EntryData(t.getSource().getState(), t.getTarget().getState())); diff --git a/spring-statemachine-uml/src/main/java/org/springframework/statemachine/uml/support/UmlModelParser.java b/spring-statemachine-uml/src/main/java/org/springframework/statemachine/uml/support/UmlModelParser.java index ef299860..6eeb0125 100644 --- a/spring-statemachine-uml/src/main/java/org/springframework/statemachine/uml/support/UmlModelParser.java +++ b/spring-statemachine-uml/src/main/java/org/springframework/statemachine/uml/support/UmlModelParser.java @@ -65,6 +65,7 @@ import org.springframework.statemachine.config.model.StatesData; import org.springframework.statemachine.config.model.TransitionData; import org.springframework.statemachine.config.model.TransitionsData; import org.springframework.statemachine.guard.Guard; +import org.springframework.statemachine.guard.Guards; import org.springframework.statemachine.guard.SpelExpressionGuard; import org.springframework.statemachine.state.PseudoStateKind; import org.springframework.util.Assert; @@ -381,13 +382,13 @@ public class UmlModelParser { transitionDatas .add(new TransitionData(resolveName(transition.getSource()), cprentries.get(0).getName(), signal.getName(), - UmlUtils.resolveTransitionActionFunctions(transition, resolver), guard, - UmlUtils.mapUmlTransitionType(transition))); + UmlUtils.resolveTransitionActionFunctions(transition, resolver), + Guards.from(guard), UmlUtils.mapUmlTransitionType(transition))); } } else { transitionDatas.add(new TransitionData(resolveName(transition.getSource()), resolveName(transition.getTarget()), signal.getName(), - UmlUtils.resolveTransitionActionFunctions(transition, resolver), guard, + UmlUtils.resolveTransitionActionFunctions(transition, resolver), Guards.from(guard), UmlUtils.mapUmlTransitionType(transition))); } } @@ -401,7 +402,7 @@ public class UmlModelParser { } transitionDatas.add(new TransitionData(resolveName(transition.getSource()), resolveName(transition.getTarget()), period, count, - UmlUtils.resolveTransitionActionFunctions(transition, resolver), guard, + UmlUtils.resolveTransitionActionFunctions(transition, resolver), Guards.from(guard), UmlUtils.mapUmlTransitionType(transition))); } } @@ -411,8 +412,8 @@ public class UmlModelParser { if (shouldCreateAnonymousTransition(transition)) { transitionDatas.add(new TransitionData(resolveName(transition.getSource()), resolveName(transition.getTarget()), null, - UmlUtils.resolveTransitionActionFunctions(transition, resolver), resolveGuard(transition), - UmlUtils.mapUmlTransitionType(transition))); + UmlUtils.resolveTransitionActionFunctions(transition, resolver), + Guards.from(resolveGuard(transition)), UmlUtils.mapUmlTransitionType(transition))); } } }