praktikum-holons/src/holeg/model/HolonSwitch.java

package holeg.model;

import java.util.LinkedList;
import java.util.ListIterator;

import com.google.gson.annotations.Expose;

import holeg.interfaces.LocalMode;
import holeg.interfaces.TimelineDependent;
import holeg.ui.controller.IndexTranslator;
import holeg.utility.math.vector.Vec2f;

/**
 * The class HolonSwitch represents an Object in the system, that has the
 * capacity of manipulate the electricity flow. The switch can be manage
 * automatically through a graph or direct manually.
 * 
 * @author Gruppe14
 *
 */
public class HolonSwitch extends AbstractCanvasObject implements TimelineDependent {

	
	public enum SwitchState {
		Open, Closed;
		public static SwitchState opposite(SwitchState state) {
			switch(state) {
			case Closed:
				return Open;
			case Open:
			default:
				return Closed;
			}
		}
		public boolean isOpen() {
			return this == Open;
		}
		public boolean isClosed() {
			return this == Closed;
		}
	}

	public enum SwitchMode {
		Manual, Auto
	}

	@Expose
	private SwitchMode mode = SwitchMode.Auto;
	@Expose
	private SwitchState manualState = SwitchState.Closed;
	@Expose
	private int localPeriod;
	@Expose
	boolean localPeriodActive = false;

	
	
	
	
	/**
	 * Energy at each point of the graph with 50 predefined points. At the
	 * beginning, it starts with all values at energy
	 */
	boolean[] activeAt = new boolean[LocalMode.STANDARD_GRAPH_ACCURACY];
	/** Points on the UnitGraph */
	LinkedList<Vec2f> graphPoints = new LinkedList<>();

	/**
	 * Create a new HolonSwitch with a custom name, a default value of automatic
	 * handle and active status.
	 * 
	 * @param name String
	 */
	public HolonSwitch(String name) {
		super(name);
		initGraphPoints();
		sampleGraph();
	}

	/**
	 * Create a copy of an existing HolonSwitch.
	 * 
	 * @param other the Object to copy
	 */
	public HolonSwitch(HolonSwitch other) {
		super(other);
		setLocalPeriod(other.getLocalPeriod());
		setUseLocalPeriod(other.isUsingLocalPeriod());
		activeAt = new boolean[LocalMode.STANDARD_GRAPH_ACCURACY];
		setName(other.getName());
		for (Vec2f p : other.getGraphPoints()) {
			this.graphPoints.add(new Vec2f(p.getX(), p.getY()));
		}
		sampleGraph();
	}

	@Override
	public void initForReflection() {
		this.graphPoints = new LinkedList<>();
		this.reset();
	}

	/**
	 * Calculates the state of the Switch.
	 */
	public void flipManualState() {
		manualState = SwitchState.opposite(manualState);
	}
	
	/*
	 * STATE
	 */
	
	private SwitchState state;
	public void calculateState(int timestep) {
		switch (mode) {
		case Auto:
			state = activeAt[IndexTranslator.getEffectiveIndex(this, timestep)] ? SwitchState.Open : SwitchState.Closed;
		case Manual:
		default:
			state =  manualState;
		}
	}
	public SwitchState getState() {
		return state;
	}
	
	/**
	 * For automatic use only (through the graph).
	 * 
	 * @return the Graph Points
	 */
	public LinkedList<Vec2f> getGraphPoints() {
		return graphPoints;
	}

	/**
	 * Set the values of the switch in the graph (auto. mode only).
	 * 
	 * @param linkedList the Graph points
	 */
	public void setGraphPoints(LinkedList<Vec2f> linkedList) {
		this.graphPoints = linkedList;
	}

	/**
	 * Initialize the Graph as a closed Switch.
	 */
	private void initGraphPoints() {
		graphPoints.clear();
		graphPoints.add(new Vec2f(0, 1));
		graphPoints.add(new Vec2f(1, 1));
	}

	public SwitchMode getMode() {
		return mode;
	}

	public void setMode(SwitchMode mode) {
		this.mode = mode;
	}

	public SwitchState getManualState() {
		return manualState;
	}

	public void setManualState(SwitchState manuelState) {
		this.manualState = manuelState;
	}

	// interfaces.GraphEditable
	@Override
	public GraphType getGraphType() {
		return GraphType.boolGraph;
	}

	@Override
	public LinkedList<Vec2f> getStateGraph() {
		return graphPoints;
	}

	@Override
	public void reset() {
		initGraphPoints();
		sampleGraph();
	}

	@Override
	public void sampleGraph() {
		activeAt = sampleGraph(100);
	}

	/**
	 * Generate out of the Graph Points a array of boolean that represent the
	 * Curve("on or off"-Graph) at each sample position. The Values are in the Range
	 * [0,1].
	 * 
	 * @param sampleLength amount of samplePositions. The positions are equidistant
	 *                     on the Range[0,1].
	 * @return the boolean array of samplepoints.
	 */
	private boolean[] sampleGraph(int sampleLength) {
		ListIterator<Vec2f> iter = this.graphPoints.listIterator();
		Vec2f before = iter.next();
		Vec2f after = iter.next();
		boolean[] activeTriggerPos = new boolean[sampleLength];
		for (int i = 0; i < sampleLength; i++) {
			double graphX = (double) i / (double) (sampleLength - 1); // from 0.0 to 1.0
			if (graphX > after.x) {
				before = after;
				after = iter.next();
			}
			activeTriggerPos[i] = (before.getY() >= 0.5);
		}
		return activeTriggerPos;
	}

	// interfaces.LocalMode
	@Override
	public void setLocalPeriod(int period) {
		localPeriod = period;
	}

	@Override
	public int getLocalPeriod() {
		return localPeriod;
	}

	@Override
	public boolean isUsingLocalPeriod() {
		return localPeriodActive;
	}

	@Override
	public void setUseLocalPeriod(boolean state) {
		this.localPeriodActive = state;
	}

	public String toString() {
		return name + "[ID:" + getId() + "]";

	}
}