ProcessStateSimplifier.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.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.morph.MorphicVectorFactory;
import edu.udel.cis.vsl.tass.state.IF.FrameIF;
import edu.udel.cis.vsl.tass.state.IF.ProcessStateIF;

public class ProcessStateSimplifier extends MorphicSimplifier<ProcessStateIF> {

	private DynamicFactoryIF dynamicFactory;

	private FrameFactory frameFactory;

	private FrameSimplifier frameSimplifier;

	private MorphicVectorFactory<FrameIF> stackFactory;

	private MorphicSimplifierIF<MorphicVector<FrameIF>> stackSimplifier;

	private ProcessStateFactory processStateFactory;

	public ProcessStateSimplifier(ProcessStateFactory processStateFactory) {
		this.dynamicFactory = processStateFactory.dynamicFactory();
		this.processStateFactory = processStateFactory;
		this.stackFactory = processStateFactory.stackFactory();
		this.frameFactory = processStateFactory.frameFactory();
		this.frameSimplifier = frameFactory.simplifier();
		this.stackSimplifier = dynamicFactory.newVectorSimplifier(stackFactory,
				frameSimplifier);
	}

	public DynamicFactoryIF dynamicFactory() {
		return dynamicFactory;
	}

	public FrameFactory frameFactory() {
		return frameFactory;
	}

	public FrameSimplifier frameSimplifier() {
		return frameSimplifier;
	}

	public MorphicVectorFactory<FrameIF> stackFactory() {
		return stackFactory;
	}

	public ProcessStateFactory processStateFactory() {
		return processStateFactory;
	}

	public MorphicSimplifierIF<MorphicVector<FrameIF>> stackSimplifier() {
		return stackSimplifier;
	}

	@Override
	public ProcessStateIF simplify(DynamicSimplifierIF dynamicSimplifier,
			ProcessStateIF processState) throws DynamicException {
		if (processState == null)
			return null;

		processState = processStateFactory.canonic(processState);

		ProcessStateIF result = (ProcessStateIF) dynamicSimplifier
				.getCachedResult(processState);

		if (result != null)
			return result;

		MorphicArray<ValueIF> oldGlobalValues = processState.globalValues();
		MorphicArray<ValueIF> newGlobalValues = dynamicFactory
				.simplifyValueArray(dynamicSimplifier, oldGlobalValues);
		MorphicVector<ValueIF> oldHeap = processState.heap();
		MorphicVector<ValueIF> newHeap = dynamicFactory.simplifyValueVector(
				dynamicSimplifier, oldHeap);
		MorphicVector<FrameIF> oldStack = processState.stack();
		MorphicVector<FrameIF> newStack = stackSimplifier.simplify(
				dynamicSimplifier, oldStack);

		if (newGlobalValues != oldGlobalValues || newHeap != oldHeap
				|| newStack != oldStack) {
			result = processStateFactory.processState(newGlobalValues, newHeap,
					newStack);
			result = processStateFactory.canonic(result);
		} else {
			result = processState;
		}
		dynamicSimplifier.cacheResult(processState, result);
		return result;
	}

	public FrameIF simplifyFrame(DynamicSimplifierIF dynamicSimplifier,
			FrameIF frame) throws DynamicException {
		return frameSimplifier.simplify(dynamicSimplifier, frame);
	}

	public MorphicVector<FrameIF> simplifyStack(
			DynamicSimplifierIF dynamicSimplifier, MorphicVector<FrameIF> stack)
			throws DynamicException {
		return stackSimplifier.simplify(dynamicSimplifier, stack);
	}
}