#include <VectorCommunicationCache.h>

Inheritance diagram for inet::physicallayer::VectorCommunicationCache:

Public Member Functions
	VectorCommunicationCache ()

virtual	~VectorCommunicationCache ()

virtual std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. More...

Medium state change notifications
virtual void	addRadio (const IRadio *radio) override

virtual void	removeRadio (const IRadio *radio) override

virtual void	addTransmission (const ITransmission *transmission) override

virtual void	removeTransmission (const ITransmission *transmission) override

Interference cache
virtual void	removeNonInterferingTransmissions () override

Public Member Functions inherited from inet::physicallayer::CommunicationCacheBase
	CommunicationCacheBase ()

virtual	~CommunicationCacheBase ()

virtual std::vector< const ITransmission * > *	computeInterferingTransmissions (const IRadio *radio, const simtime_t startTime, const simtime_t endTime) override

virtual const simtime_t	getCachedInterferenceEndTime (const ITransmission *transmission) override

virtual void	setCachedInterferenceEndTime (const ITransmission *transmission, const simtime_t interferenceEndTime) override

virtual void	removeCachedInterferenceEndTime (const ITransmission *transmission) override

virtual const IRadioFrame *	getCachedFrame (const ITransmission *transmission) override

virtual void	setCachedFrame (const ITransmission transmission, const IRadioFrame frame) override

virtual void	removeCachedFrame (const ITransmission *transmission) override

virtual const IArrival *	getCachedArrival (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedArrival (const IRadio receiver, const ITransmission transmission, const IArrival *arrival) override

virtual void	removeCachedArrival (const IRadio receiver, const ITransmission transmission) override

virtual const Interval *	getCachedInterval (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedInterval (const IRadio receiver, const ITransmission transmission, const Interval *interval) override

virtual void	removeCachedInterval (const IRadio receiver, const ITransmission transmission) override

virtual const IListening *	getCachedListening (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedListening (const IRadio receiver, const ITransmission transmission, const IListening *listening) override

virtual void	removeCachedListening (const IRadio receiver, const ITransmission transmission) override

virtual const IReception *	getCachedReception (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedReception (const IRadio receiver, const ITransmission transmission, const IReception *reception) override

virtual void	removeCachedReception (const IRadio receiver, const ITransmission transmission) override

virtual const IInterference *	getCachedInterference (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedInterference (const IRadio receiver, const ITransmission transmission, const IInterference *interference) override

virtual void	removeCachedInterference (const IRadio receiver, const ITransmission transmission) override

virtual const INoise *	getCachedNoise (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedNoise (const IRadio receiver, const ITransmission transmission, const INoise *noise) override

virtual void	removeCachedNoise (const IRadio receiver, const ITransmission transmission) override

virtual const ISNIR *	getCachedSNIR (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedSNIR (const IRadio receiver, const ITransmission transmission, const ISNIR *snir) override

virtual void	removeCachedSNIR (const IRadio receiver, const ITransmission transmission) override

virtual const IReceptionDecision *	getCachedReceptionDecision (const IRadio receiver, const ITransmission transmission, IRadioSignal::SignalPart part) override

virtual void	setCachedReceptionDecision (const IRadio receiver, const ITransmission transmission, IRadioSignal::SignalPart part, const IReceptionDecision *receptionDecision) override

virtual void	removeCachedReceptionDecision (const IRadio receiver, const ITransmission transmission, IRadioSignal::SignalPart part) override

virtual const IReceptionResult *	getCachedReceptionResult (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedReceptionResult (const IRadio receiver, const ITransmission transmission, const IReceptionResult *receptionResult) override

virtual void	removeCachedReceptionResult (const IRadio receiver, const ITransmission transmission) override

virtual const IRadioFrame *	getCachedFrame (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedFrame (const IRadio receiver, const ITransmission transmission, const IRadioFrame *frame) override

virtual void	removeCachedFrame (const IRadio receiver, const ITransmission transmission) override

Medium state change notifications
Interference cache
Transmission cache
Reception Cache
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
Cache data structures
virtual RadioCacheEntry *	getRadioCacheEntry (const IRadio *radio) override

virtual TransmissionCacheEntry *	getTransmissionCacheEntry (const ITransmission *transmission) override

virtual ReceptionCacheEntry *	getReceptionCacheEntry (const IRadio radio, const ITransmission transmission) override

Cache data structures

Protected Attributes
Cache
int	baseRadioId
	The smallest radio id of all radios on the medium. More...

int	baseTransmissionId
	The smallest transmission id of all ongoing transmissions on the medium. More...

std::vector< TransmissionCacheEntry >	transmissionCache
	Caches intermediate computation results for transmissions. More...

std::vector< RadioCacheEntry >	radioCache
	Caches intermediate computation results for radios. More...

Additional Inherited Members
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 }

Constructor & Destructor Documentation

inet::physicallayer::VectorCommunicationCache::VectorCommunicationCache ( )

                                                    :
     baseRadioId(0),
     baseTransmissionId(0)
 {
 }

inet::physicallayer::VectorCommunicationCache::~VectorCommunicationCache ( )

virtual

 {
     for (auto &transmissionCacheEntry : transmissionCache)
         delete static_cast<std::vector<ReceptionCacheEntry> *>(transmissionCacheEntry.receptionCacheEntries);
 }

Member Function Documentation

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     if (radioCache.size() == 0)
         baseRadioId = radio->getId();
     getRadioCacheEntry(radio);
 }

void inet::physicallayer::VectorCommunicationCache::addTransmission ( const ITransmission * transmission )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     if (transmissionCache.size() == 0)
         baseTransmissionId = transmission->getId();
     getTransmissionCacheEntry(transmission);
 }

VectorCommunicationCache::RadioCacheEntry * inet::physicallayer::VectorCommunicationCache::getRadioCacheEntry ( const IRadio * radio )

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

Referenced by addRadio(), and removeRadio().

 {
     int radioIndex = radio->getId() - baseRadioId;
     if (radioIndex < 0)
         return nullptr;
     else {
         if (radioIndex >= (int)radioCache.size())
             radioCache.resize(radioIndex + 1);
         return &radioCache[radioIndex];
     }
 }

VectorCommunicationCache::ReceptionCacheEntry * inet::physicallayer::VectorCommunicationCache::getReceptionCacheEntry	(	const IRadio *	radio,
		const ITransmission *	transmission
	)

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

 {
     TransmissionCacheEntry *transmissionCacheEntry = getTransmissionCacheEntry(transmission);
     if (transmissionCacheEntry == nullptr)
         return nullptr;
     else {
         std::vector<ReceptionCacheEntry> *receptionCacheEntries = static_cast<std::vector<ReceptionCacheEntry> *>(transmissionCacheEntry->receptionCacheEntries);
         int radioIndex = radio->getId() - baseRadioId;
         if (radioIndex < 0)
             return nullptr;
         else {
             if (radioIndex >= (int)receptionCacheEntries->size())
                 receptionCacheEntries->resize(radioIndex + 1);
             return &(*receptionCacheEntries)[radioIndex];
         }
     }
 }

VectorCommunicationCache::TransmissionCacheEntry * inet::physicallayer::VectorCommunicationCache::getTransmissionCacheEntry ( const ITransmission * transmission )

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

Referenced by addTransmission(), and getReceptionCacheEntry().

 {
     int transmissionIndex = transmission->getId() - baseTransmissionId;
     if (transmissionIndex < 0)
         return nullptr;
     else {
         if (transmissionIndex >= (int)transmissionCache.size())
             transmissionCache.resize(transmissionIndex + 1);
         TransmissionCacheEntry &transmissionCacheEntry = transmissionCache[transmissionIndex];
         if (transmissionCacheEntry.receptionCacheEntries == nullptr)
             transmissionCacheEntry.receptionCacheEntries = new std::vector<ReceptionCacheEntry>(radioCache.size());
         return &transmissionCacheEntry;
     }
 }

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

inlineoverridevirtual

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.

67 { return stream << "VectorCommunicationCache"; }

void inet::physicallayer::VectorCommunicationCache::removeNonInterferingTransmissions ( )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     const simtime_t now = simTime();
     size_t transmissionIndex = 0;
     while (transmissionIndex < transmissionCache.size() && transmissionCache[transmissionIndex].interferenceEndTime <= now)
         transmissionIndex++;
     for (auto it = transmissionCache.cbegin(); it != transmissionCache.cbegin() + transmissionIndex; it++) {
         const TransmissionCacheEntry &transmissionCacheEntry = *it;
         if (transmissionCacheEntry.receptionCacheEntries != nullptr) {
             std::vector<ReceptionCacheEntry> *receptionCacheEntries = static_cast<std::vector<ReceptionCacheEntry> *>(transmissionCacheEntry.receptionCacheEntries);
             auto radioIt = radioCache.cbegin();
             auto receptionIt = receptionCacheEntries->cbegin();
             while (radioIt != radioCache.cend() && receptionIt != receptionCacheEntries->cend()) {
                 const RadioCacheEntry &radioCacheEntry = *radioIt;
                 const ReceptionCacheEntry &recpeionCacheEntry = *receptionIt;
                 const Interval *interval = recpeionCacheEntry.interval;
                 if (interval != nullptr)
                     radioCacheEntry.receptionIntervals->deleteNode(interval);
                 radioIt++;
                 receptionIt++;
             }
         }
     }
     baseTransmissionId += transmissionIndex;
     for (auto it = transmissionCache.cbegin(); it != transmissionCache.cbegin() + transmissionIndex; it++) {
         const TransmissionCacheEntry &transmissionCacheEntry = *it;
         delete static_cast<std::vector<ReceptionCacheEntry> *>(transmissionCacheEntry.receptionCacheEntries);
     }
     transmissionCache.erase(transmissionCache.begin(), transmissionCache.begin() + transmissionIndex);
 }

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     getRadioCacheEntry(radio)->stale = true;
     int radioCount = 0;
     while (radioCount < (int)radioCache.size() && radioCache[radioCount].stale)
         radioCount++;
     if (radioCount != 0) {
         baseRadioId += radioCount;
         radioCache.erase(radioCache.begin(), radioCache.begin() + radioCount);
         for (auto &transmissionCacheEntry : transmissionCache) {
             std::vector<ReceptionCacheEntry> *receptionCacheEntries = static_cast<std::vector<ReceptionCacheEntry> *>(transmissionCacheEntry.receptionCacheEntries);
             if (receptionCacheEntries != nullptr)
                 receptionCacheEntries->erase(receptionCacheEntries->begin(), receptionCacheEntries->begin() + radioCount);
         }
     }
 }

void inet::physicallayer::VectorCommunicationCache::removeTransmission ( const ITransmission * transmission )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

116 {

117 }

Member Data Documentation

int inet::physicallayer::VectorCommunicationCache::baseRadioId

protected

The smallest radio id of all radios on the medium.

Referenced by addRadio(), getRadioCacheEntry(), getReceptionCacheEntry(), and removeRadio().

int inet::physicallayer::VectorCommunicationCache::baseTransmissionId

protected

The smallest transmission id of all ongoing transmissions on the medium.

Referenced by addTransmission(), getTransmissionCacheEntry(), and removeNonInterferingTransmissions().

std::vector<RadioCacheEntry> inet::physicallayer::VectorCommunicationCache::radioCache

protected

Caches intermediate computation results for radios.

The vector is indexed by radio id (offset with base transmission id).

Referenced by addRadio(), getRadioCacheEntry(), getTransmissionCacheEntry(), removeNonInterferingTransmissions(), and removeRadio().

std::vector<TransmissionCacheEntry> inet::physicallayer::VectorCommunicationCache::transmissionCache

protected

Caches intermediate computation results for transmissions.

The outer vector is indexed by transmission id (offset with base transmission id) and the inner vector is indexed by radio id. Values that are no longer needed are removed from the beginning only. May contain nullptr values for not yet computed information.

Referenced by addTransmission(), getTransmissionCacheEntry(), removeNonInterferingTransmissions(), removeRadio(), and ~VectorCommunicationCache().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation