/**
* \fn static gboolean delete_event( GtkWidget *widget,GdkEvent *event,gpointer data )
* \brief Permet de liberer la mémoire lorsque l'on ferme l'interface graĥique
*
* \return void
*/
static gboolean delete_event( GtkWidget *widget,GdkEvent *event,gpointer data ){
if(m != NULL)
deleteMatrice(m);
if(g!= NULL)
deleteGraphe(g);
gtk_main_quit();
return TRUE;
}
int main(){
Graphe g = initGraphe(3);
ajouterArc(0,1,0.5f,g);
ajouterArc(0,2,0.6f,g);
afficherGraphe(g);
deleteGraphe(g);
return 0;
}
void forward(call_t* c, packet_t *packet)
{
struct nodedata *nodedata = get_node_private_data(c);
struct protocoleData *entitydata = get_entity_private_data(c);
array_t *down = get_entity_bindings_down(c);
packet_PROTOCOLE *data = (packet_PROTOCOLE *) (packet->data + nodedata->overhead);
//printf("%d doit relayer depuis %d\n", c->node, data->pred);
// construire le bip tree pour relayer a partir des infos du paquet
int indice = listeNodes_get_index(data->askedToRedirect, c->node);
graphe* g = purgeGraphe(c, listeNodes_get(data->needsToBeCovered, indice), data->src, data->pred);
arbre* bipTree = computeBIPtree(c, g, data->askedToRedirect, data->needsToBeCovered, 0);
if(entitydata->debug)
{
printf("%d relai depuis %d :\n", c->node, data->pred);
arbre_affiche(bipTree);
}
// relayer le paquet
destination_t dst = {-1,{-1,-1,-1}};
double cout = setRangeToFarestNeighbour(c, g, bipTree);
//listeNodes_detruire(&data->askedToRedirect);
data->askedToRedirect = 0;
//listeNodes_detruire(&data->needsToBeCovered);
data->needsToBeCovered = 0;
data->pred = c->node;
//call_t c0 = {-1,c->node,-1};
//data->energyRem = battery_remaining(&c0) - cout;
//nodedata->energiesRem[c->node] = data->energyRem;
setRelayNodes(c, g, bipTree, &data->askedToRedirect, &data->needsToBeCovered, c->node);
call_t c_down = {down->elts[0], c->node, c->entity};
SET_HEADER(&c_down, packet, &dst);
tx(c, packet);
arbre_detruire(&bipTree);
deleteGraphe(g);
free(g);
}
//LA FIN DE LA SUMULATION
int unsetnode(call_t *c) {
//printf("Unset node %d\n", c->node);
struct nodedata *nodedata = get_node_private_data(c);
listeNodes_detruire(&nodedata->oneHopNeighbourhood);
listeNodes_detruire(&nodedata->twoHopNeighbourhood);
if(nodedata->BIP_tree != 0)
{
arbre_detruire(&nodedata->BIP_tree);
}
DEBUG; /* Graphe DE LBIP */
deleteGraphe(nodedata->g2hop);
free(nodedata->g2hop);
free(nodedata->lastIDs);
free(nodedata);
return 0;
}
int set_header( call_t *c , packet_t * packet , destination_t * dst )
{
struct nodedata *nodedata = get_node_private_data(c);
double cout;
//recuperer le support de communication DOWN
entityid_t *down = get_entity_links_down(c);
call_t cdown = {down[0], c->node, c->entity};
// initialisation des donnees de routage du paquet
packet_PROTOCOLE *header = (packet_PROTOCOLE *) (packet->data + nodedata->overhead);
header->type = APP;
header->src = c->node;
header->dst = dst->id;
header->pred = c->node;
header->askedToRedirect = 0;
header->needsToBeCovered = 0;
header->id = last_id++;
if(dst->id == BROADCAST_ADDR)
{
/*printf("Graphe de 2-voisinage de %d :\n", c->node);
afficherGraphe(nodedata->g2hop);*/
graphe* g = copieGraphe(nodedata->g2hop);
int i;
voisin* trans;
for(i = 0 ; i < g->nbSommets ; i++)
{
trans = g->listeVoisins[i];
while(trans != 0)
{
trans->cout /= nodedata->energiesRem[getLabelFromNum(g, i)];
trans = trans->vSuiv;
}
}
if(nodedata->BIP_tree != 0)
{
arbre_detruire(&nodedata->BIP_tree);
}
nodedata->BIP_tree = computeBIPtree(c, g, 0, 0, 0);
//afficherGraphe(nodedata->g2hop);
//arbre_affiche(nodedata->BIP_tree);
cout = setRangeToFarestNeighbour(c, nodedata->g2hop, nodedata->BIP_tree);
setRelayNodes(c, nodedata->g2hop, nodedata->BIP_tree, &header->askedToRedirect, &header->needsToBeCovered, c->node);
deleteGraphe(g);
free(g);
call_t c0 = {-1,c->node,-1};
header->energyRem = battery_remaining(&c0) - cout;
nodedata->energiesRem[c->node] = header->energyRem;
}
else
{
// TODO
}
if (SET_HEADER(&cdown, packet, dst) == -1) {
packet_dealloc(packet);
return -1;
}
return 0;
}
