Adds Precision Connection

src/main/java/de/tu_darmstadt/tk/SmartHomeNetworkSim/Main.java

@@ -4,6 +4,7 @@ import de.tu_darmstadt.tk.SmartHomeNetworkSim.control.ConfigurationController;
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.control.Controller;
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.Connection;
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.ConnectionPerformance;
+import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.ConnectionPrecision;
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.Link;
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.Model;
 import de.tu_darmstadt.tk.SmartHomeNetworkSim.core.Port;
@@ -131,7 +132,7 @@ public class Main {
 		
 		Protocol protocol = new MQTT_protocol(brokerPort);
 		
-		Connection con = new ConnectionPerformance(link, protocol);
+		Connection con = new ConnectionPrecision(link, protocol);
 		con.setPacketLossProbability(0.01);//1% Packet loss probability
 		con.addSmartDevice(brokerPort);
 		brokerPort.setConnection(con);

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

@@ -4,20 +4,20 @@ import java.util.Collection;
 import java.util.LinkedList;
 
 /**
- * Implementation of the Connection Interface
+ * Implementation of the Connection Interface, with main focus on performance
  *
  * @author Andreas T. Meyer-Berg
  */
 public class ConnectionPerformance implements Connection {
 
-	private Link link;
-	private LinkedList<Port> participants;
-	private LinkedList<Port> removedParticipants;
-	private Protocol protocol;
-	private double packetLossRate;
-	private byte status;
-	private boolean changed = false;
-	private String name;
+	protected Link link;
+	protected LinkedList<Port> participants;
+	protected LinkedList<Port> removedParticipants;
+	protected Protocol protocol;
+	protected double packetLossRate;
+	protected byte status;
+	protected boolean changed = false;
+	protected String name;
 	
 	/**
 	 * Initializes the connection, adds participants of the protocol

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

@@ -0,0 +1,121 @@
+package de.tu_darmstadt.tk.SmartHomeNetworkSim.core;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+/**
+ * Implementation of the Connection Interface, with focus on precision
+ *
+ * @author Andreas T. Meyer-Berg
+ */
+public class ConnectionPrecision extends ConnectionPerformance {
+
+	/**
+	 * Initializes the connection, adds participants of the protocol
+	 * 
+	 * @param l Link which this connection uses
+	 * @param p Protocol of the connection
+	 */
+	public ConnectionPrecision(Link l, Protocol p) {
+		super(l,p);
+	}
+	
+	@Override
+	public Collection<Packet> simulateTimeInterval(long startTime, long duration) {
+		/**
+		 * Time step the simulation interval ends
+		 */
+		long endTime = startTime+duration;
+		
+		LinkedList<Packet> returnPackets=new LinkedList<Packet>();
+		returnPackets.addAll(getTerminationPackages(startTime));
+		startTime+=returnPackets.size();
+		/**
+		 * Self Sorting LinkedList for consistency
+		 */
+		LinkedList<Port> list = new LinkedList<Port>();
+		list.addAll(participants);
+		//Sort by next trigger time step
+		list.sort(new PortComparator());
+		
+		/*
+		 * Packages that should have been sent before the simulation time step
+		 */
+		/**
+		 * Iterator to move through the list
+		 */
+		ListIterator<Port> it = list.listIterator();
+		boolean packageBeforeInterval = false;
+		while(it.hasNext()){
+			Port p = it.next();
+			if(p.getLastTrigger()+p.getTriggerInterval()<startTime){
+				if(p.getStatus()==Port.SENDING){
+					//Generate first package in the simulation interval
+					returnPackets.addAll(protocol.generateNextPakets(p, (long) (startTime+p.getJitter()*Math.random()/2),Math.random()<packetLossRate));
+					packageBeforeInterval = true;
+					startTime++;
+				}
+			}else{
+				//If not further calculations before the interval are required
+				break;
+			}
+		}
+		//If next package steps changed -> sort again (should occur rarely/never)
+		if(packageBeforeInterval)
+			list.sort(new PortComparator());
+		//Generate packages
+		it = list.listIterator();
+		while(it.hasNext()){
+			Port p = it.next();
+			
+			if(p.getStatus()==Port.SENDING){
+				if(p.getLastTrigger()+p.getTriggerInterval()<endTime){
+					//Generate first package in the simulation interval
+					returnPackets.addAll(protocol.generateNextPakets(p, (long) (p.getLastTrigger()+p.getTriggerInterval()+p.getJitter()*(Math.random()-0.5)),Math.random()<packetLossRate));
+
+					//Remove Ports, which won't simulate again during this time step
+					it.remove();
+					//If further packages should be generated -> move inside the list
+					if(p.getLastTrigger()+p.getTriggerInterval()<endTime){
+						//move Port to it's new Position;
+						boolean added = false;
+						while(it.hasNext()){
+							Port next = it.next();
+							if(new PortComparator().compare(p, next)<0){
+								//Insert in front of this Port
+								it.add(p);
+								added = true;
+							}
+						}
+						if(!added){
+							//Add as last element
+							it.add(p);
+						}
+						it = list.listIterator();
+					}
+				}else{
+					it.remove();
+				}
+			}else{
+				//Remove ports, which are not sending
+				it.remove();
+			}
+		}
+		
+		/**
+		 * Sort and return packages
+		 */
+		returnPackets.sort((a,b)->(Long.compare(a.getTimestamp(),b.getTimestamp())));
+		return returnPackets;
+	}
+	private class PortComparator implements Comparator<Port>{
+
+		@Override
+		public int compare(Port o1, Port o2) {
+			return Long.compare(o1.getLastTrigger()+o1.getTriggerInterval(),o2.getLastTrigger()+o2.getTriggerInterval());
+		}
+		
+	}
+}