Spring/spring-statemachine
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor config model classes

Browse Source 
- Better naming for public model
  data classes.
- Relates to #172
This commit is contained in:
Janne Valkealahti
2016-03-19 10:06:38 +00:00
parent 79a91220f6
commit d3eb24ed1c
28 changed files with 345 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/AbstractStateMachineFactory.java
View File

@@ -39,11 +39,9 @@ import org.springframework.statemachine.access.StateMachineFunction;
import org.springframework.statemachine.action.Action;
import org.springframework.statemachine.config.model.ChoiceData;
import org.springframework.statemachine.config.model.StateData;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineModel;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.TransitionData;
import org.springframework.statemachine.config.model.TransitionsData;
import org.springframework.statemachine.config.model.verifier.CompositeStateMachineModelVerifier;
import org.springframework.statemachine.config.model.verifier.StateMachineModelVerifier;
import org.springframework.statemachine.ensemble.DistributedStateMachine;
@@ -91,12 +89,6 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
private final Log log = LogFactory.getLog(AbstractStateMachineFactory.class);
private final StateMachineTransitions<S, E> stateMachineTransitions;
private final StateMachineStates<S, E> stateMachineStates;
private final StateMachineConfigurationConfig<S, E> stateMachineConfigurationConfig;
private final StateMachineModel<S, E> stateMachineModel;
private Boolean contextEvents;
@@ -113,9 +105,6 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
public AbstractStateMachineFactory(StateMachineModel<S, E> stateMachineModel) {
Assert.notNull(stateMachineModel, "StateMachineModel must be set");
this.stateMachineModel = stateMachineModel;
this.stateMachineConfigurationConfig = stateMachineModel.getConfiguration();
this.stateMachineTransitions = stateMachineModel.getTransitions();
this.stateMachineStates = stateMachineModel.getStates();
}
@Override
@@ -126,8 +115,8 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
@SuppressWarnings("unchecked")
@Override
public StateMachine<S, E> getStateMachine() {
if (stateMachineConfigurationConfig.isVerifierEnabled()) {
StateMachineModelVerifier<S, E> verifier = stateMachineConfigurationConfig.getVerifier();
if (stateMachineModel.getConfigurationData().isVerifierEnabled()) {
StateMachineModelVerifier<S, E> verifier = stateMachineModel.getConfigurationData().getVerifier();
if (verifier == null) {
verifier = new CompositeStateMachineModelVerifier<S, E>();
}
@@ -183,7 +172,7 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
if (initialCount > 1) {
for (Collection<StateData<S, E>> regionStateDatas : regionsStateDatas) {
machine = buildMachine(machineMap, stateMap, regionStateDatas, transitionsData, resolveBeanFactory(),
contextEvents, defaultExtendedState, stateMachineTransitions, resolveTaskExecutor(),
contextEvents, defaultExtendedState, stateMachineModel.getTransitionsData(), resolveTaskExecutor(),
resolveTaskScheduler());
regionStack.push(new MachineStackItem<S, E>(machine));
}
@@ -210,7 +199,7 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
}
} else {
machine = buildMachine(machineMap, stateMap, stateDatas, transitionsData, resolveBeanFactory(),
contextEvents, defaultExtendedState, stateMachineTransitions, resolveTaskExecutor(), resolveTaskScheduler());
contextEvents, defaultExtendedState, stateMachineModel.getTransitionsData(), resolveTaskExecutor(), resolveTaskScheduler());
if (peek.isInitial() || (!peek.isInitial() && !machineMap.containsKey(peek.getParent()))) {
machineMap.put(peek.getParent(), machine);
}
@@ -221,7 +210,7 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
// setup autostart for top-level machine
if (machine instanceof LifecycleObjectSupport) {
((LifecycleObjectSupport)machine).setAutoStartup(stateMachineConfigurationConfig.isAutoStart());
((LifecycleObjectSupport)machine).setAutoStartup(stateMachineModel.getConfigurationData().isAutoStart());
}
// set top-level machine as relay
@@ -235,11 +224,11 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
});
// TODO: should error out if sec is enabled but spring-security is not in cp
if (stateMachineConfigurationConfig.isSecurityEnabled()) {
if (stateMachineModel.getConfigurationData().isSecurityEnabled()) {
final StateMachineSecurityInterceptor<S, E> securityInterceptor = new StateMachineSecurityInterceptor<S, E>(
stateMachineConfigurationConfig.getTransitionSecurityAccessDecisionManager(),
stateMachineConfigurationConfig.getEventSecurityAccessDecisionManager(),
stateMachineConfigurationConfig.getEventSecurityRule());
stateMachineModel.getConfigurationData().getTransitionSecurityAccessDecisionManager(),
stateMachineModel.getConfigurationData().getEventSecurityAccessDecisionManager(),
stateMachineModel.getConfigurationData().getEventSecurityRule());
log.info("Adding security interceptor " + securityInterceptor);
fmachine.getStateMachineAccessor().doWithAllRegions(new StateMachineFunction<StateMachineAccess<S, E>>() {
@@ -253,15 +242,15 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
// setup distributed state machine if needed.
// we wrap previously build machine with a distributed
// state machine and set it to use given ensemble.
if (stateMachineConfigurationConfig.getStateMachineEnsemble() != null) {
if (stateMachineModel.getConfigurationData().getStateMachineEnsemble() != null) {
DistributedStateMachine<S, E> distributedStateMachine = new DistributedStateMachine<S, E>(
stateMachineConfigurationConfig.getStateMachineEnsemble(), machine);
distributedStateMachine.setAutoStartup(stateMachineConfigurationConfig.isAutoStart());
stateMachineModel.getConfigurationData().getStateMachineEnsemble(), machine);
distributedStateMachine.setAutoStartup(stateMachineModel.getConfigurationData().isAutoStart());
distributedStateMachine.afterPropertiesSet();
machine = distributedStateMachine;
}
for (StateMachineListener<S, E> listener : stateMachineConfigurationConfig.getStateMachineListeners()) {
for (StateMachineListener<S, E> listener : stateMachineModel.getConfigurationData().getStateMachineListeners()) {
machine.addStateListener(listener);
}
@@ -295,24 +284,24 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
}
private BeanFactory resolveBeanFactory() {
if (stateMachineConfigurationConfig.getBeanFactory() != null) {
return stateMachineConfigurationConfig.getBeanFactory();
if (stateMachineModel.getConfigurationData().getBeanFactory() != null) {
return stateMachineModel.getConfigurationData().getBeanFactory();
} else {
return getBeanFactory();
}
}
private TaskExecutor resolveTaskExecutor() {
if (stateMachineConfigurationConfig.getTaskExecutor() != null) {
return stateMachineConfigurationConfig.getTaskExecutor();
if (stateMachineModel.getConfigurationData().getTaskExecutor() != null) {
return stateMachineModel.getConfigurationData().getTaskExecutor();
} else {
return getTaskExecutor();
}
}
private TaskScheduler resolveTaskScheduler() {
if (stateMachineConfigurationConfig.getTaskScheduler() != null) {
return stateMachineConfigurationConfig.getTaskScheduler();
if (stateMachineModel.getConfigurationData().getTaskScheduler() != null) {
return stateMachineModel.getConfigurationData().getTaskScheduler();
} else {
return getTaskScheduler();
}
@@ -343,9 +332,9 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
private Collection<TransitionData<S, E>> getTransitionData(boolean roots, Collection<StateData<S, E>> stateDatas) {
if (roots) {
return resolveTransitionData(stateMachineTransitions.getTransitions(), stateDatas);
return resolveTransitionData(stateMachineModel.getTransitionsData().getTransitions(), stateDatas);
} else {
return resolveTransitionData2(stateMachineTransitions.getTransitions());
return resolveTransitionData2(stateMachineModel.getTransitionsData().getTransitions());
}
}
@@ -405,7 +394,7 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
Map<Object, StateMachine<S, E>> machineMap, Map<S, State<S, E>> stateMap,
Collection<StateData<S, E>> stateDatas, Collection<TransitionData<S, E>> transitionsData,
BeanFactory beanFactory, Boolean contextEvents, DefaultExtendedState defaultExtendedState,
StateMachineTransitions<S, E> stateMachineTransitions, TaskExecutor taskExecutor,
TransitionsData<S, E> stateMachineTransitions, TaskExecutor taskExecutor,
TaskScheduler taskScheduler) {
State<S, E> state = null;
State<S, E> initialState = null;
@@ -606,7 +595,7 @@ public abstract class AbstractStateMachineFactory<S, E> extends LifecycleObjectS
private Iterator<Node<StateData<S, E>>> buildStateDataIterator() {
Tree<StateData<S, E>> tree = new Tree<StateData<S, E>>();
for (StateData<S, E> stateData : stateMachineStates.getStateDatas()) {
for (StateData<S, E> stateData : stateMachineModel.getStatesData().getStateData()) {
Object id = stateData.getState();
Object parent = stateData.getParent();
tree.add(stateData, id, parent);

12
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/StateMachineBuilder.java
View File

@@ -30,9 +30,9 @@ import org.springframework.statemachine.config.builders.StateMachineTransitionCo
import org.springframework.statemachine.config.common.annotation.AnnotationBuilder;
import org.springframework.statemachine.config.common.annotation.ObjectPostProcessor;
import org.springframework.statemachine.config.model.DefaultStateMachineModel;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.config.model.TransitionsData;
/**
* {@code StateMachineBuilder} provides a builder pattern for
@@ -112,9 +112,9 @@ public class StateMachineBuilder {
builder.apply(adapter);
StateMachineConfig<S, E> stateMachineConfig = builder.getOrBuild();
StateMachineTransitions<S, E> stateMachineTransitions = stateMachineConfig.getTransitions();
StateMachineStates<S, E> stateMachineStates = stateMachineConfig.getStates();
StateMachineConfigurationConfig<S, E> stateMachineConfigurationConfig = stateMachineConfig.getStateMachineConfigurationConfig();
TransitionsData<S, E> stateMachineTransitions = stateMachineConfig.getTransitions();
StatesData<S, E> stateMachineStates = stateMachineConfig.getStates();
ConfigurationData<S, E> stateMachineConfigurationConfig = stateMachineConfig.getStateMachineConfigurationConfig();
ObjectStateMachineFactory<S, E> stateMachineFactory = new ObjectStateMachineFactory<S, E>(
new DefaultStateMachineModel<S, E>(stateMachineConfigurationConfig, stateMachineStates, stateMachineTransitions));

20
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/StateMachineConfig.java
View File

@@ -15,33 +15,33 @@
*/
package org.springframework.statemachine.config;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.config.model.TransitionsData;
public class StateMachineConfig<S, E> {
public final StateMachineConfigurationConfig<S, E> stateMachineConfigurationConfig;
public final ConfigurationData<S, E> stateMachineConfigurationConfig;
public final StateMachineTransitions<S, E> transitions;
public final TransitionsData<S, E> transitions;
public final StateMachineStates<S, E> states;
public final StatesData<S, E> states;
public StateMachineConfig(StateMachineConfigurationConfig<S, E> stateMachineConfigurationConfig, StateMachineTransitions<S, E> transitions, StateMachineStates<S, E> states) {
public StateMachineConfig(ConfigurationData<S, E> stateMachineConfigurationConfig, TransitionsData<S, E> transitions, StatesData<S, E> states) {
this.stateMachineConfigurationConfig = stateMachineConfigurationConfig;
this.transitions = transitions;
this.states = states;
}
public StateMachineConfigurationConfig<S, E> getStateMachineConfigurationConfig() {
public ConfigurationData<S, E> getStateMachineConfigurationConfig() {
return stateMachineConfigurationConfig;
}
public StateMachineTransitions<S, E> getTransitions() {
public TransitionsData<S, E> getTransitions() {
return transitions;
}
public StateMachineStates<S, E> getStates() {
public StatesData<S, E> getStates() {
return states;
}

14
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/builders/StateMachineConfigBuilder.java
View File

@@ -17,9 +17,9 @@ package org.springframework.statemachine.config.builders;
import org.springframework.statemachine.config.StateMachineConfig;
import org.springframework.statemachine.config.common.annotation.AbstractConfiguredAnnotationBuilder;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.config.model.TransitionsData;
public class StateMachineConfigBuilder<S, E>
extends
@@ -33,10 +33,10 @@ public class StateMachineConfigBuilder<S, E>
StateMachineStateBuilder<?, ?> stateBuilder = getSharedObject(StateMachineStateBuilder.class);
// build config first as it's shared with transition builder
StateMachineConfigurationConfig<S, E> config = (StateMachineConfigurationConfig<S, E>) configurationBuilder.build();
transitionBuilder.setSharedObject(StateMachineConfigurationConfig.class, config);
StateMachineTransitions<S, E> transitions = (StateMachineTransitions<S, E>) transitionBuilder.build();
StateMachineStates<S, E> states = (StateMachineStates<S, E>) stateBuilder.build();
ConfigurationData<S, E> config = (ConfigurationData<S, E>) configurationBuilder.build();
transitionBuilder.setSharedObject(ConfigurationData.class, config);
TransitionsData<S, E> transitions = (TransitionsData<S, E>) transitionBuilder.build();
StatesData<S, E> states = (StatesData<S, E>) stateBuilder.build();
StateMachineConfig<S, E> bean = new StateMachineConfig<S, E>(config, transitions, states);
return bean;
}

12
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/builders/StateMachineConfigurationBuilder.java
View File

@@ -33,15 +33,15 @@ import org.springframework.statemachine.config.configurers.DefaultVerifierConfig
import org.springframework.statemachine.config.configurers.DistributedStateMachineConfigurer;
import org.springframework.statemachine.config.configurers.SecurityConfigurer;
import org.springframework.statemachine.config.configurers.VerifierConfigurer;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.config.model.verifier.StateMachineModelVerifier;
import org.springframework.statemachine.ensemble.StateMachineEnsemble;
import org.springframework.statemachine.listener.StateMachineListener;
import org.springframework.statemachine.security.SecurityRule;
/**
* {@link AnnotationBuilder} for {@link StateMachineStates}.
* {@link AnnotationBuilder} for {@link StatesData}.
*
* @author Janne Valkealahti
*
@@ -49,7 +49,7 @@ import org.springframework.statemachine.security.SecurityRule;
* @param <E> the type of event
*/
public class StateMachineConfigurationBuilder<S, E>
extends AbstractConfiguredAnnotationBuilder<StateMachineConfigurationConfig<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
extends AbstractConfiguredAnnotationBuilder<ConfigurationData<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
implements StateMachineConfigurationConfigurer<S, E> {
private BeanFactory beanFactory;
@@ -114,8 +114,8 @@ public class StateMachineConfigurationBuilder<S, E>
}
@Override
protected StateMachineConfigurationConfig<S, E> performBuild() throws Exception {
return new StateMachineConfigurationConfig<S, E>(beanFactory, taskExecutor, taskScheculer, autoStart, ensemble, listeners,
protected ConfigurationData<S, E> performBuild() throws Exception {
return new ConfigurationData<S, E>(beanFactory, taskExecutor, taskScheculer, autoStart, ensemble, listeners,
securityEnabled, transitionSecurityAccessDecisionManager, eventSecurityAccessDecisionManager, eventSecurityRule,
transitionSecurityRule, verifierEnabled, verifier);
}

10
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/builders/StateMachineStateBuilder.java
View File

@@ -24,10 +24,10 @@ import org.springframework.statemachine.config.common.annotation.ObjectPostProce
import org.springframework.statemachine.config.configurers.DefaultStateConfigurer;
import org.springframework.statemachine.config.configurers.StateConfigurer;
import org.springframework.statemachine.config.model.StateData;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StatesData;
/**
* {@link AnnotationBuilder} for {@link StateMachineStates}.
* {@link AnnotationBuilder} for {@link StatesData}.
*
* @author Janne Valkealahti
*
@@ -35,7 +35,7 @@ import org.springframework.statemachine.config.model.StateMachineStates;
* @param <E> the type of event
*/
public class StateMachineStateBuilder<S, E>
extends AbstractConfiguredAnnotationBuilder<StateMachineStates<S, E>, StateMachineStateConfigurer<S, E>, StateMachineStateBuilder<S, E>>
extends AbstractConfiguredAnnotationBuilder<StatesData<S, E>, StateMachineStateConfigurer<S, E>, StateMachineStateBuilder<S, E>>
implements StateMachineStateConfigurer<S, E> {
private final Collection<StateData<S, E>> stateDatas = new ArrayList<StateData<S,E>>();
@@ -54,8 +54,8 @@ public class StateMachineStateBuilder<S, E>
}
@Override
protected StateMachineStates<S, E> performBuild() throws Exception {
return new StateMachineStates<S, E>(stateDatas);
protected StatesData<S, E> performBuild() throws Exception {
return new StatesData<S, E>(stateDatas);
}
@Override

14
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/builders/StateMachineTransitionBuilder.java
View File

@@ -38,15 +38,15 @@ import org.springframework.statemachine.config.configurers.InternalTransitionCon
import org.springframework.statemachine.config.configurers.JoinTransitionConfigurer;
import org.springframework.statemachine.config.configurers.LocalTransitionConfigurer;
import org.springframework.statemachine.config.model.ChoiceData;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.TransitionsData;
import org.springframework.statemachine.config.model.TransitionData;
import org.springframework.statemachine.guard.Guard;
import org.springframework.statemachine.security.SecurityRule;
import org.springframework.statemachine.transition.TransitionKind;
/**
* {@link AnnotationBuilder} for {@link StateMachineTransitions}.
* {@link AnnotationBuilder} for {@link TransitionsData}.
*
* @author Janne Valkealahti
*
@@ -55,7 +55,7 @@ import org.springframework.statemachine.transition.TransitionKind;
*/
public class StateMachineTransitionBuilder<S, E>
extends
AbstractConfiguredAnnotationBuilder<StateMachineTransitions<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>>
AbstractConfiguredAnnotationBuilder<TransitionsData<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>>
implements StateMachineTransitionConfigurer<S, E> {
private final Collection<TransitionData<S, E>> transitionData = new ArrayList<TransitionData<S, E>>();
@@ -77,8 +77,8 @@ public class StateMachineTransitionBuilder<S, E>
}
@Override
protected StateMachineTransitions<S, E> performBuild() throws Exception {
return new StateMachineTransitions<S, E>(transitionData, choices, forks, joins);
protected TransitionsData<S, E> performBuild() throws Exception {
return new TransitionsData<S, E>(transitionData, choices, forks, joins);
}
@Override
@@ -116,7 +116,7 @@ public class StateMachineTransitionBuilder<S, E>
// if rule not given, get it from global
if (securityRule == null) {
@SuppressWarnings("unchecked")
StateMachineConfigurationConfig<S, E> config = getSharedObject(StateMachineConfigurationConfig.class);
ConfigurationData<S, E> config = getSharedObject(ConfigurationData.class);
securityRule = config.getTransitionSecurityRule();
}
transitionData.add(new TransitionData<S, E>(source, target, state, event, period, count, actions, guard, kind, securityRule));

12
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineConfiguration.java
View File

@@ -39,9 +39,9 @@ import org.springframework.statemachine.config.builders.StateMachineConfigurer;
import org.springframework.statemachine.config.common.annotation.AbstractImportingAnnotationConfiguration;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurer;
import org.springframework.statemachine.config.model.DefaultStateMachineModel;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.config.model.TransitionsData;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
@@ -142,9 +142,9 @@ public class StateMachineConfiguration<S, E> extends
}
}
StateMachineConfig<S, E> stateMachineConfig = getBuilder().getOrBuild();
StateMachineTransitions<S, E> stateMachineTransitions = stateMachineConfig.getTransitions();
StateMachineStates<S, E> stateMachineStates = stateMachineConfig.getStates();
StateMachineConfigurationConfig<S, E> stateMachineConfigurationConfig = stateMachineConfig.getStateMachineConfigurationConfig();
TransitionsData<S, E> stateMachineTransitions = stateMachineConfig.getTransitions();
StatesData<S, E> stateMachineStates = stateMachineConfig.getStates();
ConfigurationData<S, E> stateMachineConfigurationConfig = stateMachineConfig.getStateMachineConfigurationConfig();
ObjectStateMachineFactory<S, E> stateMachineFactory = new ObjectStateMachineFactory<S, E>(
new DefaultStateMachineModel<S, E>(stateMachineConfigurationConfig, stateMachineStates, stateMachineTransitions));
stateMachineFactory.setBeanFactory(getBeanFactory());

12
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineFactoryConfiguration.java
View File

@@ -40,9 +40,9 @@ import org.springframework.statemachine.config.builders.StateMachineConfigBuilde
import org.springframework.statemachine.config.common.annotation.AbstractImportingAnnotationConfiguration;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurer;
import org.springframework.statemachine.config.model.DefaultStateMachineModel;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.config.model.TransitionsData;
import org.springframework.util.ClassUtils;
/**
@@ -130,9 +130,9 @@ public class StateMachineFactoryConfiguration<S, E> extends
}
}
StateMachineConfig<S, E> stateMachineConfig = builder.getOrBuild();
StateMachineTransitions<S, E> stateMachineTransitions = stateMachineConfig.getTransitions();
StateMachineStates<S, E> stateMachineStates = stateMachineConfig.getStates();
StateMachineConfigurationConfig<S, E> stateMachineConfigurationConfig = stateMachineConfig
TransitionsData<S, E> stateMachineTransitions = stateMachineConfig.getTransitions();
StatesData<S, E> stateMachineStates = stateMachineConfig.getStates();
ConfigurationData<S, E> stateMachineConfigurationConfig = stateMachineConfig
.getStateMachineConfigurationConfig();
ObjectStateMachineFactory<S, E> objectStateMachineFactory = new ObjectStateMachineFactory<S, E>(
new DefaultStateMachineModel<S, E>(stateMachineConfigurationConfig, stateMachineStates, stateMachineTransitions));

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/AbstractTransitionConfigurer.java
View File

@@ -22,7 +22,7 @@ import org.springframework.statemachine.action.Action;
import org.springframework.statemachine.config.builders.StateMachineTransitionBuilder;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.TransitionsData;
import org.springframework.statemachine.guard.Guard;
import org.springframework.statemachine.security.SecurityRule;
import org.springframework.statemachine.security.SecurityRule.ComparisonType;
@@ -36,7 +36,7 @@ import org.springframework.statemachine.security.SecurityRule.ComparisonType;
* @param <E> the type of event
*/
public abstract class AbstractTransitionConfigurer<S, E> extends
AnnotationConfigurerAdapter<StateMachineTransitions<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>> {
AnnotationConfigurerAdapter<TransitionsData<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>> {
private S source;
private S target;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/DefaultChoiceTransitionConfigurer.java
View File

@@ -22,7 +22,7 @@ import org.springframework.statemachine.config.builders.StateMachineTransitionBu
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.ChoiceData;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.TransitionsData;
import org.springframework.statemachine.guard.Guard;
/**
@@ -34,7 +34,7 @@ import org.springframework.statemachine.guard.Guard;
* @param <E> the type of event
*/
public class DefaultChoiceTransitionConfigurer<S, E>
extends AnnotationConfigurerAdapter<StateMachineTransitions<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>>
extends AnnotationConfigurerAdapter<TransitionsData<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>>
implements ChoiceTransitionConfigurer<S, E> {
private S source;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/DefaultConfigurationConfigurer.java
View File

@@ -24,7 +24,7 @@ import org.springframework.scheduling.TaskScheduler;
import org.springframework.statemachine.config.builders.StateMachineConfigurationBuilder;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.listener.StateMachineListener;
/**
@@ -36,7 +36,7 @@ import org.springframework.statemachine.listener.StateMachineListener;
* @param <E> the type of event
*/
public class DefaultConfigurationConfigurer<S, E>
extends AnnotationConfigurerAdapter<StateMachineConfigurationConfig<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
extends AnnotationConfigurerAdapter<ConfigurationData<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
implements ConfigurationConfigurer<S, E> {
private BeanFactory beanFactory;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/DefaultDistributedStateMachineConfigurer.java
View File

@@ -18,7 +18,7 @@ package org.springframework.statemachine.config.configurers;
import org.springframework.statemachine.config.builders.StateMachineConfigurationBuilder;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.ensemble.StateMachineEnsemble;
/**
@@ -30,7 +30,7 @@ import org.springframework.statemachine.ensemble.StateMachineEnsemble;
* @param <E> the type of event
*/
public class DefaultDistributedStateMachineConfigurer<S, E>
extends AnnotationConfigurerAdapter<StateMachineConfigurationConfig<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
extends AnnotationConfigurerAdapter<ConfigurationData<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
implements DistributedStateMachineConfigurer<S, E> {
private StateMachineEnsemble<S, E> ensemble;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/DefaultForkTransitionConfigurer.java
View File

@@ -21,7 +21,7 @@ import java.util.List;
import org.springframework.statemachine.config.builders.StateMachineTransitionBuilder;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.TransitionsData;
/**
* Default implementation of a {@link ForkTransitionConfigurer}.
@@ -32,7 +32,7 @@ import org.springframework.statemachine.config.model.StateMachineTransitions;
* @param <E> the type of event
*/
public class DefaultForkTransitionConfigurer<S, E>
extends AnnotationConfigurerAdapter<StateMachineTransitions<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>>
extends AnnotationConfigurerAdapter<TransitionsData<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>>
implements ForkTransitionConfigurer<S, E> {
private S source;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/DefaultJoinTransitionConfigurer.java
View File

@@ -22,7 +22,7 @@ import java.util.List;
import org.springframework.statemachine.config.builders.StateMachineTransitionBuilder;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.TransitionsData;
/**
* Default implementation of a {@link JoinTransitionConfigurer}.
@@ -33,7 +33,7 @@ import org.springframework.statemachine.config.model.StateMachineTransitions;
* @param <E> the type of event
*/
public class DefaultJoinTransitionConfigurer<S, E>
extends AnnotationConfigurerAdapter<StateMachineTransitions<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>>
extends AnnotationConfigurerAdapter<TransitionsData<S, E>, StateMachineTransitionConfigurer<S, E>, StateMachineTransitionBuilder<S, E>>
implements JoinTransitionConfigurer<S, E> {
private S target;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/DefaultSecurityConfigurer.java
View File

@@ -19,7 +19,7 @@ import org.springframework.security.access.AccessDecisionManager;
import org.springframework.statemachine.config.builders.StateMachineConfigurationBuilder;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.security.SecurityRule;
import org.springframework.statemachine.security.SecurityRule.ComparisonType;
@@ -32,7 +32,7 @@ import org.springframework.statemachine.security.SecurityRule.ComparisonType;
* @param <E> the type of event
*/
public class DefaultSecurityConfigurer<S, E>
extends AnnotationConfigurerAdapter<StateMachineConfigurationConfig<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
extends AnnotationConfigurerAdapter<ConfigurationData<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
implements SecurityConfigurer<S, E> {
private boolean enabled = true;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/DefaultStateConfigurer.java
View File

@@ -28,7 +28,7 @@ import org.springframework.statemachine.config.builders.StateMachineStateBuilder
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.StateData;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.state.PseudoStateKind;
/**
@@ -40,7 +40,7 @@ import org.springframework.statemachine.state.PseudoStateKind;
* @param <E> the type of event
*/
public class DefaultStateConfigurer<S, E>
extends AnnotationConfigurerAdapter<StateMachineStates<S, E>, StateMachineStateConfigurer<S, E>, StateMachineStateBuilder<S, E>>
extends AnnotationConfigurerAdapter<StatesData<S, E>, StateMachineStateConfigurer<S, E>, StateMachineStateBuilder<S, E>>
implements StateConfigurer<S, E> {
private Object parent;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configurers/DefaultVerifierConfigurer.java
View File

@@ -18,7 +18,7 @@ package org.springframework.statemachine.config.configurers;
import org.springframework.statemachine.config.builders.StateMachineConfigurationBuilder;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.common.annotation.AnnotationConfigurerAdapter;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.verifier.CompositeStateMachineModelVerifier;
import org.springframework.statemachine.config.model.verifier.StateMachineModelVerifier;
@@ -31,7 +31,7 @@ import org.springframework.statemachine.config.model.verifier.StateMachineModelV
* @param <E> the type of event
*/
public class DefaultVerifierConfigurer <S, E>
extends AnnotationConfigurerAdapter<StateMachineConfigurationConfig<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
extends AnnotationConfigurerAdapter<ConfigurationData<S, E>, StateMachineConfigurationConfigurer<S, E>, StateMachineConfigurationBuilder<S, E>>
implements VerifierConfigurer<S, E> {
private boolean enabled = true;

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/StateMachineConfigurationConfig.java → spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/ConfigurationData.java
View File

@@ -35,7 +35,7 @@ import org.springframework.statemachine.security.SecurityRule;
* @param <S> the type of state
* @param <E> the type of event
*/
public class StateMachineConfigurationConfig<S, E> {
public class ConfigurationData<S, E> {
private final BeanFactory beanFactory;
private final TaskExecutor taskExecutor;
@@ -68,7 +68,7 @@ public class StateMachineConfigurationConfig<S, E> {
* @param verifierEnabled the verifier enabled flag
* @param verifier the state machine model verifier
*/
public StateMachineConfigurationConfig(BeanFactory beanFactory, TaskExecutor taskExecutor,
public ConfigurationData(BeanFactory beanFactory, TaskExecutor taskExecutor,
TaskScheduler taskScheduler, boolean autoStart, StateMachineEnsemble<S, E> ensemble,
List<StateMachineListener<S, E>> listeners, boolean securityEnabled,
AccessDecisionManager transitionSecurityAccessDecisionManager, AccessDecisionManager eventSecurityAccessDecisionManager,

33
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/DefaultStateMachineModel.java
View File

@@ -15,6 +15,8 @@
*/
package org.springframework.statemachine.config.model;
import org.springframework.util.Assert;
/**
* Default implementation of a {@link StateMachineModel}.
*
@@ -25,36 +27,39 @@ package org.springframework.statemachine.config.model;
*/
public class DefaultStateMachineModel<S, E> extends StateMachineModel<S, E> {
private final StateMachineConfigurationConfig<S, E> configuration;
private final StateMachineStates<S, E> states;
private final StateMachineTransitions<S, E> transitions;
private final ConfigurationData<S, E> configuration;
private final StatesData<S, E> states;
private final TransitionsData<S, E> transitions;
/**
* Instantiates a new default state machine model.
*
* @param configuration the configuration
* @param states the states
* @param transitions the transitions
* @param configurationData the configuration
* @param statesData the states
* @param transitionsData the transitions
*/
public DefaultStateMachineModel(StateMachineConfigurationConfig<S, E> configuration, StateMachineStates<S, E> states,
StateMachineTransitions<S, E> transitions) {
this.configuration = configuration;
this.states = states;
this.transitions = transitions;
public DefaultStateMachineModel(ConfigurationData<S, E> configurationData, StatesData<S, E> statesData,
TransitionsData<S, E> transitionsData) {
Assert.notNull(configurationData, "Configuration must be set");
Assert.notNull(statesData, "States must be set");
Assert.notNull(transitionsData, "Transitions must be set");
this.configuration = configurationData;
this.states = statesData;
this.transitions = transitionsData;
}
@Override
public StateMachineConfigurationConfig<S, E> getConfiguration() {
public ConfigurationData<S, E> getConfigurationData() {
return configuration;
}
@Override
public StateMachineStates<S, E> getStates() {
public StatesData<S, E> getStatesData() {
return states;
}
@Override
public StateMachineTransitions<S, E> getTransitions() {
public TransitionsData<S, E> getTransitionsData() {
return transitions;
}
}

100
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/StateData.java
View File

@@ -45,6 +45,16 @@ public class StateData<S, E> {
private boolean end = false;
private PseudoStateKind pseudoStateKind;
/**
* Instantiates a new state data.
*
* @param parent the parent
* @param region the region
* @param state the state
* @param deferred the deferred
* @param entryActions the entry actions
* @param exitActions the exit actions
*/
public StateData(Object parent, Object region, S state, Collection<E> deferred,
Collection<? extends Action<S, E>> entryActions, Collection<? extends Action<S, E>> exitActions) {
this.state = state;
@@ -55,58 +65,128 @@ public class StateData<S, E> {
this.region = region;
}
/**
* Gets the state.
*
* @return the state
*/
public S getState() {
return state;
}
/**
* Gets the deferred.
*
* @return the deferred
*/
public Collection<E> getDeferred() {
return deferred;
}
/**
* Sets the deferred.
*
* @param deferred the new deferred
*/
public void setDeferred(Collection<E> deferred) {
this.deferred = deferred;
}
/**
* Gets the entry actions.
*
* @return the entry actions
*/
public Collection<? extends Action<S, E>> getEntryActions() {
return entryActions;
}
/**
* Sets the entry actions.
*
* @param entryActions the entry actions
*/
public void setEntryActions(Collection<? extends Action<S, E>> entryActions) {
this.entryActions = entryActions;
}
/**
* Gets the exit actions.
*
* @return the exit actions
*/
public Collection<? extends Action<S, E>> getExitActions() {
return exitActions;
}
/**
* Sets the exit actions.
*
* @param exitActions the exit actions
*/
public void setExitActions(Collection<? extends Action<S, E>> exitActions) {
this.exitActions = exitActions;
}
/**
* Gets the parent.
*
* @return the parent
*/
public Object getParent() {
return parent;
}
/**
* Sets the parent.
*
* @param parent the new parent
*/
public void setParent(Object parent) {
this.parent = parent;
}
/**
* Gets the region.
*
* @return the region
*/
public Object getRegion() {
return region;
}
/**
* Sets the region.
*
* @param region the new region
*/
public void setRegion(Object region) {
this.region = region;
}
/**
* Checks if is initial.
*
* @return true, if is initial
*/
public boolean isInitial() {
return initial;
}
/**
* Sets the initial.
*
* @param initial the new initial
*/
public void setInitial(boolean initial) {
this.initial = initial;
}
/**
* Sets the initial action.
*
* @param action the action
*/
public void setInitialAction(Action<S, E> action) {
this.initialAction = action;
}
@@ -115,18 +195,38 @@ public class StateData<S, E> {
return initialAction;
}
/**
* Checks if is end.
*
* @return true, if is end
*/
public boolean isEnd() {
return end;
}
/**
* Sets the end.
*
* @param end the new end
*/
public void setEnd(boolean end) {
this.end = end;
}
/**
* Gets the pseudo state kind.
*
* @return the pseudo state kind
*/
public PseudoStateKind getPseudoStateKind() {
return pseudoStateKind;
}
/**
* Sets the pseudo state kind.
*
* @param pseudoStateKind the new pseudo state kind
*/
public void setPseudoStateKind(PseudoStateKind pseudoStateKind) {
this.pseudoStateKind = pseudoStateKind;
}

18
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/StateMachineModel.java
View File

@@ -26,23 +26,23 @@ package org.springframework.statemachine.config.model;
public abstract class StateMachineModel<S, E> {
/**
* Gets the configuration config.
* Gets the configuration config data.
*
* @return the configuration config
* @return the configuration config data
*/
public abstract StateMachineConfigurationConfig<S, E> getConfiguration();
public abstract ConfigurationData<S, E> getConfigurationData();
/**
* Gets the states config.
* Gets the states config data.
*
* @return the states config
* @return the states config data
*/
public abstract StateMachineStates<S, E> getStates();
public abstract StatesData<S, E> getStatesData();
/**
* Gets the transitions config.
* Gets the transitions config data.
*
* @return the transitions config
* @return the transitions config data
*/
public abstract StateMachineTransitions<S, E> getTransitions();
public abstract TransitionsData<S, E> getTransitionsData();
}

22
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/StateMachineStates.java → spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/StatesData.java
View File

@@ -27,16 +27,26 @@ import org.springframework.statemachine.config.configurers.StateConfigurer;
* @param <S> the type of state
* @param <E> the type of event
*/
public class StateMachineStates<S, E> {
public class StatesData<S, E> {
private final Collection<StateData<S, E>> stateDatas;
private final Collection<StateData<S, E>> stateData;
public StateMachineStates(Collection<StateData<S, E>> stateDatas) {
this.stateDatas = stateDatas;
/**
* Instantiates a new states data.
*
* @param stateData the state data
*/
public StatesData(Collection<StateData<S, E>> stateData) {
this.stateData = stateData;
}
public Collection<StateData<S, E>> getStateDatas() {
return stateDatas;
/**
* Gets the state data.
*
* @return the state data
*/
public Collection<StateData<S, E>> getStateData() {
return stateData;
}
}

2
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/TransitionData.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016 the original author or authors.
* Copyright 2015-2016 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.

4
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/StateMachineTransitions.java → spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/TransitionsData.java
View File

@@ -27,7 +27,7 @@ import java.util.Map;
* @param <S> the type of state
* @param <E> the type of event
*/
public class StateMachineTransitions<S, E> {
public class TransitionsData<S, E> {
private final Collection<TransitionData<S, E>> transitions;
private final Map<S, List<ChoiceData<S, E>>> choices;
@@ -42,7 +42,7 @@ public class StateMachineTransitions<S, E> {
* @param forks the forks
* @param joins the joins
*/
public StateMachineTransitions(Collection<TransitionData<S, E>> transitions,
public TransitionsData(Collection<TransitionData<S, E>> transitions,
Map<S, List<ChoiceData<S, E>>> choices, Map<S, List<S>> forks, Map<S, List<S>> joins) {
this.transitions = transitions;
this.choices = choices;

10
spring-statemachine-core/src/main/java/org/springframework/statemachine/config/model/verifier/BaseStructureVerifier.java
View File

@@ -20,7 +20,7 @@ import java.util.Iterator;
import org.springframework.statemachine.config.model.MalformedConfigurationException;
import org.springframework.statemachine.config.model.StateData;
import org.springframework.statemachine.config.model.StateMachineModel;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.support.tree.Tree;
import org.springframework.statemachine.support.tree.Tree.Node;
import org.springframework.statemachine.support.tree.TreeTraverser;
@@ -39,12 +39,12 @@ public class BaseStructureVerifier<S, E> implements StateMachineModelVerifier<S,
@Override
public void verify(StateMachineModel<S, E> model) {
// verify that we have transitions
if (model.getTransitions().getTransitions().isEmpty()) {
if (model.getTransitionsData().getTransitions().isEmpty()) {
MalformedConfigurationException exception = new MalformedConfigurationException("Must have at least one transition");
throw exception;
}
// verify that we have initial state
Iterator<Node<StateData<S, E>>> iterator = buildStateDataIterator(model.getStates());
Iterator<Node<StateData<S, E>>> iterator = buildStateDataIterator(model.getStatesData());
while (iterator.hasNext()) {
Node<StateData<S, E>> node = iterator.next();
if (node.getData() == null) {
@@ -66,10 +66,10 @@ public class BaseStructureVerifier<S, E> implements StateMachineModelVerifier<S,
}
}
private Iterator<Node<StateData<S, E>>> buildStateDataIterator(StateMachineStates<S, E> stateMachineStates) {
private Iterator<Node<StateData<S, E>>> buildStateDataIterator(StatesData<S, E> stateMachineStates) {
Tree<StateData<S, E>> tree = new Tree<StateData<S, E>>();
for (StateData<S, E> stateData : stateMachineStates.getStateDatas()) {
for (StateData<S, E> stateData : stateMachineStates.getStateData()) {
Object id = stateData.getState();
Object parent = stateData.getParent();
tree.add(stateData, id, parent);

12
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderTests.java
View File

@@ -36,9 +36,9 @@ import org.springframework.statemachine.config.builders.StateMachineConfigBuilde
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.config.model.DefaultStateMachineModel;
import org.springframework.statemachine.config.model.StateMachineConfigurationConfig;
import org.springframework.statemachine.config.model.StateMachineStates;
import org.springframework.statemachine.config.model.StateMachineTransitions;
import org.springframework.statemachine.config.model.ConfigurationData;
import org.springframework.statemachine.config.model.StatesData;
import org.springframework.statemachine.config.model.TransitionsData;
import org.springframework.statemachine.listener.StateMachineListenerAdapter;
import org.springframework.statemachine.state.State;
@@ -51,9 +51,9 @@ public class ManualBuilderTests {
builder.apply(config);
StateMachineConfig<String, String> stateMachineConfig = builder.getOrBuild();
StateMachineTransitions<String, String> stateMachineTransitions = stateMachineConfig.getTransitions();
StateMachineStates<String, String> stateMachineStates = stateMachineConfig.getStates();
StateMachineConfigurationConfig<String, String> stateMachineConfigurationConfig = stateMachineConfig.getStateMachineConfigurationConfig();
TransitionsData<String, String> stateMachineTransitions = stateMachineConfig.getTransitions();
StatesData<String, String> stateMachineStates = stateMachineConfig.getStates();
ConfigurationData<String, String> stateMachineConfigurationConfig = stateMachineConfig.getStateMachineConfigurationConfig();
ObjectStateMachineFactory<String, String> stateMachineFactory = new ObjectStateMachineFactory<String, String>(
new DefaultStateMachineModel<String, String>(stateMachineConfigurationConfig, stateMachineStates, stateMachineTransitions));

90
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelTests.java Normal file
View File

@@ -0,0 +1,90 @@
/*
* Copyright 2016 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
*
* http://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.config.model;
import static org.hamcrest.Matchers.contains;
import static org.junit.Assert.assertThat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.core.task.SyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.security.access.AccessDecisionManager;
import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.config.ObjectStateMachineFactory;
import org.springframework.statemachine.config.model.verifier.DefaultStateMachineModelVerifier;
import org.springframework.statemachine.config.model.verifier.StateMachineModelVerifier;
import org.springframework.statemachine.ensemble.StateMachineEnsemble;
import org.springframework.statemachine.listener.StateMachineListener;
import org.springframework.statemachine.security.SecurityRule;
import org.springframework.statemachine.transition.TransitionKind;
public class StateMachineModelTests {
@Test
public void testMachineManuallyViaModel() {
BeanFactory beanFactory = null;
TaskExecutor taskExecutor = new SyncTaskExecutor();
TaskScheduler taskScheduler = null;
boolean autoStart = false;
StateMachineEnsemble<String, String> ensemble = null;
List<StateMachineListener<String, String>> listeners = new ArrayList<>();
boolean securityEnabled = false;
AccessDecisionManager transitionSecurityAccessDecisionManager = null;
AccessDecisionManager eventSecurityAccessDecisionManager = null;
SecurityRule eventSecurityRule = null;
SecurityRule transitionSecurityRule = null;
boolean verifierEnabled = true;
StateMachineModelVerifier<String, String> verifier = new DefaultStateMachineModelVerifier<>();
ConfigurationData<String, String> configurationData = new ConfigurationData<>(beanFactory, taskExecutor, taskScheduler, autoStart,
ensemble, listeners, securityEnabled, transitionSecurityAccessDecisionManager, eventSecurityAccessDecisionManager,
eventSecurityRule, transitionSecurityRule, verifierEnabled, verifier);
Collection<StateData<String, String>> stateData = new ArrayList<>();
StateData<String, String> stateData1 = new StateData<String, String>(null, null, "S1", null, null, null);
stateData1.setInitial(true);
stateData.add(stateData1);
StateData<String, String> stateData2 = new StateData<String, String>(null, null, "S2", null, null, null);
stateData.add(stateData2);
StatesData<String, String> statesData = new StatesData<>(stateData);
Collection<TransitionData<String, String>> transitions = new ArrayList<>();
TransitionData<String, String> transitionData1 = new TransitionData<String, String>("S1", "S2", null, "E1", null, null, null, null, TransitionKind.EXTERNAL, null);
transitions.add(transitionData1);
Map<String, List<ChoiceData<String, String>>> choices = new HashMap<>();
Map<String, List<String>> forks = new HashMap<>();
Map<String, List<String>> joins = new HashMap<>();
TransitionsData<String, String> transitionsData = new TransitionsData<>(transitions, choices, forks, joins);
StateMachineModel<String, String> stateMachineModel = new DefaultStateMachineModel<>(configurationData, statesData, transitionsData);
ObjectStateMachineFactory<String, String> factory = new ObjectStateMachineFactory<>(stateMachineModel);
StateMachine<String,String> stateMachine = factory.getStateMachine();
stateMachine.start();
assertThat(stateMachine.getState().getIds(), contains("S1"));
stateMachine.sendEvent("E1");
assertThat(stateMachine.getState().getIds(), contains("S2"));
}
}