m2.mbcp/src/lowreceiver_ab.cc

/* vim: set sw=4 ts=4 si et: */
#include "lowreceiver.h"
#include "messagecell_ab.h"

void LowReceiver::manage_abcast(Message * mesg) {
    static std::list<MessageCellAb *> fifo_get;
    static std::list<MessageCellAb *> fifo_send;
    static std::list<Message *> fifo_deliverable;

    //FIXME: maintenir les temps dans les listes get/send/deliverable
    //       pour savoir si l'on peut délivrer les messages dans "deliverable"
    static short minimum_waiting_stamp = -1 ;
    static short maximum_deliverable_stamp = -1;
    static short minimum_deliverable_stamp = -1;

    std::list<MessageCellAb *>::iterator iter;
    std::list<MessageCellAb *>::iterator iter2;
    printf("LowReceiver::manage_abcast -- init\n");

    // identifiant = horloge + id_site_emeteur
    bool iAmTheEmitter = false;
    bool firstSeenMessage = true;

    if (mesg->getStamp().getIndex() == _group.getIndex()){
        iAmTheEmitter = true;
    }

    if (iAmTheEmitter){
        printf("LowReceiver::manage_abcast - Received my own message \n");
        //on faire la gestion du abcast/send ici, c'est plus simple que
        //de partager une variable+mutex avec le sender

        // chercher si l'on a déja recu ce message
        MessageCellAb * cell = NULL;
        for (iter = fifo_send.begin(); iter != fifo_send.end(); iter++){
            //on fait pointer cell sur la cellule si égale a l'id du message
            //courant
            MessageCellAb * cur = *iter;
            if (cur->message == mesg){
                printf("LowReceiver::manage_abcast -- message seen\n");
                firstSeenMessage = false;
                cell = cur;
                break;
            }
        }
        if (firstSeenMessage){
            //sinon on le crée
            printf("LowReceiver::manage_abcast -- message is first\n");
            cell = new MessageCellAb();
            cell->message = new Message(*mesg); 
            //et on l'ajoute au fifo
            fifo_send.push_back(cell);
        }

        // comparer le timestamp max a ceux que l'on recoit
        cell->count += 1;
        if (cell->count == _group.getCount()){
            // broadcaster le nouveau timestamp du message
            //
            // le message a broadcaster est exactement le message max
            // reçu... mais bon... on le reconstruit quand même
            // A AMéLIORER...

            TimeStamp st = cell->message->getStamp();
            // on construit un message identifié par le timestamp original
            // et contenant le timestamp final choisi
            Message * nMsg = new Message(Protocol::TYPE_ABCAST,
                    st,
                    cell->maximum->getRaw(),
                    cell->maximum->getRawSize());
            _group.broadcast(*nMsg);
            
            Message * deliverableMesg = new Message(Protocol::TYPE_ABCAST,
                    st,
                    cell->message->getData(),
                    cell->message->getDataSize());
            
            // enfiler dans la liste des messager a délivrer, avec l'estampille finale.
            fifo_deliverable.push_back(deliverableMesg);

            // FIXME: retirer le message_cell de la liste des send...
        }
    } else {
        printf("LowReceiver::manage_abcast - Received a message from a friend\n");
        // on cherche si l'on a déja croisé le message
        MessageCellAb * cell = NULL;
        for (iter = fifo_get.begin(); iter != fifo_get.end(); iter++){
            MessageCellAb * cur = *iter;
            if (cur->message == mesg) {
                printf("LowReceiver::manage_abcast -- message seen\n");
                firstSeenMessage = false;
                cell = cur;
                break;
            }
        }

        if (firstSeenMessage){
            printf("LowReceiver::manage_abcast -- message is first\n");
            // si le message est vu pour la premiere fois:
            // - on l'ajoute dans la liste d'attente
            cell = new MessageCellAb();
            cell->message = new Message(*mesg);
            cell->type = MessageCellAb::TYPE_TEMPORARY;		

            fifo_get.push_back(cell);

            TimeStamp st = cell->message->getStamp();
            TimeStamp nSt = _clock.inc();

            // - on retourne une estampille(reception) à l'emeteur
            //   via un message identifié comme le message courant mais contenant
            //   l'estampille...
            Message * nMsg = new Message(Protocol::TYPE_ABCAST,
                    st,
                    nSt.getRaw(),
                    nSt.getRawSize());

            _group.sendto(*(cell->message), cell->message->getStamp().getIndex());

        } else {
            // sinon 
            // - l'estampille du message est mise à jour
            TimeStamp st = mesg->getStamp();
            TimeStamp nSt = _clock.inc();

            Message * nMsg = new Message(Protocol::TYPE_ABCAST,
                    st,
                    cell->message->getData(),
                    cell->message->getDataSize());

            // - le message est ajouté dans deliverable
            fifo_deliverable.push_back(nMsg);

            // Trouver l'iterator
            for (iter = fifo_get.begin(); iter != fifo_get.end(); iter++){
                MessageCellAb * itCell = *iter;
                if (cell == itCell){
                    iter2 = iter;
                }
            }
            // normalement on a trouvé l'iterateur...
            fifo_get.erase(iter2);

        }
    }

    // FIXME: prendre les messages à délivrer, dans le bon ordre, et les délivrer...
    
}