ProbabilisticBroadcast.h

/*
 * ProbabilisticBroadcast.h
 *
 *  Created on: Nov 4, 2008
 *      Author: Damien Piguet
 */

#ifndef PROBABILISTICBROADCAST_H_
#define PROBABILISTICBROADCAST_H_

#include <fstream>
#include <set>
#include <map>

#include "ProbabilisticBroadcastPkt_m.h"
#include "MacPkt_m.h"
#include "BaseMacLayer.h"
#include "SimTracer.h"
#include "ProbBcastNetwControlInfo.h"
#include "MacToNetwControlInfo.h"
#include "NetwToMacControlInfo.h"
#include "BaseNetwLayer.h"

using namespace std;


class ProbabilisticBroadcast : public BaseNetwLayer
{
public:


    virtual void initialize(int);

    virtual void finish();

protected:
  enum messagesTypes {
    UNKNOWN=0,
    BROADCAST_TIMER,
    NEIGHBOR_TIMER,
    BETA_TIMER,
    DATA
  };

  typedef struct tMsgDesc {
    ProbabilisticBroadcastPkt* pkt;
    int                        nbBcast;     // number of times the present node has passed the
                                            // message through a broadcast attempt.
    bool                       initialSend; // true if message to be sent for first
                                            // time by its creator.
  } tMsgDesc;

  typedef set<unsigned int> MsgIdSet;
  typedef multimap<simtime_t, tMsgDesc*> TimeMsgMap;

    virtual void handleUpperMsg(cMessage* msg);

    virtual void handleLowerMsg(cMessage* msg);

    virtual void handleSelfMsg(cMessage* msg);

    virtual void handleLowerControl(cMessage* msg);

    virtual bool messageKnown(unsigned int msgId);

    virtual bool debugMessageKnown(unsigned int msgId);

  virtual void insertMessage(simtime_t bcastDelay, tMsgDesc* msgDesc);

  virtual tMsgDesc* popFirstMessageUpdateQueue(void);

  virtual ProbabilisticBroadcastPkt* encapsMsg(cMessage* msg);

  virtual cMessage* decapsMsg(ProbabilisticBroadcastPkt *msg);

  virtual void insertNewMessage(ProbabilisticBroadcastPkt* pkt, bool iAmInitialSender = false);

  simtime_t broadcastPeriod;

  double beta;


  /*
   * @brief Default time to live for packets to send.
   */
  simtime_t timeToLive;

  static long id_counter;

  static long getNextID() {
    long nextID = id_counter;
    id_counter++;
    return nextID;
  }
  int maxNbBcast;

  int maxFirstBcastBackoff;

  simtime_t timeInQueueAfterDeath;

    int headerLength;

    bool trace, stats, debug;

    // perform broadcast attempt for the first message in the list each time it expires
    cMessage* broadcastTimer;

    // we use two containers: a set which stores the ID's of the messages which are kept
    // in memory and a multimap which stores a pair <Key, Value> where Key is the next
    // broadcasting attempt time of the message and Value is a pointer to the message
    // (see typedef's above).
    MsgIdSet knownMsgIds;
    TimeMsgMap msgQueue;
    MsgIdSet debugMsgIdSet;

    // keep MAC broadcast address at class level:
    int convertedMacBroadcastAddr;

    // variables for statistics
    long nbDataPacketsReceived; // total number of received packets from lower layer
    long nbDataPacketsSent;
    long nbHops;
    int debugNbMessageKnown;
    long nbDataPacketsForwarded;
    // records the time packets take between submission to MAC layer and reception at
    // networking layer (over one hop).
    cOutVector oneHopLatencies;
};

#endif /* PROBABILISTICBROADCAST_H_ */