Adds backend for user created manipulation algorithms to sim

src/main/java/de/tu_darmstadt/tk/SmartHomeNetworkSim/control/SimulationController.java

@@ -1,9 +1,11 @@
 package de.tu_darmstadt.tk.SmartHomeNetworkSim.control;
 
 import java.io.File;
+import java.util.LinkedList;
 import java.util.Observer;
 
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.Model;
+import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.NetworkManipulationAlgorithm;
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.SimulationManager;
 
 /**
@@ -204,4 +206,34 @@ public class SimulationController {
 	public void removeObserver(Observer o){
 		sim.deleteObserver(o);
 	}
+	
+	/**
+	 * Runs all registered algorithms at the currentTimeStep
+	 * @param time currentTime of the simulation
+	 */
+	public void runAlgorithms(long time) {
+		sim.runAlgorithms(time);
+	}
+	/**
+	 * Returns all registered algorithms of the simulation
+	 * @return all registered algorithms
+	 */
+	public LinkedList<NetworkManipulationAlgorithm> getAlgorithms(){
+		return sim.getAlgorithms();
+	}
+	/**
+	 * Adds an algorithm, which should be executed each timestep
+	 * @param algo new algorithm
+	 */
+	public void addAlgorithm(NetworkManipulationAlgorithm algo, Controller controller){
+		sim.addAlgorithm(algo, controller);
+	}
+	
+	/**
+	 * Removes algorithms from the simulation
+	 * @param algo algorithm to be removed
+	 */
+	public void removeAlgo(NetworkManipulationAlgorithm algo){
+		sim.removeAlgo(algo);
+	}
 }

src/main/java/de/tu_darmstadt/tk/SmartHomeNetworkSim/core/ConnectionPrecision.java

@@ -147,13 +147,6 @@ public class ConnectionPrecision extends ConnectionPerformance {
 				break;
 			last = returnPackets.getLast();
 		}
-		if(!outOfBoundsPackets.isEmpty()||true){
-			System.out.println("Connection: "+name);
-			System.out.println("Returned: ");
-			returnPackets.forEach(p->System.out.println(p.getTextualRepresentation()));
-			System.out.println("Not returned:");
-			outOfBoundsPackets.forEach(p->System.out.println(p.getTextualRepresentation()));
-		}
 		return returnPackets;
 	}
 	

src/main/java/de/tu_darmstadt/tk/SmartHomeNetworkSim/core/NetworkManipulationAlgorithm.java

@@ -0,0 +1,26 @@
+package de.tu_darmstadt.tk.SmartHomeNetworkSim.core;
+
+import de.tu_darmstadt.tk.SmartHomeNetworkSim.control.Controller;
+
+/**
+ * Interface for programs/algorithms/manipulations/optimizations which could run during each
+ * simulation step. The Main Controller which is an argument is quite powerful and
+ * allows full access to the whole model, simulation, parts of the GUI and
+ * should be used wisely.<br>
+ * The runAlgorithm method will be called at the end of each simulation cycle,
+ * if imported and added to the simulation.
+ *
+ * @author Andreas T. Meyer-Berg
+ */
+public interface NetworkManipulationAlgorithm {
+
+	/**
+	 * 
+	 * @param controller
+	 *            Main controller of the framework, access to the network model,
+	 *            settings, simulation etc.
+	 * @param currentTimeStep
+	 *            current time in the simulation
+	 */
+	public void runAlgorithm(Controller controller, long currentTimeStep);
+}

src/main/java/de/tu_darmstadt/tk/SmartHomeNetworkSim/core/SimulationManager.java

@@ -10,6 +10,7 @@ import java.util.Observable;
 
 import javax.swing.Timer;
 
+import de.tu_darmstadt.tk.SmartHomeNetworkSim.control.Controller;
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.util.PacketComparator;
 
 /**
@@ -23,6 +24,11 @@ public class SimulationManager extends Observable {
 	 */
 	private Model model;
 
+	/**
+	 * Controller for manipulationAlgorithms
+	 */
+	private Controller controller;
+
 	/**
 	 * True if packets should be printed
 	 */
@@ -58,18 +64,26 @@ public class SimulationManager extends Observable {
 	 * First Timestep of the simulation
 	 */
 	private long startTime = 0L;
+	
 	/**
 	 * Last Timestep of the simulation
 	 */
 	private long endTime = 1000L;
+	
 	/**
 	 * Current TimeStep in the simulation
 	 */
 	private long currentTime = 0L;
+	
 	/**
 	 * Duration of the simulation
 	 */
 	private long duration = 100L;
+	
+	/**
+	 * ManipulationAlgorithm Instances, which should run in each timestep
+	 */
+	private LinkedList<NetworkManipulationAlgorithm> algos = new LinkedList<NetworkManipulationAlgorithm>();
 
 	/**
 	 * Creates a new Simulationmanager
@@ -79,11 +93,12 @@ public class SimulationManager extends Observable {
 	 */
 	public SimulationManager(Model model) {
 		this.model = model;
+		this.controller = null;
 		timer = new Timer(0, t -> simulateTimeStep());
 	}
 
 	/**
-	 * Simulate the nexte Timestep
+	 * Simulate the next Timestep
 	 */
 	private void simulateTimeStep() {
 		// Just simulate if timer is running
@@ -131,6 +146,7 @@ public class SimulationManager extends Observable {
 			model.setChanged();
 			model.notifyObservers();
 		}
+		runAlgorithms(startTime);
 		exportPacketsOfLastTimeStep();
 	}
 
@@ -405,4 +421,41 @@ public class SimulationManager extends Observable {
 		this.setChanged();
 		this.notifyObservers();
 	}
+	
+	/**
+	 * Runs all registered algorithms at the currentTimeStep
+	 * @param time currentTime of the simulation
+	 */
+	public void runAlgorithms(long time) {
+		/**
+		 * Run all Algorithms
+		 */
+		for(NetworkManipulationAlgorithm algo:algos){
+			algo.runAlgorithm(controller, time);
+		}
+	}
+	/**
+	 * Returns all registered algorithms of the simulation
+	 * @return all registered algorithms
+	 */
+	public LinkedList<NetworkManipulationAlgorithm> getAlgorithms(){
+		return algos;
+	}
+	/**
+	 * Adds an algorithm, which should be executed each timestep
+	 * @param algo new algorithm
+	 */
+	public void addAlgorithm(NetworkManipulationAlgorithm algo, Controller controller){
+		this.controller = controller;
+		if(algo!=null)
+			algos.add(algo);
+	}
+	
+	/**
+	 * Removes algorithms from the simulation
+	 * @param algo algorithm to be removed
+	 */
+	public void removeAlgo(NetworkManipulationAlgorithm algo){
+		algos.remove(algo);
+	}
 }

src/main/java/de/tu_darmstadt/tk/SmartHomeNetworkSim/core/simpleImplementation/SimpleManipulation.java

@@ -0,0 +1,51 @@
+package de.tu_darmstadt.tk.SmartHomeNetworkSim.core.simpleImplementation;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import de.tu_darmstadt.tk.SmartHomeNetworkSim.control.Controller;
+import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.NetworkManipulationAlgorithm;
+import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.SmartDevice;
+
+/**
+ * Simple proof of concept NetworkManipulationAlgorithm, which moves one random visible SmartDevice by a small amount.
+ *
+ * @author Andreas T. Meyer-Berg
+ */
+public class SimpleManipulation implements NetworkManipulationAlgorithm {
+
+	@Override
+	public void runAlgorithm(Controller controller, long currentTimeStep) {
+		/**
+		 * Visible devices of the model, to select one which should be moved
+		 */
+		Collection<SmartDevice> devices = controller.getNetworkController().getVisibleSmartDevices();
+		/**
+		 * Iterator for the devices
+		 */
+		Iterator<SmartDevice> it = devices.iterator();
+		/**
+		 * SmartDevice which should be moved
+		 */
+		SmartDevice move = null;
+		/**
+		 * Index of the randomly selected device
+		 */
+		int deviceNumber = (int)Math.round(devices.size() * Math.random());
+		for(int i = 0; i< deviceNumber && it.hasNext(); i++){
+			move = it.next();
+		}
+		/**
+		 * Move device randomly up to 5 pixels in x and y direction
+		 */
+		if(move != null){
+			controller.getNetworkController().moveSmartDevice(move,(int)(move.getX()+Math.random()*10-5), (int)(move.getY()+Math.random()*10-5), move.getZ());
+			controller.getNetworkController().validateDevicePosition();
+		}
+			/**
+		 * Refresh Panel
+		 */
+		controller.notifyObservers();
+	}
+
+}