ModelStateSimplifier.java

package edu.udel.cis.vsl.tass.state.impl;

import edu.udel.cis.vsl.tass.dynamic.IF.DynamicException;
import edu.udel.cis.vsl.tass.dynamic.IF.DynamicFactoryIF;
import edu.udel.cis.vsl.tass.dynamic.IF.simplify.DynamicSimplifierIF;
import edu.udel.cis.vsl.tass.dynamic.IF.simplify.MorphicSimplifierIF;
import edu.udel.cis.vsl.tass.dynamic.IF.value.MessageIF;
import edu.udel.cis.vsl.tass.dynamic.IF.value.ValueIF;
import edu.udel.cis.vsl.tass.dynamic.impl.simplify.MorphicSimplifier;
import edu.udel.cis.vsl.tass.morph.MorphicArray;
import edu.udel.cis.vsl.tass.morph.MorphicVector;
import edu.udel.cis.vsl.tass.state.IF.ModelStateFactoryIF;
import edu.udel.cis.vsl.tass.state.IF.ModelStateIF;
import edu.udel.cis.vsl.tass.state.IF.ProcessStateIF;

public class ModelStateSimplifier extends MorphicSimplifier<ModelStateIF> {

	private ModelStateFactoryIF modelStateFactory;

	private DynamicFactoryIF dynamicFactory;

	private MorphicSimplifierIF<ProcessStateIF> processStateSimplifier;

	private MorphicSimplifierIF<MorphicArray<ProcessStateIF>> processStateArraySimplifier;

	public ModelStateSimplifier(ModelStateFactoryIF modelStateFactory) {
		this.modelStateFactory = modelStateFactory;
		this.dynamicFactory = modelStateFactory.dynamicFactory();
		this.processStateSimplifier = modelStateFactory.processStateFactory()
				.simplifier();
		this.processStateArraySimplifier = dynamicFactory.newArraySimplifier(
				modelStateFactory.processStateArrayFactory(),
				processStateSimplifier);
	}

	@Override
	public ModelStateIF simplify(DynamicSimplifierIF dynamicSimplifier,
			ModelStateIF state)  throws DynamicException {
		state = modelStateFactory.canonic(state);

		ModelStateIF result = (ModelStateIF) dynamicSimplifier
				.getCachedResult(state);

		if (result != null)
			return result;

		MorphicArray<ValueIF> oldSharedValues = state.sharedValues();
		MorphicArray<ValueIF> newSharedValues = dynamicFactory
				.simplifyValueArray(dynamicSimplifier, oldSharedValues);
		MorphicVector<MessageIF> oldBuffer = state.buffer();
		MorphicVector<MessageIF> newBuffer = dynamicFactory
				.simplifyMessageVector(dynamicSimplifier, oldBuffer);
		MorphicArray<ProcessStateIF> oldProcessStates = state.processStates();
		MorphicArray<ProcessStateIF> newProcessStates = processStateArraySimplifier
				.simplify(dynamicSimplifier, oldProcessStates);

		if (newSharedValues != oldSharedValues || newBuffer != oldBuffer
				|| newProcessStates != oldProcessStates) {
			result = modelStateFactory.newState(newProcessStates,
					newSharedValues, newBuffer);
			result = modelStateFactory.canonic(result);
		} else {
			result = state;
		}
		dynamicSimplifier.cacheResult(state, result);
		return result;
	}

	public MorphicSimplifierIF<ProcessStateIF> processStateSimplifier() {
		return processStateSimplifier;
	}

	public MorphicSimplifierIF<MorphicArray<ProcessStateIF>> processStateArraySimplifier() {
		return processStateArraySimplifier;
	}

}