#include <VectorCommunicationCache.h>

Inheritance diagram for inet::physicallayer::VectorCommunicationCache:

Classes
class	VectorTransmissionCacheEntry

Public Member Functions
Radio cache
virtual void	addRadio (const IRadio *radio) override

virtual void	removeRadio (const IRadio *radio) override

virtual const IRadio *	getRadio (int id) const override

virtual void	mapRadios (std::function< void(const IRadio *)> f) const override

Transmission cache
virtual void	addTransmission (const ITransmission *transmission) override

virtual void	removeTransmission (const ITransmission *transmission) override

virtual const ITransmission *	getTransmission (int id) const override

virtual void	mapTransmissions (std::function< void(const ITransmission *)> f) const override

Interference cache
virtual void	removeNonInterferingTransmissions (std::function< void(const ITransmission *transmission)> f) override

Public Member Functions inherited from inet::physicallayer::CommunicationCacheBase
virtual int	getNumRadios () const override

virtual int	getNumTransmissions () const override

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 IWirelessSignal *	getCachedSignal (const ITransmission *transmission) override

virtual void	setCachedSignal (const ITransmission transmission, const IWirelessSignal signal) override

virtual void	removeCachedSignal (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 IntervalTree::Interval *	getCachedInterval (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedInterval (const IRadio receiver, const ITransmission transmission, const IntervalTree::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 IWirelessSignal *	getCachedSignal (const IRadio receiver, const ITransmission transmission) override

virtual void	setCachedSignal (const IRadio receiver, const ITransmission transmission, const IWirelessSignal *signal) override

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

Public Member Functions inherited from inet::physicallayer::ICommunicationCache
virtual	~ICommunicationCache ()

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 Attributes
Cache
int	baseRadioId = -1
	The smallest radio id of all radios on the medium. More...

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

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

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

Cache data structures
virtual RadioCacheEntry *	getRadioCacheEntry (const IRadio *radio) override

virtual VectorTransmissionCacheEntry *	getTransmissionCacheEntry (const ITransmission *transmission) override

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

virtual	~VectorCommunicationCache ()

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

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

Cache data structures

Constructor & Destructor Documentation

◆ ~VectorCommunicationCache()

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

virtual

 {
     for (auto& transmissionCacheEntry : transmissionCache)
         delete transmissionCacheEntry.receptionCacheEntries;
 }

Member Function Documentation

◆ addRadio()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     int radioId = radio->getId();
     if (baseRadioId == -1)
         baseRadioId = radioId;
     int radioIndex = radio->getId() - baseRadioId;
     if (radioIndex < 0) {
         radioCache.insert(radioCache.begin(), -radioIndex, RadioCacheEntry());
         for (auto& transmissionCacheEntry : transmissionCache) {
             std::vector<ReceptionCacheEntry> *receptionCacheEntries = transmissionCacheEntry.receptionCacheEntries;
             if (receptionCacheEntries != nullptr)
                 receptionCacheEntries->insert(receptionCacheEntries->begin(), -radioIndex, ReceptionCacheEntry());
         }
         baseRadioId = radioId;
     }
     else if (radioIndex >= (int)radioCache.size())
         radioCache.resize(radioIndex + 1);
     auto radioCacheEntry = getRadioCacheEntry(radio);
     radioCacheEntry->radio = radio;
 }

◆ addTransmission()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     int transmissionId = transmission->getId();
     if (baseTransmissionId == -1)
         baseTransmissionId = transmissionId;
     int transmissionIndex = transmission->getId() - baseTransmissionId;
     if (transmissionIndex < 0) {
         transmissionCache.insert(transmissionCache.begin(), -transmissionIndex, VectorTransmissionCacheEntry());
         baseTransmissionId = transmissionId;
     }
     else if (transmissionIndex >= (int)transmissionCache.size())
         transmissionCache.resize(transmissionIndex + 1);
     auto transmissionCacheEntry = getTransmissionCacheEntry(transmission);
     transmissionCacheEntry->transmission = transmission;
     transmissionCacheEntry->receptionCacheEntries = new std::vector<ReceptionCacheEntry>(radioCache.size());
 }

◆ getRadio()

const IRadio * inet::physicallayer::VectorCommunicationCache::getRadio ( int id ) const

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     ASSERT(baseRadioId != -1);
     int radioIndex = id - baseRadioId;
     if (0 <= radioIndex && radioIndex < (int)radioCache.size())
         return radioCache[radioIndex].radio;
     else
         return nullptr;
 }

◆ getRadioCacheEntry()

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

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

 {
     ASSERT(baseRadioId != -1);
     int radioIndex = radio->getId() - baseRadioId;
     ASSERT(0 <= radioIndex && radioIndex < (int)radioCache.size());
     return &radioCache[radioIndex];
 }

Referenced by addRadio(), and removeRadio().

◆ getReceptionCacheEntry()

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

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

 {
     VectorTransmissionCacheEntry *transmissionCacheEntry = getTransmissionCacheEntry(transmission);
     if (transmissionCacheEntry == nullptr)
         return nullptr;
     else {
         ASSERT(baseRadioId != -1);
         std::vector<ReceptionCacheEntry> *receptionCacheEntries = 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];
         }
     }
 }

◆ getTransmission()

const ITransmission * inet::physicallayer::VectorCommunicationCache::getTransmission ( int id ) const

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     ASSERT(baseTransmissionId != -1);
     int transmissionIndex = id - baseTransmissionId;
     if (0 <= transmissionIndex && transmissionIndex < (int)transmissionCache.size())
         return transmissionCache[transmissionIndex].transmission;
     else
         return nullptr;
 }

◆ getTransmissionCacheEntry()

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

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

 {
     ASSERT(baseTransmissionId != -1);
     int transmissionIndex = transmission->getId() - baseTransmissionId;
     ASSERT(0 <= transmissionIndex && transmissionIndex < (int)transmissionCache.size());
     return &transmissionCache[transmissionIndex];
 }

Referenced by addTransmission(), and getReceptionCacheEntry().

◆ mapRadios()

void inet::physicallayer::VectorCommunicationCache::mapRadios ( std::function< void(const IRadio *)> f ) const

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     for (auto& radioCacheEntry : radioCache)
         if (radioCacheEntry.radio != nullptr)
             f(radioCacheEntry.radio);
 }

◆ mapTransmissions()

void inet::physicallayer::VectorCommunicationCache::mapTransmissions ( std::function< void(const ITransmission *)> f ) const

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     for (auto& transmissionCacheEntry : transmissionCache)
         if (transmissionCacheEntry.transmission != nullptr)
             f(transmissionCacheEntry.transmission);
 }

◆ printToStream()

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

inlineoverridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

64 { return stream << "VectorCommunicationCache"; }

◆ removeNonInterferingTransmissions()

void inet::physicallayer::VectorCommunicationCache::removeNonInterferingTransmissions ( std::function< void(const ITransmission *transmission)> f )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     const simtime_t now = simTime();
     size_t transmissionIndex = 0;
     for (auto it = transmissionCache.begin(); it != transmissionCache.end(); ++it) {
         VectorTransmissionCacheEntry& transmissionCacheEntry = *it;
         if (transmissionCacheEntry.interferenceEndTime <= now) {
             transmissionIndex++;
             if (transmissionCacheEntry.receptionCacheEntries != nullptr) {
                 std::vector<ReceptionCacheEntry> *receptionCacheEntries = transmissionCacheEntry.receptionCacheEntries;
                 auto radioIt = radioCache.cbegin();
                 auto receptionIt = receptionCacheEntries->cbegin();
                 while (radioIt != radioCache.cend() && receptionIt != receptionCacheEntries->cend()) {
                     const RadioCacheEntry& radioCacheEntry = *radioIt;
                     const ReceptionCacheEntry& receptionCacheEntry = *receptionIt;
                     const IntervalTree::Interval *interval = receptionCacheEntry.interval;
                     if (interval != nullptr)
                         radioCacheEntry.receptionIntervals->deleteNode(interval);
                     radioIt++;
                     receptionIt++;
                 }
                 delete receptionCacheEntries;
                 transmissionCacheEntry.receptionCacheEntries = nullptr;
             }
             if (transmissionCacheEntry.transmission != nullptr)
                 f(transmissionCacheEntry.transmission);
         }
         else
             break;
     }
     ASSERT(baseTransmissionId != -1);
     baseTransmissionId += transmissionIndex;
     transmissionCache.erase(transmissionCache.begin(), transmissionCache.begin() + transmissionIndex);
     EV_DEBUG << "Removed " << transmissionIndex << " non interfering transmissions\n";
 }

◆ removeRadio()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

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

◆ removeTransmission()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     ASSERT(baseTransmissionId != -1);
     int transmissionIndex = transmission->getId() - baseTransmissionId;
     if (0 <= transmissionIndex && transmissionIndex < (int)transmissionCache.size())
         transmissionCache[transmissionIndex] = VectorTransmissionCacheEntry();
     else
         throw cRuntimeError("Cannot find transmission");
 }

Member Data Documentation

◆ baseRadioId

int inet::physicallayer::VectorCommunicationCache::baseRadioId = -1

protected

The smallest radio id of all radios on the medium.

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

◆ baseTransmissionId

int inet::physicallayer::VectorCommunicationCache::baseTransmissionId = -1

protected

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

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

◆ radioCache

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(), addTransmission(), getRadio(), getRadioCacheEntry(), mapRadios(), removeNonInterferingTransmissions(), and removeRadio().

◆ transmissionCache

std::vector<VectorTransmissionCacheEntry> 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 addRadio(), addTransmission(), getTransmission(), getTransmissionCacheEntry(), mapTransmissions(), removeNonInterferingTransmissions(), removeRadio(), removeTransmission(), and ~VectorCommunicationCache().

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

Classes

Public Member Functions

Protected Attributes

Cache data structures

Additional Inherited Members

Constructor & Destructor Documentation

◆ ~VectorCommunicationCache()

Member Function Documentation

◆ addRadio()

◆ addTransmission()

◆ getRadio()

◆ getRadioCacheEntry()

◆ getReceptionCacheEntry()

◆ getTransmission()

◆ getTransmissionCacheEntry()

◆ mapRadios()

◆ mapTransmissions()

◆ printToStream()

◆ removeNonInterferingTransmissions()

◆ removeRadio()

◆ removeTransmission()

Member Data Documentation

◆ baseRadioId

◆ baseTransmissionId

◆ radioCache

◆ transmissionCache