Ordinal Based Duplicator module. More...

#include <OrdinalBasedDuplicator.h>

Inheritance diagram for inet::OrdinalBasedDuplicator:

Protected Member Functions
virtual void	initialize () override

virtual void	handleMessage (cMessage *msg) override

virtual void	parseVector (const char *vector)

virtual void	finish () override

Protected Attributes
unsigned int	numPackets

unsigned int	numDuplicated

bool	generateFurtherDuplicates

std::vector< unsigned int >	duplicatesVector

Static Protected Attributes
static simsignal_t	rcvdPkSignal = registerSignal("rcvdPk")

static simsignal_t	sentPkSignal = registerSignal("sentPk")

static simsignal_t	duplPkSignal = registerSignal("duplPk")

Detailed Description

Ordinal Based Duplicator module.

Member Function Documentation

void inet::OrdinalBasedDuplicator::finish ( )

overrideprotectedvirtual

109 {

110 }

void inet::OrdinalBasedDuplicator::handleMessage ( cMessage * msg )

overrideprotectedvirtual

 {
     numPackets++;
 
     emit(rcvdPkSignal, msg);
 
     if (generateFurtherDuplicates) {
         if (numPackets == duplicatesVector[0]) {
             EV << "DuplicatesGenerator: Duplicating packet number " << numPackets << " " << msg << endl;
             cMessage *dupmsg = utils::dupPacketAndControlInfo(msg);
             emit(duplPkSignal, dupmsg);
             emit(sentPkSignal, dupmsg);
             send(dupmsg, "out");
             numDuplicated++;
             duplicatesVector.erase(duplicatesVector.begin());
             if (duplicatesVector.size() == 0) {
                 EV << "DuplicatesGenerator: End of duplicatesVector reached." << endl;
                 generateFurtherDuplicates = false;
             }
         }
     }
     emit(sentPkSignal, msg);
     send(msg, "out");
 }

void inet::OrdinalBasedDuplicator::initialize ( )

overrideprotectedvirtual

 {
     numPackets = 0;
     numDuplicated = 0;
     generateFurtherDuplicates = false;
 
     WATCH(numPackets);
     WATCH(numDuplicated);
     WATCH(generateFurtherDuplicates);
 
     const char *vector = par("duplicatesVector");
     parseVector(vector);
 
     if (duplicatesVector.size() == 0) {
         EV << "DuplicatesGenerator: Empty duplicatesVector" << endl;
     }
     else {
         EV << "DuplicatesGenerator: duplicatesVector=" << vector << endl;
         generateFurtherDuplicates = true;
     }
 }

void inet::OrdinalBasedDuplicator::parseVector ( const char * vector )

protectedvirtual

Referenced by initialize().

 {
     const char *v = vector;
     while (*v) {
         // parse packet numbers
         while (isspace(*v))
             v++;
         if (!*v || *v == ';')
             break;
         if (!isdigit(*v))
             throw cRuntimeError("Syntax error in duplicatesVector: packet number expected");
         if (duplicatesVector.size() > 0 && duplicatesVector.back() >= (unsigned int)atoi(v))
             throw cRuntimeError("Syntax error in duplicatesVector: packet numbers in ascending order expected");
 
         duplicatesVector.push_back(atoi(v));
         while (isdigit(*v))
             v++;
 
         // skip delimiter
         while (isspace(*v))
             v++;
         if (!*v)
             break;
         if (*v != ';')
             throw cRuntimeError("Syntax error in duplicatesVector: separator ';' missing");
         v++;
         while (isspace(*v))
             v++;
     }
 }