inet::physicallayer::QuadTreeNeighborCache Class Reference

#include <QuadTreeNeighborCache.h>

Inheritance diagram for inet::physicallayer::QuadTreeNeighborCache:

Classes
class	QuadTreeNeighborCacheVisitor

Public Types
typedef std::vector< const IRadio * >	Radios
Public Types inherited from inet::IPrintableObject
enum	PrintLevel {   PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO,   PRINT_LEVEL_COMPLETE = INT_MIN }
enum	PrintFlag { PRINT_FLAG_FORMATTED = (1 << 0), PRINT_FLAG_MULTILINE = (1 << 1) }

Public Member Functions
	QuadTreeNeighborCache ()
	~QuadTreeNeighborCache ()
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) 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 IWirelessSignal *signal, 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::IPrintableObject
virtual	~IPrintableObject ()
virtual std::string	printToString () const
virtual std::string	printToString (int level, int evFlags=0) const
virtual std::string	getInfoStringRepresentation (int evFlags=0) const
virtual std::string	getDetailStringRepresentation (int evFlags=0) const
virtual std::string	getDebugStringRepresentation (int evFlags=0) const
virtual std::string	getTraceStringRepresentation (int evFlags=0) const
virtual std::string	getCompleteStringRepresentation (int evFlags=0) const

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
void	fillQuadTreeWithRadios ()
void	rebuildQuadTree ()

Protected Attributes
QuadTree *	quadTree
Radios	radios
ModuleRefByPar< RadioMedium >	radioMedium
cMessage *	rebuildQuadTreeTimer
Coord	constraintAreaMax
Coord	constraintAreaMin
unsigned int	maxNumOfPointsPerQuadrant
double	refillPeriod
double	maxSpeed

Member Typedef Documentation

Radios

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

Constructor & Destructor Documentation

QuadTreeNeighborCache()

inet::physicallayer::QuadTreeNeighborCache::QuadTreeNeighborCache

(

)

                                             :
    quadTree(nullptr),
    rebuildQuadTreeTimer(nullptr),
    constraintAreaMax(Coord::NIL),
    constraintAreaMin(Coord::NIL),
    maxNumOfPointsPerQuadrant(0),
    refillPeriod(NaN),
    maxSpeed(NaN)
{
}

~QuadTreeNeighborCache()

inet::physicallayer::QuadTreeNeighborCache::~QuadTreeNeighborCache

(

)

{
    delete quadTree;
    cancelAndDelete(rebuildQuadTreeTimer);
}

Member Function Documentation

addRadio()

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

overridevirtual

Implements inet::physicallayer::INeighborCache.

{
    radios.push_back(radio);
    Coord radioPos = radio->getAntenna()->getMobility()->getCurrentPosition();
    maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
    if (maxSpeed != 0 && !rebuildQuadTreeTimer->isScheduled() && initialized())
        scheduleAfter(refillPeriod, rebuildQuadTreeTimer);
    Coord newConstraintAreaMin = radioMedium->getMediumLimitCache()->getMinConstraintArea();
    Coord newConstraintAreaMax = radioMedium->getMediumLimitCache()->getMaxConstraintArea();
    // If the constraintArea changed we must rebuild the QuadTree
    if (newConstraintAreaMin != constraintAreaMin || newConstraintAreaMax != constraintAreaMax) {
        constraintAreaMin = newConstraintAreaMin;
        constraintAreaMax = newConstraintAreaMax;
        if (initialized())
            rebuildQuadTree();
    }
    else if (initialized())
        quadTree->insert(check_and_cast<const cObject *>(radio), radioPos);
}

fillQuadTreeWithRadios()

void inet::physicallayer::QuadTreeNeighborCache::fillQuadTreeWithRadios ( )

protected

{
    for (auto& elem : radios) {
        Coord radioPos = elem->getAntenna()->getMobility()->getCurrentPosition();
        if (!quadTree->insert(check_and_cast<const cObject *>(elem), radioPos))
            throw cRuntimeError("Unsuccessful QuadTree building");
    }
}

Referenced by rebuildQuadTree().

handleMessage()

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

overrideprotectedvirtual

{
    if (!msg->isSelfMessage())
        throw cRuntimeError("This module only handles self messages");
    rebuildQuadTree();
    scheduleAfter(refillPeriod, msg);
}

initialize()

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        radioMedium.reference(this, "radioMediumModule", true);
        rebuildQuadTreeTimer = new cMessage("rebuildQuadTreeTimer");
        refillPeriod = par("refillPeriod");
        maxNumOfPointsPerQuadrant = par("maxNumOfPointsPerQuadrant");
    }
    else if (stage == INITSTAGE_PHYSICAL_LAYER_NEIGHBOR_CACHE) {
        constraintAreaMin = radioMedium->getMediumLimitCache()->getMinConstraintArea();
        constraintAreaMax = radioMedium->getMediumLimitCache()->getMaxConstraintArea();
        quadTree = new QuadTree(constraintAreaMin, constraintAreaMax, maxNumOfPointsPerQuadrant, nullptr);
        maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
        rebuildQuadTree();
        scheduleAfter(refillPeriod, rebuildQuadTreeTimer);
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

printToStream()

std::ostream & inet::physicallayer::QuadTreeNeighborCache::printToStream ( std::ostream &  stream, int  level, int  evFlags = 0  ) const

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

{
    stream << "QuadTreeNeighborCache";
    if (level <= PRINT_LEVEL_TRACE)
        stream << EV_FIELD(maxNumOfPointsPerQuadrant)
               << EV_FIELD(refillPeriod)
               << EV_FIELD(maxSpeed);
    return stream;
}

rebuildQuadTree()

void inet::physicallayer::QuadTreeNeighborCache::rebuildQuadTree ( )

protected

{
    delete quadTree;
    quadTree = new QuadTree(constraintAreaMin, constraintAreaMax, maxNumOfPointsPerQuadrant, nullptr);
    fillQuadTreeWithRadios();
}

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

removeRadio()

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

overridevirtual

Implements inet::physicallayer::INeighborCache.

{
    auto it = find(radios, radio);
    if (it != radios.end()) {
        radios.erase(it);
        Coord newConstraintAreaMin = radioMedium->getMediumLimitCache()->getMinConstraintArea();
        Coord newConstraintAreaMax = radioMedium->getMediumLimitCache()->getMaxConstraintArea();
        if (newConstraintAreaMin != constraintAreaMin || newConstraintAreaMax != constraintAreaMax) {
            constraintAreaMin = newConstraintAreaMin;
            constraintAreaMax = newConstraintAreaMax;
            if (initialized())
                rebuildQuadTree();
        }
        else if (initialized())
            quadTree->remove(check_and_cast<const cObject *>(radio));
        maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
        if (maxSpeed == 0 && initialized())
            cancelEvent(rebuildQuadTreeTimer);
    }
    else
        throw cRuntimeError("You can't remove radio: %d because it is not in our radio container", radio->getId());
}

sendToNeighbors()

void inet::physicallayer::QuadTreeNeighborCache::sendToNeighbors ( IRadio *  transmitter, const IWirelessSignal *  signal, double  range  ) const

overridevirtual

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

Implements inet::physicallayer::INeighborCache.

{
    double radius = range + refillPeriod * maxSpeed;
    Coord transmitterPos = transmitter->getAntenna()->getMobility()->getCurrentPosition();
    QuadTreeNeighborCacheVisitor visitor(radioMedium, transmitter, signal);
    quadTree->rangeQuery(transmitterPos, radius, &visitor);
}

Member Data Documentation

constraintAreaMax

Coord inet::physicallayer::QuadTreeNeighborCache::constraintAreaMax

protected

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

constraintAreaMin

Coord inet::physicallayer::QuadTreeNeighborCache::constraintAreaMin

protected

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

maxNumOfPointsPerQuadrant

unsigned int inet::physicallayer::QuadTreeNeighborCache::maxNumOfPointsPerQuadrant

protected

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

maxSpeed

double inet::physicallayer::QuadTreeNeighborCache::maxSpeed

protected

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

quadTree

QuadTree* inet::physicallayer::QuadTreeNeighborCache::quadTree

protected

Referenced by addRadio(), fillQuadTreeWithRadios(), initialize(), rebuildQuadTree(), removeRadio(), sendToNeighbors(), and ~QuadTreeNeighborCache().

radioMedium

ModuleRefByPar<RadioMedium> inet::physicallayer::QuadTreeNeighborCache::radioMedium

protected

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

radios

Radios inet::physicallayer::QuadTreeNeighborCache::radios

protected

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

rebuildQuadTreeTimer

cMessage* inet::physicallayer::QuadTreeNeighborCache::rebuildQuadTreeTimer

protected

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

refillPeriod

double inet::physicallayer::QuadTreeNeighborCache::refillPeriod

protected

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

---

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

• QuadTreeNeighborCache.h
• QuadTreeNeighborCache.cc