#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::physicallayer::IPrintableObject
enum	PrintLevel { PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO, PRINT_LEVEL_COMPLETE = INT_MIN }

Public Member Functions
	QuadTreeNeighborCache ()

	~QuadTreeNeighborCache ()

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	fillQuadTreeWithRadios ()

void	rebuildQuadTree ()

Protected Attributes
QuadTree *	quadTree

Radios	radios

RadioMedium *	radioMedium

cMessage *	rebuildQuadTreeTimer

Coord	constraintAreaMax

Coord	constraintAreaMin

unsigned int	maxNumOfPointsPerQuadrant

double	refillPeriod

double	maxSpeed

Member Typedef Documentation

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

Constructor & Destructor Documentation

inet::physicallayer::QuadTreeNeighborCache::QuadTreeNeighborCache ( )

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

inet::physicallayer::QuadTreeNeighborCache::~QuadTreeNeighborCache ( )

 {
     delete quadTree;
     cancelAndDelete(rebuildQuadTreeTimer);
 }

Member Function Documentation

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())
         scheduleAt(simTime() + 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);
 }

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

protected

Referenced by rebuildQuadTree().

 {
     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");
     }
 }

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

overrideprotectedvirtual

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

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

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         radioMedium = getModuleFromPar<RadioMedium>(par("radioMediumModule"), this);
         rebuildQuadTreeTimer = new cMessage("rebuildQuadTreeTimer");
         refillPeriod = par("refillPeriod");
         maxNumOfPointsPerQuadrant = par("maxNumOfPointsPerQuadrant");
     }
     else if (stage == INITSTAGE_LINK_LAYER_2) {
         constraintAreaMin = radioMedium->getMediumLimitCache()->getMinConstraintArea();
         constraintAreaMax = radioMedium->getMediumLimitCache()->getMaxConstraintArea();
         quadTree = new QuadTree(constraintAreaMin, constraintAreaMax, maxNumOfPointsPerQuadrant, nullptr);
         maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
         rebuildQuadTree();
         scheduleAt(simTime() + refillPeriod, rebuildQuadTreeTimer);
     }
 }

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

inlineoverrideprotectedvirtual

58 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

std::ostream & inet::physicallayer::QuadTreeNeighborCache::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 << "QuadTreeNeighborCache";
     if (level <= PRINT_LEVEL_TRACE)
         stream << ", maxNumOfPointsPerQuadrant = " << maxNumOfPointsPerQuadrant
                << ", refillPeriod = " << refillPeriod
                << ", maxSpeed = " << maxSpeed;
     return stream;
 }

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

protected

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

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

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

overridevirtual

Implements inet::physicallayer::INeighborCache.

 {
     auto it = find(radios.begin(), radios.end(), 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());
 }

void inet::physicallayer::QuadTreeNeighborCache::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.

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