test_class.declarator: test3
test_class.modifier: private static
test_class.original_string: private static HierarchyMapGraph test3;
test_class.type: HierarchyMapGraph
test_class.var_name: test3
test_class.declarator: test5
test_class.modifier: private static
test_class.original_string: private static HierarchyMapGraph test5;
test_class.type: HierarchyMapGraph
test_class.var_name: test5
test_class.declarator: test8
test_class.modifier: private static
test_class.original_string: private static HierarchyMapGraph test8;
test_class.type: HierarchyMapGraph
test_class.var_name: test8
test_class.declarator: testGraph1
test_class.modifier: private static
test_class.original_string: private static HierarchyMapGraph testGraph1;
test_class.type: HierarchyMapGraph
test_class.var_name: testGraph1
test_class.declarator: testGraph2
test_class.modifier: private static
test_class.original_string: private static HierarchyMapGraph testGraph2;
test_class.type: HierarchyMapGraph
test_class.var_name: testGraph2
test_class.declarator: testGraph3
test_class.modifier: private static
test_class.original_string: private static HierarchyMapGraph testGraph3;
test_class.type: HierarchyMapGraph
test_class.var_name: testGraph3
test_class.declarator: testGraph4
test_class.modifier: private static
test_class.original_string: private static HierarchyMapGraph testGraph4;
test_class.type: HierarchyMapGraph
test_class.var_name: testGraph4
test_class.declarator: fastBackup
test_class.modifier: private static
test_class.original_string: private static boolean fastBackup;
test_class.type: boolean
test_class.var_name: fastBackup
test_class.file: SoftwarePraktikum/src/algorithmen/DijkstraTest.java
test_class.identifier: DijkstraTest
test_case.body: @Test
  	public void testBidirectional() throws Exception {
  		
  		Config.fastestPathMode = false;
  		
  		//boolean fehler = false;
  		ArrayList<MapNode> liste = null;
  		MapGraph graph = null;
  		String test;
  		
  		/*
  		 * Test 1 
  		 * Teste auf einem leeren Graphen - erwarte eine leere Liste
  		 */
  		
  		
  		try {
  			liste = Dijkstra.bidirectional(new MapGraph(new GPSCoordinate(50,-50),new GPSCoordinate(-50,50)), 5, 6);
  		} catch (Exception e) {
  			fail("Auf einem leeren Graohen wurde keine Exception geworfen");
  		}
  			
  		/*
  		if (liste.size() != 0)
  			fail("Die Ausgabe auf einem leeren Graphen sollte leer sein. Stattdessen gibt es so viele Elemente: "+liste.size());
  		*/
  		
  		/*
  		 * Test 2
  		 * Teste mit nciht-existerenden End-Knoten - erwarte eine leere Liste
  		 */
  			
  		graph = randomGraph(50,0.3f,3);
  			
  		//fehler = false;
  		try {
  			liste = Dijkstra.bidirectional(graph, 5, 100);
  		} catch (Exception e) {
  			fail("Bei nicht-existierendem Endknoten wurde eine Exception geworfen, statt einer leeren Liste auszugeben: "+e.getLocalizedMessage());
  		}
  		if (liste.size() != 0)
  			fail("Die Ausgabe ohne existerenden Endknoten sollte leer sein. Stattdessen gibt es so viele Elemente: "+liste.size());
  			
  		
  		
  		/*
  		 * Test 3
  		 * Teste mit unerrecihbaren End-Knoten - erwarte leere Liste
  		 */
  		
  		
  		graph.insertNode(10001, new GPSCoordinate(0,0));
  		try {
  			liste = Dijkstra.bidirectional(graph, 5, 10001);
  		} catch (Exception e) {
  			fail("Bei nicht-erreichbaren Endknoten wurde eine Exception geworfen, statt einer leeren Liste auszugeben: "+e.getLocalizedMessage());
  		}
  		if (liste.size() != 0)
  			fail("Die Ausgabe sollte leer sein. Stattdessen gibt es so viele Elemente: "+liste.size());
  			
  		
  		/*
  		 * Test 4
  		 * Teste mit gleichen start-/End-Knoten - erwarte leere Liste
  		 */
  			
  		try {
  			liste = Dijkstra.bidirectional(graph, 5, 5);
  		} catch (Exception e) {
  			fail("Bei nicht-existierendem Endknoten wurde eine Exception geworfen, statt einer leeren Liste auszugeben: "+e.getLocalizedMessage());
  		}
  		if (liste.size() != 0)
  			fail("Die Ausgabe auf start=Ende sollte leer sein. Stattdessen gibt es so viele Elemente: "+liste.size());
  			
  		
  		
  		/*
  		 * Test 5
  		 * Test mit wohldefiniertem Graphen die korrekten Entfernungen
  		 * Test zunaechst im Falle von Einbahnstrassen
  		 */
  		// Definiere Graph:
  			
  		graph = new MapGraph(new GPSCoordinate(50,-50),new GPSCoordinate(-50,50));
  		for(int i=1;i<9;i++) {
  			graph.insertNode(i, new GPSCoordinate(i,i));
  		}
  		graph.insertEdge(1, 2, 1, 1, StreetType.SECONDARY);
  		graph.insertEdge(1, 3, 2, 1, StreetType.SECONDARY);
  		graph.insertEdge(1, 4, 3, 5, StreetType.SECONDARY);
  		graph.insertEdge(2, 3, 4, 2, StreetType.SECONDARY);
  		graph.insertEdge(2, 4, 5, 3, StreetType.SECONDARY);
  		graph.insertEdge(3, 5, 6, 6, StreetType.SECONDARY);
  		graph.insertEdge(4, 6, 7, 1, StreetType.SECONDARY);
  		graph.insertEdge(4, 5, 8, 1, StreetType.SECONDARY);
  		graph.insertEdge(4, 7, 9, 4, StreetType.SECONDARY);
  		graph.insertEdge(6, 7, 10, 2, StreetType.SECONDARY);
  		graph.insertEdge(5, 7, 11, 3, StreetType.SECONDARY);
  		graph.insertEdge(5, 8, 12, 5, StreetType.SECONDARY);
  		graph.insertEdge(7, 8, 13, 2, StreetType.SECONDARY);
  		
  		Logger.getInstance().log("DijkstraTest","======");
  		
  		//Test nur die Strecken 1->8 und die Strecke 8->1 (erwarte Laenge 9 und eine leere Liste)
  		liste = Dijkstra.bidirectional(graph, 1, 8);
  		if (liste.size() != 6)
  			fail("Ausgabeliste hat falsche Groesse - erwarte 6, habe: "+liste.size());
  		//Teste korrekte Reihenfolge
  		
  		test = Pfad(liste);
  		if (!test.equalsIgnoreCase("1-2-4-6-7-8"))
  			fail("Die Reihenfolge der besuchten Knoten ist falsch. Erwarte: 1-2-4-6-7-8, habe: "+test);
  		
  		liste = Dijkstra.bidirectional(graph, 8, 1);
  		if (liste.size() != 0)
  			fail("Ausgabeliste hat falsche Groesse - erwarte 0, habe: "+liste.size());
  			
  		/*
  		 * Test 6
  		 * Teste nun mit wegen (beide Richtungen) verschiedene kurze wege
  		 */
  		
  		//Definiere Graph
  		graph = new MapGraph(new GPSCoordinate(50,-50),new GPSCoordinate(-50,50));
  		for(int i=1;i<9;i++) {
  			graph.insertNode(i, new GPSCoordinate(i,i));
  		}
  		weg(graph,1,2,1,1);
  		weg(graph,1,3,2,1);
  		weg(graph,1,4,3,5);
  		weg(graph,2,3,4,2);
  		weg(graph,2,4,5,3);
  		weg(graph,3,5,6,6);
  		weg(graph,4,6,7,1);
  		weg(graph,4,5,8,1);
  		weg(graph,4,7,9,4);
  		weg(graph,6,7,10,2);
  		weg(graph,5,7,11,3);
  		weg(graph,5,8,12,5);
  		weg(graph,7,8,13,2);
  
  		//Teste nun wieder 1->8 (gleiches Ergebnis wie eben bitte!)
  		liste = Dijkstra.bidirectional(graph, 1, 8);
  		if (liste.size() != 6)
  			fail("Ausgabeliste hat falsche Groesse - erwarte 6, habe: "+liste.size());
  		//teste Reihenfolge
  		test = Pfad(liste);
  		if (!test.equalsIgnoreCase("1-2-4-6-7-8"))
  			fail("Die Reihenfolge der besuchten Knoten ist falsch. Erwarte: -1-2-4-6-7-8, habe: "+test);
  		
  		//Teste 8->1
  		liste = Dijkstra.bidirectional(graph, 8, 1);
  		if (liste.size() != 6)
  			fail("Ausgabeliste hat falsche Groesse - erwarte 6, habe: "+liste.size());
  		//teste Reihenfolge
  		test = Pfad(liste);
  		if (!test.equalsIgnoreCase("8-7-6-4-2-1"))
  			fail("Die Reihenfolge der besuchten Knoten ist falsch. Erwarte: 8-7-6-4-2-1, habe: "+test);
  		
  		
  		//Test nun 1->5
  		liste = Dijkstra.bidirectional(graph, 1, 5);
  		if (liste.size() != 4)
  			fail("Ausgabeliste hat falsche Groesse - erwarte 3, habe: "+liste.size());
  		//teste Reihenfolge
  		test = Pfad(liste);
  		if (!test.equalsIgnoreCase("1-2-4-5"))
  			fail("Die Reihenfolge der besuchten Knoten ist falsch. Erwarte: 1-4-5, habe: "+test);
  		
  		//Teste nun 3->4
  		liste = Dijkstra.bidirectional(graph, 3, 4);
  		if (liste.size() != 3)
  			fail("Ausgabeliste hat falsche Groesse - erwarte 3, habe: "+liste.size());
  		//teste Reihenfolge
  		test = Pfad(liste);
  		if (!test.equalsIgnoreCase("3-2-4"))
  			fail("Die Reihenfolge der besuchten Knoten ist falsch. Erwarte: 3-2-4, habe: "+test);
  		
  		//Teste 7->4
  		liste = Dijkstra.bidirectional(graph, 7, 4);
  		if (liste.size() != 3)
  			fail("Ausgabeliste hat falsche Groesse - erwarte 3, habe: "+liste.size());
  		//teste Reihenfolge
  		test = Pfad(liste);
  		if (!test.equalsIgnoreCase("7-6-4"))
  			fail("Die Reihenfolge der besuchten Knoten ist falsch. Erwarte: 7-6-4, habe: "+test);
  		
  		/*
  		 * Test 7
  		 * erstelle zufallige Graphen und pruefe, ob ein ehler auftritt
  		 * Teste dabei auch die Zeit
  		 */
  		
  		try {
  			//for (int l = 0;l<10;l++) {
  				BelastungsTest(50,0.3f,3);
  				BelastungsTest(100,0.3f,5);
  				BelastungsTest(500,0.3f,5);
  				BelastungsTest(1000,0.3f,5);
  				BelastungsTest(5000,0.3f,5);
  				//BelastungsTest(10000,0.3f,5);
  				//BelastungsTest(50000,0.3f,5);
  				//BelastungsTest(100000,0.3f,5);
  				//BelastungsTest(500000,0.3f,5);
  				//BelastungsTest(1000000,0.3f,5);
  			//}
  		} catch (Exception e) {
  			fail("Es gab einen Fehler innerhalb der Belastungstests: "+e.getLocalizedMessage());
  		}
  		
  		/*
  		long time =0;
  		try{
  			for (int i=0; i<10;i++){
  				//Logger.getInstance().log("DijkstraTest","Durchlauf"+ (i+1));
  				time += BelastungsTest(5000,0.1f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,0.2f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,0.3f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,0.4f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,0.5f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,0.6f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,0.7f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,0.8f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,0.9f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  				time += BelastungsTest(5000,1.0f,5);
  				//Logger.getInstance().log("DijkstraTest","Gesamtzeit bisher: "+time+"ms");
  			}
  		} catch (Exception e) {
  			fail("Es gab einen Fehler innerhalb der Belastungstests: "+e.getLocalizedMessage());
  		}
  		*/
  		
  
  		/*
  		 * Test 8
  		 * Teste die Dtestgraph
  		 */
  		
  		MapGraph testGraph = null;
  		OSMImporter osm_imp;
  		
  		try {
  			osm_imp = new OSMImporter(new File("testdateien/DtestGraph.osm"));
  			testGraph = osm_imp.getTile(osm_imp.getMapCenter(), 0);
  		} catch (Exception e) {
  			fail("Fehler beim Einlesen der DtestGraph: "+e.getLocalizedMessage());
  		}
  		
  		ArrayList<MapNode> myway = Dijkstra.bidirectional(testGraph, 3, 10);
  		
  		Logger.getInstance().log("DijkstraTest", "Die Laenge der Strecke ist: "+weglaenge(myway));
  		
  		/*
  		 * Gitter-Test
  		 */
  		Logger.getInstance().log("DijkstraTest","Starte Gitter-Test (n=3)");
  		MapGraph Gittertest = GitterGraph(3);
  		liste = Dijkstra.bidirectional(Gittertest, 1, 3*3);
  		if (!(Pfad(liste).equals("1-2-5-6-9")))
  			fail("Der Algo ibt nicht auf dem Gitter die kuerzeste Route aus");
  		Logger.getInstance().log("DijkstraTest","Weglaenge (soll: 4): "+weglaenge(liste));
  		if (weglaenge(liste) != 4)
  			fail("Der berechnete Weg ist nciht der kuerzeste!");
  			/*
  		Logger.getInstance().log("DijkstraTest","Starte Gitter-Test (n=1.000)");
  		Gittertest = GitterGraph(1000);
  		liste = Dijkstra.bidirectional(Gittertest, 1, 1000*1000);
  		Logger.getInstance().log("DijkstraTest","Weglaenge (soll: 1998): "+weglaenge(liste));
  		if (weglaenge(liste) != 1998)
  			fail("Der berechnete Weg ist nciht der kuerzeste!");
  			*/
  	}
test_case.class_method_signature: DijkstraTest.testBidirectional()
test_case.full_signature: @Test public void testBidirectional()
test_case.identifier: testBidirectional
test_case.invocations: bidirectional fail randomGraph bidirectional fail getLocalizedMessage size fail size insertNode bidirectional fail getLocalizedMessage size fail size bidirectional fail getLocalizedMessage size fail size insertNode insertEdge insertEdge insertEdge insertEdge insertEdge insertEdge insertEdge insertEdge insertEdge insertEdge insertEdge insertEdge insertEdge log getInstance bidirectional size fail size Pfad equalsIgnoreCase fail bidirectional size fail size insertNode weg weg weg weg weg weg weg weg weg weg weg weg weg bidirectional size fail size Pfad equalsIgnoreCase fail bidirectional size fail size Pfad equalsIgnoreCase fail bidirectional size fail size Pfad equalsIgnoreCase fail bidirectional size fail size Pfad equalsIgnoreCase fail bidirectional size fail size Pfad equalsIgnoreCase fail BelastungsTest BelastungsTest BelastungsTest BelastungsTest BelastungsTest fail getLocalizedMessage getTile getMapCenter fail getLocalizedMessage bidirectional log getInstance weglaenge log getInstance GitterGraph bidirectional equals Pfad fail log getInstance weglaenge weglaenge fail
test_case.modifiers: @Test public
test_case.parameters: ()
test_case.return: void
test_case.signature: void testBidirectional()
focal_class.declarator: debug = false
focal_class.modifier: static
focal_class.original_string: static boolean debug = false;
focal_class.type: boolean
focal_class.var_name: debug
focal_class.declarator: logger = Logger.getInstance()
focal_class.modifier: private static
focal_class.original_string: private static Logger logger = Logger.getInstance();
focal_class.type: Logger
focal_class.var_name: logger
focal_class.file: SoftwarePraktikum/src/algorithmen/Dijkstra.java
focal_class.identifier: Dijkstra
focal_class.class_method_signature: Dijkstra.updateNeighbours(HashMap<Integer,Vertex> nodes, PrQueue queue, HierarchyMapEdge newEdge, Vertex node, boolean mode)
focal_class.full_signature: private static void updateNeighbours(HashMap<Integer,Vertex> nodes, PrQueue queue, HierarchyMapEdge newEdge, Vertex node, boolean mode)
focal_class.identifier: updateNeighbours
focal_class.modifiers: private static
focal_class.parameters: (HashMap<Integer,Vertex> nodes, PrQueue queue, HierarchyMapEdge newEdge, Vertex node, boolean mode)
focal_class.return: void
focal_class.signature: void updateNeighbours(HashMap<Integer,Vertex> nodes, PrQueue queue, HierarchyMapEdge newEdge, Vertex node, boolean mode)
focal_class.class_method_signature: Dijkstra.neighbourhood(HierarchyMapGraph graph, int startnode, byte level, boolean forward)
focal_class.full_signature: public static long neighbourhood(HierarchyMapGraph graph, int startnode, byte level, boolean forward)
focal_class.identifier: neighbourhood
focal_class.modifiers: public static
focal_class.parameters: (HierarchyMapGraph graph, int startnode, byte level, boolean forward)
focal_class.return: long
focal_class.signature: long neighbourhood(HierarchyMapGraph graph, int startnode, byte level, boolean forward)
focal_class.class_method_signature: Dijkstra.handleQueues(HashMap<Integer,Vertex> nodes1, PrQueue forward, MapGraph graph, 
  									HashMap<Integer,Vertex> nodes2, PrQueue backward, boolean mode)
focal_class.full_signature: private static boolean handleQueues(HashMap<Integer,Vertex> nodes1, PrQueue forward, MapGraph graph, 
  									HashMap<Integer,Vertex> nodes2, PrQueue backward, boolean mode)
focal_class.identifier: handleQueues
focal_class.modifiers: private static
focal_class.parameters: (HashMap<Integer,Vertex> nodes1, PrQueue forward, MapGraph graph, 
  									HashMap<Integer,Vertex> nodes2, PrQueue backward, boolean mode)
focal_class.return: boolean
focal_class.signature: boolean handleQueues(HashMap<Integer,Vertex> nodes1, PrQueue forward, MapGraph graph, 
  									HashMap<Integer,Vertex> nodes2, PrQueue backward, boolean mode)
focal_class.class_method_signature: Dijkstra.bidirectional(MapGraph graph, int startnode, int endnode)
focal_class.full_signature: public static ArrayList<MapNode> bidirectional(MapGraph graph, int startnode, int endnode)
focal_class.identifier: bidirectional
focal_class.modifiers: public static
focal_class.parameters: (MapGraph graph, int startnode, int endnode)
focal_class.return: ArrayList<MapNode>
focal_class.signature: ArrayList<MapNode> bidirectional(MapGraph graph, int startnode, int endnode)
focal_class.class_method_signature: Dijkstra.handleQueues(HashMap<Integer,Vertex> nodes1, PrQueue forward, 
  									    HashMap<Integer,Vertex> nodes2, PrQueue backward, boolean mode)
focal_class.full_signature: private static boolean handleQueues(HashMap<Integer,Vertex> nodes1, PrQueue forward, 
  									    HashMap<Integer,Vertex> nodes2, PrQueue backward, boolean mode)
focal_class.identifier: handleQueues
focal_class.modifiers: private static
focal_class.parameters: (HashMap<Integer,Vertex> nodes1, PrQueue forward, 
  									    HashMap<Integer,Vertex> nodes2, PrQueue backward, boolean mode)
focal_class.return: boolean
focal_class.signature: boolean handleQueues(HashMap<Integer,Vertex> nodes1, PrQueue forward, 
  									    HashMap<Integer,Vertex> nodes2, PrQueue backward, boolean mode)
focal_class.class_method_signature: Dijkstra.bidirectional(HierarchyMapGraph graph, int startnode, int endnode)
focal_class.full_signature: public static Path bidirectional(HierarchyMapGraph graph, int startnode, int endnode)
focal_class.identifier: bidirectional
focal_class.modifiers: public static
focal_class.parameters: (HierarchyMapGraph graph, int startnode, int endnode)
focal_class.return: Path
focal_class.signature: Path bidirectional(HierarchyMapGraph graph, int startnode, int endnode)
focal_method.body: public static ArrayList<MapNode> bidirectional(MapGraph graph, int startnode, int endnode) throws Exception{
  		
  		if (graph == null) throw new EmptyInputException("Leerer Graph uebergeben");
  		//Hier breche ich immer wieder ab, was echt bloed ist und mich nervt das langsam echt!
  		if (graph.getNode(startnode) == null || graph.getNode(endnode) == null || startnode == endnode) return new ArrayList<MapNode>();
  		
  		HashMap<Integer,Vertex> nodes1 = new HashMap<Integer,Vertex>(); // In einzelnen Listen wird gespeichert welcher Knoten.
  		HashMap<Integer,Vertex> nodes2 = new HashMap<Integer,Vertex>(); //von welcher Richtung aus schon besucht worden ist.
  		
  		PrQueue forward = new PrQueue(); //Priority Queue, die alle erreichbaren Knoten enthaelt
  		PrQueue backward = new PrQueue(); //Priority Queue, die alle erreichbaren Knoten enthaelt
  		
  		Vertex start = new Vertex(graph.getNode(startnode),0,0); //Vertex ist die Hilfsklasse, in der zusaetzliche Infos ueber Knoten gespeichert werden.
  		Vertex end = new Vertex(graph.getNode(endnode),0,0); //Vertex ist die Hilfsklasse, in der zusaetzliche Infos ueber Knoten gespeichert werden.
  		
  		nodes1.put(startnode,start); 
  		nodes2.put(endnode,end);
  		
  		forward.insert(start);
  		backward.insert(end);
          
  		while (forward.getSize() != 0 && backward.getSize() != 0){ //Wenn beide Queues leer, Abbruch
  			boolean abort;
  			abort = handleQueues(nodes1,forward,graph,nodes2,backward,true); //Berechne vorwaerts
  			if(abort) break;
  			abort = handleQueues(nodes1,forward,graph,nodes2,backward,false); //Berechne rueckwaerts
  			if(abort) break;
  		}
  		
  		long distance = -1;
  		Vertex meet = null;
  		
  		
  		//Wir suchen den Punkt ueber den der kuerzeste Weg verlueuft
  		for (Vertex currentNode : nodes1.values()){
  			
  			//ueber pruefe ob Node in beiden Listen vorhanden ist
  			
  			int ID = currentNode.node.getUID();
  			if (nodes2.containsKey(ID) == false){
  				continue;  //node noch nicht von anderer Seite ueberprueft => liegt nicht auf kuerzestem Weg
  			}
  			
  			if (distance == -1) {
  				distance = nodes1.get(ID).getDist() + nodes2.get(ID).getDist();
  				meet = nodes1.get(ID);
  				
  
  			}else{
  				long newDist = nodes1.get(ID).getDist() + nodes2.get(ID).getDist();
  				if (distance > newDist){
  					distance = nodes1.get(ID).getDist() + nodes2.get(ID).getDist();
  					meet = nodes1.get(ID);
  				}
  			}
  		}
  		
  		
  		if (meet == null) return new ArrayList<MapNode>();
  		
  		ArrayList<MapNode> route = new ArrayList<MapNode>();
  
  		route.add(graph.getNode(meet.node.getUID() ) );
  		Vertex pos = meet;
  		
  		while (pos.getPredecessor() != 0){ //Ermittle alle Knoten, die vor meet besucht wurden
  			Vertex parent = nodes1.get(pos.getPredecessor());
  			route.add(0, graph.getNode(parent.node.getUID()));
  			pos = parent;
  		}
  		
  		pos = nodes2.get( meet.node.getUID());
  		
  		while (pos.getPredecessor() != 0){ //Ermittle alle Knoten die nach meet besucht wurden 
  			Vertex parent = nodes2.get(pos.getPredecessor());
  			route.add(graph.getNode(parent.node.getUID()));
  			pos = parent;
  		}		
  		
  		if(debug){ 
  			logger.log("Dijkstra.biderectional","Vom Startknoten aus evaluiert: "+nodes1.values().size());
  			logger.log("Dijkstra.biderectional","Vom Zielknoten aus evaluiert: "+nodes2.values().size());
  			logger.log("Dijkstra.biderectional","Knoten auf der Route: "+route.size());
  		}
  		
  		return route; //gib die Liste zurueck
  	}
focal_method.class_method_signature: Dijkstra.bidirectional(MapGraph graph, int startnode, int endnode)
focal_method.full_signature: public static ArrayList<MapNode> bidirectional(MapGraph graph, int startnode, int endnode)
focal_method.identifier: bidirectional
focal_method.invocations: getNode getNode getNode getNode put put insert insert getSize getSize handleQueues handleQueues values getUID containsKey getDist get getDist get get getDist get getDist get getDist get getDist get get add getNode getUID getPredecessor get getPredecessor add getNode getUID get getUID getPredecessor get getPredecessor add getNode getUID log size values log size values log size
focal_method.modifiers: public static
focal_method.parameters: (MapGraph graph, int startnode, int endnode)
focal_method.return: ArrayList<MapNode>
focal_method.signature: ArrayList<MapNode> bidirectional(MapGraph graph, int startnode, int endnode)