bool graph_add_edge(graph_t *g, void *from, void *to, void *label)
{
assert(list_has(g->nodes, g->comp, from) && list_has(g->nodes, g->comp, to));
edge_t *e = new_edge();
e->from = from;
e->to = to;
e->label = label;
list_add(g->edges, e);
return true;
}
void testLISTHAS()
{
list_t *l = list_new();
list_add(l, strdup("hello"));
list_add(l, strdup("world"));
CU_ASSERT_FALSE(list_has(l, streq, "HELLO"));
CU_ASSERT(list_has(l, streq, "hello"));
list_foreach(l, free);
list_free(l);
}
void *get_min_distance_node(list_t *distanceLabels, comparator_t comp,
list_t *visited)
{
assert(distanceLabels);
int minDist = -1;
void *minLabel = NULL;
iter_t *it;
for (it = iter(distanceLabels); !iter_done(it); iter_next(it))
{
distance_label_t *itdl = iter_get(it);
if (itdl->dist == -1) // inte varit där
{
continue;
}
if (list_has(visited, comp, itdl->label)) // finns redan i visited, abort
{
continue;
}
if (minDist == -1 || itdl->dist < minDist)// om inte ändrats en enda gång eller nya distansen 'r mindre än förra minsta distans.
{
minDist = itdl->dist;
minLabel = itdl->label;
}
}
iter_free(it);
return minLabel;
}
void dijkstra(graph_t *g, void *current, void *to, list_t *visited,
list_t *distanceLabels)
{
assert(g);
assert(current);
assert(to);
assert(visited);
assert(distanceLabels);
while (true)
{
if (!list_has(visited, g->comp, current))
{
list_t *unvisited_neighs = unvisited_neighbors(g, current, visited);
distance_label_t *here =
get_distance_label(distanceLabels, current, g->comp);
iter_t *it;
for (it = iter(unvisited_neighs); !iter_done(it); iter_next(it))
{
void *neigh = iter_get(it);
int line = list_quickest_line(g->nodes, current, neigh, here->arrival_time);
// printf("med linje:%i i dijkstra\n",line);
assert(line);
edge_t *edge = graph_get_edge(g,line,current,here->path_edges);
assert(edge);
list_t *tentativePath = list_clone(here->path);
list_t *tentativeEdgePath = list_clone(here->path_edges);
list_add(tentativePath, neigh);
list_add(tentativeEdgePath, edge);
char *bussDepart = list_next_dep_time(g->nodes,current,neigh,line,here->arrival_time);
assert(bussDepart);
int total_distance = graph_add_penalty(edge, here->arrival_time, bussDepart);// egen rad
char *new_arrival_time = add_duration(bussDepart, network_get_dur(edge->label)); //egen rad
//free(bussDepart);
update_distance(distanceLabels, neigh, g->comp, here->dist + total_distance,
tentativePath, tentativeEdgePath, new_arrival_time); //la till new_arrival_tim. ost-bågen borde gå in här!!
}
iter_free(it);
list_free(unvisited_neighs);
}
list_add(visited, current);
if (g->comp(current, to))
{
return;
}
current = get_min_distance_node(distanceLabels, g->comp, visited);
assert(current);
}
}
bool graph_add_node(graph_t *g, void *label)
{
if (list_has(g->nodes, g->comp, label))
{
return false;
}
else
{
list_add(g->nodes, label);
return true;
}
}
static void validate_list(int index, struct list *list) {
int i;
assert(list);
for(i=0; i < 4; i++) {
if (i != wdref[index])
continue;
assert(list_has(list, pathref[index], cmp));
}
}
list_t *unvisited_neighbors(graph_t *g, void *current, list_t *visited)
{
list_t *neighs = graph_find_neighbors(g, current);
list_t *unvisited_neighs = list_new();
iter_t *nit;
for (nit = iter(neighs); !iter_done(nit); iter_next(nit))
{
void *neigh = iter_get(nit);
if (!list_has(visited, g->comp, neigh))
{
list_add(unvisited_neighs, neigh);
}
}
iter_free(nit);
list_free(neighs);
return unvisited_neighs;
}
void testFINDNEIGHBORS()
{
graph_t *g = mkGraphABCDE();
graph_add_edge(g, "A", "B", NULL);
list_t *neighs = graph_find_neighbors(g, "A");
CU_ASSERT(list_has(neighs, streq, "B"))
CU_ASSERT(list_len(neighs) == 1);
list_free(neighs);
// adding an additional neighbor:
graph_add_edge(g, "A", "C", NULL);
neighs = graph_find_neighbors(g, "A");
CU_ASSERT(list_has(neighs, streq, "B"));
CU_ASSERT(list_has(neighs, streq, "C"));
CU_ASSERT(list_len(neighs) == 2);
list_free(neighs);
// the graph is directed:
graph_add_edge(g, "C", "A", NULL);
neighs = graph_find_neighbors(g, "A");
CU_ASSERT(list_has(neighs, streq, "B"));
CU_ASSERT(list_has(neighs, streq, "C"));
CU_ASSERT(list_len(neighs) == 2);
list_free(neighs);
// add an unrelated edge
graph_add_edge(g, "D", "E", NULL);
neighs = graph_find_neighbors(g, "A");
CU_ASSERT(list_has(neighs, streq, "B"));
CU_ASSERT(list_has(neighs, streq, "C"));
CU_ASSERT(list_len(neighs) == 2);
list_free(neighs);
freeGraphABCDE(g);
}
bool graph_has_node(graph_t *g, void *label)
{
return list_has(g->nodes, g->comp, label);
}
bool graph_check_node_exist(graph_t *g, char *from, char *to) //EGEN FUNKTION
{
if(list_has(g->nodes, g->comp, from) && list_has(g->nodes, g->comp, to)) return true;
else return false;
}
