ProcessStateFactory.java

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

import edu.udel.cis.vsl.tass.dynamic.IF.DynamicFactoryIF;
import edu.udel.cis.vsl.tass.dynamic.IF.value.ValueIF;
import edu.udel.cis.vsl.tass.morph.MorphicArray;
import edu.udel.cis.vsl.tass.morph.MorphicArrayFactory;
import edu.udel.cis.vsl.tass.morph.MorphicFactory;
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 ProcessStateFactory extends MorphicFactory<ProcessStateIF> {

	private MorphicArrayFactory<ValueIF> globalFactory;

	private MorphicVectorFactory<ValueIF> heapFactory;

	private MorphicVectorFactory<FrameIF> stackFactory;

	private DynamicFactoryIF dynamicFactory;

	private FrameFactory frameFactory;

	/** Number of instantiations of ProcessState objects. */
	private int instanceCounter = 0;

	ProcessStateFactory(FrameFactory frameFactory) {
		this.dynamicFactory = frameFactory.dynamicFactory();
		this.frameFactory = frameFactory;
		this.globalFactory = dynamicFactory.valueArrayFactory();
		this.heapFactory = dynamicFactory.valueVectorFactory();
		this.stackFactory = new MorphicVectorFactory<FrameIF>(frameFactory);
	}

	public ProcessStateSimplifier simplifier() {
		return new ProcessStateSimplifier(this);
	}

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

	public FrameFactory frameFactory() {
		return frameFactory;
	}

	public DynamicFactoryIF dynamicFactory() {
		return dynamicFactory;
	}

	ProcessState processState(MorphicArray<ValueIF> globalValues,
			MorphicVector<ValueIF> heap, MorphicVector<FrameIF> stack) {
		ProcessState processState = new ProcessState(instanceCounter,
				globalValues, heap, stack);

		instanceCounter++;
		return processState;
	}

	public void canonicalizeChildren(ProcessStateIF processState) {
		((ProcessState) processState).canonicalizeChildren(globalFactory,
				heapFactory, stackFactory);
	}

	@Override
	public ProcessStateIF canonic(ProcessStateIF processState) {
		ProcessStateIF result = super.canonic(processState);

		if (result.canonicalId() < 0) {
			((ProcessState) result).setCanonicalId(this.numStored() - 1);
		}
		return result;
	}
}