cz.wicketstuff.boss.flow.processor.basic.SimpleFlowProcessor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of boss-flow Show documentation
Workflow control and configuration java framework
There is a newer version: 1.3.1
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 cz.wicketstuff.boss.flow.processor.basic;

import java.io.Serializable;

import cz.wicketstuff.boss.flow.FlowException;
import cz.wicketstuff.boss.flow.model.IFlowCarter;
import cz.wicketstuff.boss.flow.model.IFlowState;
import cz.wicketstuff.boss.flow.model.IFlowTransition;
import cz.wicketstuff.boss.flow.processor.FlowPersistingException;
import cz.wicketstuff.boss.flow.processor.IFlowCarterFactory;
import cz.wicketstuff.boss.flow.processor.IFlowStateChangeListener;
import cz.wicketstuff.boss.flow.processor.IFlowStateDataFactory;
import cz.wicketstuff.boss.flow.processor.IFlowStatePersister;
import cz.wicketstuff.boss.flow.processor.IFlowStateProcessor;
import cz.wicketstuff.boss.flow.processor.IFlowStateResolver;
import cz.wicketstuff.boss.flow.processor.IFlowStateValidationListener;
import cz.wicketstuff.boss.flow.processor.IFlowTransitionChangeListener;
import cz.wicketstuff.boss.flow.processor.IFlowTransitionResolver;
import cz.wicketstuff.boss.flow.processor.NoSuchStateException;
import cz.wicketstuff.boss.flow.processor.NoSuchTransitionException;
import cz.wicketstuff.boss.flow.processor.StateDataException;
import cz.wicketstuff.boss.flow.util.Comparators;
import cz.wicketstuff.boss.flow.util.listener.IPriority;
import cz.wicketstuff.boss.flow.validation.IFlowStateValidator;
import cz.wicketstuff.boss.flow.validation.IFlowValidation;

public class SimpleFlowProcessor extends AbstractFlowProcessor {

	private static final long serialVersionUID = 1L;
	
	private Integer flowId;
	private String flowName;
	private IFlowState defaultInitialState;
	
	private IFlowCarterFactory carterFactory;
	private IFlowStateDataFactory stateDataFactory;
	
	private IFlowStateProcessor stateProcessor;
	private IFlowStateValidator stateValidator;
	
	private IFlowStateChangeListener stateChangeListener;
	private IFlowTransitionChangeListener transitionChangeListener;
	private IFlowStateValidationListener stateValidationListener;
	
	private IFlowStateResolver stateResolver;
	private IFlowTransitionResolver transitionResolver;
	
	private IFlowStatePersister flowStatePersister;
	
	private int priority = 0;
	
	public SimpleFlowProcessor() {
		super();
	}

	@Override
	public IFlowCarter initFlow(Long flowProcessId, T payload, String initialStateName) throws FlowException {
		return initFlow(flowProcessId, payload, getStateResolver().resolveState(initialStateName));
	}

	@Override
	public boolean invokeTransition(IFlowCarter flow, String transitionName)
			throws FlowException {
		return invokeTransition(flow, resolveTransition(flow, transitionName));
	}


	@Override
	public Integer getFlowId() {
		return flowId;
	}

	public void setFlowId(Integer flowId) {
		this.flowId = flowId;
	}

	@Override
	public String getFlowName() {
		return flowName;
	}

	public void setFlowName(String flowName) {
		this.flowName = flowName;
	}

	@Override
	public IFlowState getDefaultInitialState() {
		return defaultInitialState;
	}
	
	public void setDefaultInitialState(IFlowState defaultInitialState) {
		this.defaultInitialState = defaultInitialState;
	}

	@Override
	public IFlowCarter createFlowCarter(Long flowProcessId, IFlowState initialState) throws FlowException {
		return getCarterFactory().createFlowCarter(flowProcessId, initialState);
	}

	@Override
	public IFlowValidation validateState(IFlowCarter flow) {
		return getStateValidator().validateState(flow);
	}
	
	@Override
	public void processState(IFlowCarter flow) throws FlowException {
		getStateProcessor().processState(flow);
		
	}

	@Override
	public void onStateValid(IFlowCarter flow) {
		if(getStateValidationListener() != null)
			getStateValidationListener().onStateValid(flow);
	}

	@Override
	public void onStateInvalid(IFlowCarter flow) {
		if(getStateValidationListener() != null)
			getStateValidationListener().onStateInvalid(flow);
		
	}

	@Override
	public void onTransitionStart(IFlowCarter flow) {
		if(getTransitionChangeListener() != null)
			getTransitionChangeListener().onTransitionStart(flow);
	}

	@Override
	public void onTransitionFinished(IFlowCarter flow) {
		if(getTransitionChangeListener() != null)
			getTransitionChangeListener().onTransitionFinished(flow);
	}

	@Override
	public void onStateEntry(IFlowCarter flow) {
		if(getStateChangeListener() != null)
			getStateChangeListener().onStateEntry(flow);
	}

	@Override
	public void onStateLeaving(IFlowCarter flow) {
		if(getStateChangeListener() != null)
			getStateChangeListener().onStateLeaving(flow);
	}

	@Override
	public IFlowState resolveState(String stateName)
			throws NoSuchStateException {
		return getStateResolver().resolveState(stateName);
	}

	@Override
	public IFlowTransition resolveTransition(IFlowCarter flow, String transitionName)
			throws NoSuchTransitionException {
		return getTransitionResolver().resolveTransition(flow, transitionName);
	}

	public IFlowStateChangeListener getStateChangeListener() {
		return stateChangeListener;
	}

	public void setStateChangeListener(
			IFlowStateChangeListener stateChangeListener) {
		this.stateChangeListener = stateChangeListener;
	}

	public IFlowTransitionChangeListener getTransitionChangeListener() {
		return transitionChangeListener;
	}

	public void setTransitionChangeListener(
			IFlowTransitionChangeListener transitionChangeListener) {
		this.transitionChangeListener = transitionChangeListener;
	}

	public IFlowStateValidationListener getStateValidationListener() {
		return stateValidationListener;
	}

	public void setStateValidationListener(
			IFlowStateValidationListener stateValidationListener) {
		this.stateValidationListener = stateValidationListener;
	}

	public IFlowStateProcessor getStateProcessor() {
		return stateProcessor;
	}

	public void setStateProcessor(IFlowStateProcessor stateProcessor) {
		this.stateProcessor = stateProcessor;
	}

	public IFlowStateValidator getStateValidator() {
		return stateValidator;
	}

	public void setStateValidator(IFlowStateValidator stateValidator) {
		this.stateValidator = stateValidator;
	}

	@Override
	public Serializable createStateData(IFlowState flowState)
			throws NoSuchStateException, StateDataException {
		return getStateDataFactory().createStateData(flowState);
	}

	public IFlowStateDataFactory getStateDataFactory() {
		return stateDataFactory;
	}

	public void setStateDataFactory(IFlowStateDataFactory stateDataFactory) {
		this.stateDataFactory = stateDataFactory;
	}

	public IFlowCarterFactory getCarterFactory() {
		return carterFactory;
	}

	public void setCarterFactory(IFlowCarterFactory carterFactory) {
		this.carterFactory = carterFactory;
	}

	public IFlowStateResolver getStateResolver() {
		return stateResolver;
	}

	public void setStateResolver(IFlowStateResolver stateResolver) {
		this.stateResolver = stateResolver;
	}

	public IFlowTransitionResolver getTransitionResolver() {
		return transitionResolver;
	}

	public void setTransitionResolver(IFlowTransitionResolver transitionResolver) {
		this.transitionResolver = transitionResolver;
	}
	
	public String getDefaultInitialStateName() {
		return getDefaultInitialState().getStateName();
	}

	public void setDefaultInitialStateName(String defaultInitialStateName) throws NoSuchStateException {
		setDefaultInitialState(getStateResolver().resolveState(defaultInitialStateName));
	}
	
	public IFlowStatePersister getFlowStatePersister() {
		return flowStatePersister;
	}

	public void setFlowStatePersister(IFlowStatePersister flowStatePersister) {
		this.flowStatePersister = flowStatePersister;
	}

	@Override
	protected void finalize() throws Throwable {
		carterFactory = null;
		defaultInitialState = null;
		stateChangeListener = null;
		stateDataFactory = null;
		stateProcessor = null;
		stateResolver = null;
		stateValidationListener = null;
		stateValidator = null;
		transitionChangeListener = null;
		transitionResolver = null;
		super.finalize();
	}

	@Override
	public int compareTo(IPriority o) {
		return Comparators.compareInts(priority, o.getPriority());
	}

	@Override
	public int getPriority() {
		return priority;
	}

	public void setPriority(int priority) {
		this.priority = priority;
	}

	public void onFlowInitialized(IFlowCarter flow) {
		
	}

	@Override
	public void persistFlowState(IFlowCarter flow) throws FlowPersistingException {
		IFlowStatePersister p = getFlowStatePersister();
		if(p != null) {
			p.persistFlowState(flow);
		}		
	}

}