inet::physicallayer::NeighborListNeighborCache Class Reference

#include <NeighborListNeighborCache.h>

Inheritance diagram for inet::physicallayer::NeighborListNeighborCache:

Classes
struct	RadioEntry

Public Types
typedef std::vector< RadioEntry * >	RadioEntries
typedef std::vector< const IRadio * >	Radios
typedef std::map< const IRadio *, RadioEntry * >	RadioEntryCache
Public Types inherited from inet::physicallayer::IPrintableObject
enum	PrintLevel {   PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO,   PRINT_LEVEL_COMPLETE = INT_MIN }

Public Member Functions
	NeighborListNeighborCache ()
	~NeighborListNeighborCache ()
virtual std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. More...
virtual void	addRadio (const IRadio *radio) override
virtual void	removeRadio (const IRadio *radio) override
virtual void	sendToNeighbors (IRadio *transmitter, const IRadioFrame *frame, double range) const override
	Sends the provided frame (using the radio medium) to all neighbors within the given range. More...
Public Member Functions inherited from inet::physicallayer::IPrintableObject
virtual	~IPrintableObject ()
virtual std::string	getInfoStringRepresentation () const
virtual std::string	getDetailStringRepresentation () const
virtual std::string	getDebugStringRepresentation () const
virtual std::string	getTraceStringRepresentation () const
virtual std::string	getCompleteStringRepresentation () const

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
void	updateNeighborList (RadioEntry *radioEntry)
void	updateNeighborLists ()
void	removeRadioFromNeighborLists (const IRadio *radio)

Protected Attributes
RadioMedium *	radioMedium
RadioEntries	radios
cMessage *	updateNeighborListsTimer
RadioEntryCache	radioToEntry
double	refillPeriod
double	range
double	maxSpeed

Member Typedef Documentation

typedef std::vector<RadioEntry *> inet::physicallayer::NeighborListNeighborCache::RadioEntries

typedef std::map<const IRadio *, RadioEntry *> inet::physicallayer::NeighborListNeighborCache::RadioEntryCache

typedef std::vector<const IRadio *> inet::physicallayer::NeighborListNeighborCache::Radios

Constructor & Destructor Documentation

inet::physicallayer::NeighborListNeighborCache::NeighborListNeighborCache

(

)

                                                     :
    radioMedium(nullptr),
    updateNeighborListsTimer(nullptr),
    refillPeriod(NaN),
    range(NaN),
    maxSpeed(NaN)
{
}

inet::physicallayer::NeighborListNeighborCache::~NeighborListNeighborCache

(

)

{
    for (auto & elem : radios)
        delete elem;

    cancelAndDelete(updateNeighborListsTimer);
}

Member Function Documentation

void inet::physicallayer::NeighborListNeighborCache::addRadio ( const IRadio *  radio )

overridevirtual

Implements inet::physicallayer::INeighborCache.

{
    RadioEntry *newEntry = new RadioEntry(radio);
    radios.push_back(newEntry);
    radioToEntry[radio] = newEntry;
    updateNeighborLists();
    maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
    if (maxSpeed != 0 && !updateNeighborListsTimer->isScheduled() && initialized())
        scheduleAt(simTime() + refillPeriod, updateNeighborListsTimer);
}

void inet::physicallayer::NeighborListNeighborCache::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (!msg->isSelfMessage())
        throw cRuntimeError("This module only handles self messages");

    updateNeighborLists();

    scheduleAt(simTime() + refillPeriod, msg);
}

void inet::physicallayer::NeighborListNeighborCache::initialize ( int  stage )

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        radioMedium = getModuleFromPar<RadioMedium>(par("radioMediumModule"), this);
        refillPeriod = par("refillPeriod");
        range = par("range");
        updateNeighborListsTimer = new cMessage("updateNeighborListsTimer");
    }
    else if (stage == INITSTAGE_LINK_LAYER_2) {
        maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
        updateNeighborLists();
        scheduleAt(simTime() + refillPeriod, updateNeighborListsTimer);
    }
}

virtual int inet::physicallayer::NeighborListNeighborCache::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

std::ostream & inet::physicallayer::NeighborListNeighborCache::printToStream ( std::ostream &  stream, int  level  ) const

overridevirtual

Prints this object to the provided output stream.

Function calls to operator<< with pointers or references either const or not are all forwarded to this function.

Reimplemented from inet::physicallayer::IPrintableObject.

{
    stream << "NeighborListNeighborCache";
    if (level <= PRINT_LEVEL_TRACE)
        stream << ", refillPeriod = " << refillPeriod
               << ", range = " << range
               << ", maxSpeed = " << maxSpeed;
    return stream;
}

void inet::physicallayer::NeighborListNeighborCache::removeRadio ( const IRadio *  radio )

overridevirtual

Implements inet::physicallayer::INeighborCache.

{
    auto it = find(radios.begin(), radios.end(), radioToEntry[radio]);
    if (it != radios.end()) {
        removeRadioFromNeighborLists(radio);
        radios.erase(it);
        maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
        if (maxSpeed == 0 && initialized())
            cancelEvent(updateNeighborListsTimer);
    }
    else {
        throw cRuntimeError("You can't remove radio: %d because it is not in our radio vector", radio->getId());
    }
}

void inet::physicallayer::NeighborListNeighborCache::removeRadioFromNeighborLists ( const IRadio *  radio )

protected

Referenced by removeRadio().

{
    for (auto & elem : radios) {
        Radios neighborVector = elem->neighborVector;
        auto it = find(neighborVector.begin(), neighborVector.end(), radio);
        if (it != neighborVector.end())
            neighborVector.erase(it);
    }
}

void inet::physicallayer::NeighborListNeighborCache::sendToNeighbors ( IRadio *  transmitter, const IRadioFrame *  frame, double  range  ) const

overridevirtual

Sends the provided frame (using the radio medium) to all neighbors within the given range.

Implements inet::physicallayer::INeighborCache.

{
    if (this->range < range)
        throw cRuntimeError("The transmitter's (id: %d) range is bigger then the cache range", transmitter->getId());

    RadioEntryCache::const_iterator it = radioToEntry.find(transmitter);
    if (it == radioToEntry.end())
        throw cRuntimeError("Transmitter is not found");

    RadioEntry *radioEntry = it->second;
    Radios& neighborVector = radioEntry->neighborVector;

    for (auto & elem : neighborVector)
        radioMedium->sendToRadio(transmitter, elem, frame);
}

void inet::physicallayer::NeighborListNeighborCache::updateNeighborList ( RadioEntry *  radioEntry )

protected

Referenced by updateNeighborLists().

{
    IMobility *radioMobility = radioEntry->radio->getAntenna()->getMobility();
    Coord radioPosition = radioMobility->getCurrentPosition();
    double radius = maxSpeed * refillPeriod + range;
    radioEntry->neighborVector.clear();

    for (auto & elem : radios) {
        const IRadio *otherRadio = elem->radio;
        Coord otherEntryPosition = otherRadio->getAntenna()->getMobility()->getCurrentPosition();

        if (otherRadio->getId() != radioEntry->radio->getId() &&
            otherEntryPosition.sqrdist(radioPosition) <= radius * radius)
            radioEntry->neighborVector.push_back(otherRadio);
    }
}

void inet::physicallayer::NeighborListNeighborCache::updateNeighborLists ( )

protected

Referenced by addRadio(), handleMessage(), and initialize().

{
    EV_DETAIL << "Updating the neighbor lists" << endl;
    for (auto & elem : radios)
        updateNeighborList(elem);
}

Member Data Documentation

double inet::physicallayer::NeighborListNeighborCache::maxSpeed

protected

Referenced by addRadio(), initialize(), printToStream(), removeRadio(), and updateNeighborList().

RadioMedium* inet::physicallayer::NeighborListNeighborCache::radioMedium

protected

Referenced by addRadio(), initialize(), removeRadio(), and sendToNeighbors().

RadioEntries inet::physicallayer::NeighborListNeighborCache::radios

protected

Referenced by addRadio(), removeRadio(), removeRadioFromNeighborLists(), updateNeighborList(), updateNeighborLists(), and ~NeighborListNeighborCache().

RadioEntryCache inet::physicallayer::NeighborListNeighborCache::radioToEntry

protected

Referenced by addRadio(), removeRadio(), and sendToNeighbors().

double inet::physicallayer::NeighborListNeighborCache::range

protected

Referenced by initialize(), printToStream(), and updateNeighborList().

double inet::physicallayer::NeighborListNeighborCache::refillPeriod

protected

Referenced by addRadio(), handleMessage(), initialize(), printToStream(), and updateNeighborList().

cMessage* inet::physicallayer::NeighborListNeighborCache::updateNeighborListsTimer

protected

Referenced by addRadio(), initialize(), removeRadio(), and ~NeighborListNeighborCache().

---

The documentation for this class was generated from the following files:

• NeighborListNeighborCache.h
• NeighborListNeighborCache.cc