Edge Feature

src/api/TopologieAlgorithmFramework.java

@@ -16,6 +16,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Locale;
@@ -88,15 +89,13 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 	private HashMap<Integer, AbstractCpsObject> accessIntegerToWildcard = new HashMap<Integer, AbstractCpsObject>();
 	
 	
-	
-	
-	
-	
-	
 	private HashSet<IndexCable> cableSet = new HashSet<IndexCable>();
-	private HashMap<IndexCable, CpsEdge> addedCableMap = new HashMap<IndexCable, CpsEdge>();
+	private ArrayList<IndexCable> cableList = new ArrayList<IndexCable>();
+	private HashSet<IndexCable> addedIndexCable = new HashSet<IndexCable>();
 	private int countForAccessMap = 0;
-	
+	private int amountOfExistingCables = 0;
+	private ArrayList<HolonSwitch> switchList = new ArrayList<HolonSwitch>();
+	private ArrayList<CpsEdge> edgeList = new ArrayList<CpsEdge>();
 	
 	
 	boolean algoUseElements = false, algoUseSwitches = true, algoUseFlexes = true;
@@ -627,12 +626,19 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 	 * @param position
 	 */
 	private void setState(List<Integer> position) {
-		this.removeAllAddedCables();
+		this.removeAllAddedObjects();
 		for(int i = 0; i < this.amountOfNewCables; i++) {
-			generateCable(position.get(2 * i), position.get(2 * i + 1));
+			generateCable(position.get(2 * i), position.get(2 * i + 1), position.get(2 * amountOfNewCables + i) == 1);
 		}
+		//Switches new Cable
+		//Switches existing cable
 		int count = 0;
-		for(int i = 2 * this.amountOfNewCables; i < position.size(); i++) {
+		for(int i = 3 * amountOfNewCables; i < 3 * this.amountOfNewCables + this.amountOfExistingCables; i++) {
+			generateEdgeFromIndexCable(cableList.get(count++), position.get(i) == 1);
+		}
+		//WildCards
+		count = 0;
+		for(int i = 3 * amountOfNewCables + amountOfExistingCables; i < position.size(); i++) {
 			accessWildcards.get(count++).setState(position.get(i));
 		}
 }
@@ -654,9 +660,11 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 		//-->reset
 		accessWildcards.clear();
 		this.countForAccessMap = 0;
+		amountOfExistingCables = 0;
 		accessIntToObject.clear();
 		accessObjectToInt.clear();
 		cableSet.clear();
+		cableList.clear();
 		//<---
 		Category category = control.searchCategory("Wildcards");
 		if(category != null) {
@@ -672,11 +680,21 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 		List<Integer> initialState = new ArrayList<Integer>();
 		generateAccess(model.getObjectsOnCanvas());			
 		addCables(model.getEdgesOnCanvas());
+		model.getEdgesOnCanvas().clear();
 		getCables(model.getObjectsOnCanvas());
+		//New Cables
 		for(int i = 0; i < this.amountOfNewCables; i++) {
 			initialState.add(0);
 			initialState.add(0);
 		}
+		//switch in new Cables
+		for(int i = 0; i < this.amountOfNewCables; i++) {
+			initialState.add(0);
+		}
+		//Switch in initial Cable
+		cableSet.stream().forEach(indexCale -> initialState.add(0));
+		amountOfExistingCables = cableSet.size();
+		//wildcards
 		for(int i = 0; i < accessWildcards.size(); i++) {
 			initialState.add(0);
 		}
@@ -716,6 +734,8 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 				CpsUpperNode aUpperNode = (CpsUpperNode)aCps;
 				addCables(aUpperNode.getNodeEdges());
 				addCables(aUpperNode.getOldEdges());
+				aUpperNode.getNodeEdges().clear();
+				aUpperNode.getOldEdges().clear();
 				getCables(((CpsUpperNode)aCps).getNodes());
 			}
 		}
@@ -730,8 +750,10 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 	 * @param cables
 	 */
 	private void addCables(List<CpsEdge> edges) {
+		
 		for (CpsEdge edge : edges) {
 			edge.setUnlimitedCapacity(true);
+			edgeList.add(edge);
 			//console.println("Cable from " + edge.getA().getName() + " to " + edge.getB().getName());
 			if(!accessObjectToInt.containsKey(edge.getA())) {
 				console.println("Node A from Edge[" + edge + "] not exist");
@@ -740,33 +762,68 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 				console.println("Node B from Edge[" + edge + "] not exist");
 				continue;
 			}
-			cableSet.add(new IndexCable(accessObjectToInt.get(edge.getA()), accessObjectToInt.get(edge.getB())));
+			IndexCable cable = new IndexCable(accessObjectToInt.get(edge.getA()), accessObjectToInt.get(edge.getB()));
+			boolean success = cableSet.add(cable);
+			if(success) {
+				cableList.add(cable);
+			}
+			
 		}
 	}
 	
 	
 	
-	private void generateCable(int index1, int index2) {
+	private void generateCable(int index0, int index1, boolean switchBetween) {
 		//If cable isnt valid
-		if(index1 == 0 || index2 == 0 || index1 == index2) {
+		if(index0 == 0 || index1 == 0 || index0 == index1) {
 			//console.println("Cable("+index1+","+index2+ ") isn't valid");
 			return;
 		}
-		IndexCable cable = new IndexCable(index1, index2);
+		IndexCable cable = new IndexCable(index0, index1);
 		//if cable is in existing cables
-		if(cableSet.contains(cable) || addedCableMap.containsKey(cable)) {
-			//console.println("Cable("+index1+","+index2+ ") already exist");
+		if(cableSet.contains(cable) || addedIndexCable.contains(cable)) {
 			return;
 		}
-		
-		CpsEdge edge = new CpsEdge(accessIntToObject.get(index1), accessIntToObject.get(index2));
-		edge.setUnlimitedCapacity(true);
-		control.getModel().getEdgesOnCanvas().add(edge);
-		addedCableMap.put(cable, edge);
+		generateEdgeFromIndexCable(cable, switchBetween);
+		addedIndexCable.add(cable);
 	}
-	private void removeAllAddedCables() {
-		control.getModel().getEdgesOnCanvas().removeAll(addedCableMap.values());
-		addedCableMap.clear();
+	
+	private void generateEdgeFromIndexCable(IndexCable cable, boolean switchBetween){
+		if(switchBetween) {
+			//generate Switch
+			AbstractCpsObject fromObject =  accessIntToObject.get(cable.first);
+			AbstractCpsObject toObject =  accessIntToObject.get(cable.second);
+			int middleX = (fromObject.getPosition().x +   toObject.getPosition().x)/2;
+			int middleY = (fromObject.getPosition().y +   toObject.getPosition().y)/2;
+			HolonSwitch newSwitch = new HolonSwitch("Switch12368");
+			newSwitch.setPosition(middleX, middleY);
+			control.getModel().getObjectsOnCanvas().add(newSwitch);
+			this.switchList.add(newSwitch);
+			
+			//Generate Cable From Object A To Switch
+			CpsEdge edge1 = new CpsEdge(fromObject, newSwitch);
+			edge1.setUnlimitedCapacity(true);
+			control.getModel().getEdgesOnCanvas().add(edge1);
+			edgeList.add(edge1);
+			
+			//Generate Cable From Object B To Switch
+			CpsEdge edge = new CpsEdge(newSwitch, toObject);
+			edge.setUnlimitedCapacity(true);
+			control.getModel().getEdgesOnCanvas().add(edge);
+			edgeList.add(edge);
+			}else {
+			CpsEdge edge = new CpsEdge(accessIntToObject.get(cable.first), accessIntToObject.get(cable.second));
+			edge.setUnlimitedCapacity(true);
+			control.getModel().getEdgesOnCanvas().add(edge);
+			edgeList.add(edge);
+		}
+	}
+	private void removeAllAddedObjects() {
+		control.getModel().getEdgesOnCanvas().removeAll(edgeList);
+		addedIndexCable.clear();
+		control.getModel().getObjectsOnCanvas().removeAll(switchList);
+		switchList.clear();
+		edgeList.clear();
 	}
 	
 	
@@ -870,8 +927,23 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 		this.control = control;
 	}
 	
+	//                 | New Cable          | Switches   | Wildcards             |
+	//return index:    |  countForAccessMap | 1  		 | accessWildcards.size()|	
 	public int getMaximumIndexObjects(int index) {
-		return (index < 2 * amountOfNewCables)? this.countForAccessMap: accessWildcards.size();
+		int maximumIndex = -1;
+		//New Cables
+		if(index < 2 * amountOfNewCables) {
+			maximumIndex =  this.countForAccessMap;
+		}
+		//Switches in existing and in new Cables
+		else if (index < 3 * amountOfNewCables + this.amountOfExistingCables) {
+			maximumIndex =  1;
+		}
+		//wildcards
+		else {
+			maximumIndex =  accessWildcards.size();
+		}
+		return maximumIndex;
 	}
 	
 	
@@ -1030,14 +1102,17 @@ public abstract class TopologieAlgorithmFramework implements AddOn{
 		 */
 		public static int nextIntegerInRangeExcept(int min, int max,int valueBetween) {
 			int result = min;
+			if(max - min == 1) {
+				return (valueBetween == min)? max:min;
+			}
 			try {
 				result = min + random.nextInt((max - 1) - min);
 				if(result >= valueBetween) {
 					result++;
 				}
 			}catch(java.lang.IllegalArgumentException e){
-				System.err.println("min : " + min + " max : " + max);
-				System.err.println("max should be more then min");
+				System.err.println("min : " + min + " max : " + max + " valueBetween:" + valueBetween);
+				System.err.println("Except max should be more then min");
 			}
 			return result;
 		}

src/classes/AbstractCpsObject.java

@@ -55,6 +55,7 @@ public abstract class AbstractCpsObject {
 		setObjName(objName);
 		setName(objName);
 		setImage("/Images/Dummy_House.png");
+		setConnections(new ArrayList<>());
 		tags = new ArrayList<>();
 		pseudoTags = new ArrayList<>();
 	}

src/classes/CpsEdge.java

@@ -54,6 +54,13 @@ public class CpsEdge {
     public CpsEdge(AbstractCpsObject a, AbstractCpsObject b) {
         setA(a);
         setB(b);
+        if(a == null) {
+        	System.out.println("A == NULL");
+        }
+        if(a == null) {
+        	System.out.println("B == NULL");
+        }
+        
         this.a.addConnection(this);
         this.b.addConnection(this);
         this.maxCapacity = 100;