#include <MapCommunicationCache.h>

Inheritance diagram for inet::physicallayer::MapCommunicationCache:

Classes
class	MapTransmissionCacheEntry

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

virtual int	getNumRadios () 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

virtual int	getNumTransmissions () const override

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

Public Member Functions inherited from inet::physicallayer::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 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
std::map< int, RadioCacheEntry >	radioCache
	Caches intermediate computation results for radios. More...

std::map< int, MapTransmissionCacheEntry >	transmissionCache
	Caches intermediate computation results for transmissions. More...

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

virtual MapTransmissionCacheEntry *	getTransmissionCacheEntry (const ITransmission *transmission) override

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

virtual	~MapCommunicationCache ()

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

◆ ~MapCommunicationCache()

inet::physicallayer::MapCommunicationCache::~MapCommunicationCache ( )

virtual

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

Member Function Documentation

◆ addRadio()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     auto radioCacheEntry = getRadioCacheEntry(radio);
     radioCacheEntry->radio = radio;
 }

◆ addTransmission()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     auto transmissionCacheEntry = getTransmissionCacheEntry(transmission);
     transmissionCacheEntry->transmission = transmission;
     transmissionCacheEntry->receptionCacheEntries = new std::map<int, ReceptionCacheEntry>();
 }

◆ getNumRadios()

int inet::physicallayer::MapCommunicationCache::getNumRadios ( ) const

overridevirtual

Reimplemented from inet::physicallayer::CommunicationCacheBase.

 {
     return radioCache.size();
 }

◆ getNumTransmissions()

int inet::physicallayer::MapCommunicationCache::getNumTransmissions ( ) const

overridevirtual

Reimplemented from inet::physicallayer::CommunicationCacheBase.

 {
     return transmissionCache.size();
 }

◆ getRadio()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     auto it = radioCache.find(id);
     return (it == radioCache.end()) ? nullptr : it->second.radio;
 }

◆ getRadioCacheEntry()

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

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

 {
     return &radioCache[radio->getId()];
 }

Referenced by addRadio().

◆ getReceptionCacheEntry()

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

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

 {
     MapTransmissionCacheEntry *transmissionCacheEntry = getTransmissionCacheEntry(transmission);
     auto receptionCacheEntries = transmissionCacheEntry->receptionCacheEntries;
     return &(*receptionCacheEntries)[radio->getId()];
 }

◆ getTransmission()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     auto it = transmissionCache.find(id);
     return (it == transmissionCache.end()) ? nullptr : it->second.transmission;
 }

◆ getTransmissionCacheEntry()

MapCommunicationCache::MapTransmissionCacheEntry * inet::physicallayer::MapCommunicationCache::getTransmissionCacheEntry ( const ITransmission * transmission )

overrideprotectedvirtual

Implements inet::physicallayer::CommunicationCacheBase.

 {
     return &transmissionCache[transmission->getId()];
 }

Referenced by addTransmission(), and getReceptionCacheEntry().

◆ mapRadios()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     for (auto& it : radioCache)
         f(it.second.radio);
 }

◆ mapTransmissions()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     for (auto& it : transmissionCache)
         f(it.second.transmission);
 }

◆ printToStream()

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

inlineoverridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

51 { return stream << "MapCommunicationCache"; }

◆ removeNonInterferingTransmissions()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     int transmissionCount = 0;
     const simtime_t now = simTime();
     for (auto it = transmissionCache.begin(); it != transmissionCache.end();) {
         MapTransmissionCacheEntry& transmissionCacheEntry = it->second;
         if (transmissionCacheEntry.interferenceEndTime <= now) {
             if (transmissionCacheEntry.receptionCacheEntries != nullptr) {
                 std::map<int, ReceptionCacheEntry> *receptionCacheEntries = transmissionCacheEntry.receptionCacheEntries;
                 for (auto radioIt = radioCache.cbegin(); radioIt != radioCache.cend(); radioIt++) {
                     const RadioCacheEntry& radioCacheEntry = radioIt->second;
                     auto receptionIt = receptionCacheEntries->find(radioIt->first);
                     if (receptionIt != receptionCacheEntries->cend()) {
                         const ReceptionCacheEntry& receptionCacheEntry = receptionIt->second;
                         const IntervalTree::Interval *interval = receptionCacheEntry.interval;
                         if (interval != nullptr)
                             radioCacheEntry.receptionIntervals->deleteNode(interval);
                     }
                 }
                 delete receptionCacheEntries;
                 transmissionCacheEntry.receptionCacheEntries = nullptr;
             }
             f(transmissionCacheEntry.transmission);
             transmissionCache.erase(it++);
             transmissionCount++;
         }
         else
             it++;
     }
     EV_DEBUG << "Removed " << transmissionCount << " non interfering transmissions\n";
 }

◆ removeRadio()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     auto radioId = radio->getId();
     auto it = radioCache.find(radioId);
     if (it != radioCache.end())
         radioCache.erase(it);
     for (auto& it : transmissionCache) {
         std::map<int, ReceptionCacheEntry> *receptionCacheEntries = it.second.receptionCacheEntries;
         if (receptionCacheEntries != nullptr) {
             auto jt = receptionCacheEntries->find(radioId);
             if (jt != receptionCacheEntries->end())
                 receptionCacheEntries->erase(jt);
         }
     }
 }

◆ removeTransmission()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

 {
     auto it = transmissionCache.find(transmission->getId());
     if (it != transmissionCache.end()) {
         MapTransmissionCacheEntry& transmissionCacheEntry = it->second;
         std::map<int, ReceptionCacheEntry> *receptionCacheEntries = transmissionCacheEntry.receptionCacheEntries;
         if (receptionCacheEntries != nullptr) {
             for (auto& jt : *receptionCacheEntries) {
                 const RadioCacheEntry& radioCacheEntry = radioCache[jt.first];
                 const ReceptionCacheEntry& receptionCacheEntry = jt.second;
                 const IntervalTree::Interval *interval = receptionCacheEntry.interval;
                 if (interval != nullptr)
                     radioCacheEntry.receptionIntervals->deleteNode(interval);
             }
         }
         delete transmissionCacheEntry.receptionCacheEntries;
         transmissionCacheEntry.receptionCacheEntries = nullptr;
         transmissionCache.erase(it);
     }
     else
         throw cRuntimeError("Cannot find transmission");
 }

Member Data Documentation

◆ radioCache

std::map<int, RadioCacheEntry> inet::physicallayer::MapCommunicationCache::radioCache

protected

Caches intermediate computation results for radios.

Referenced by getNumRadios(), getRadio(), getRadioCacheEntry(), mapRadios(), removeNonInterferingTransmissions(), removeRadio(), and removeTransmission().

◆ transmissionCache

std::map<int, MapTransmissionCacheEntry> inet::physicallayer::MapCommunicationCache::transmissionCache

protected

Caches intermediate computation results for transmissions.

Referenced by getNumTransmissions(), getTransmission(), getTransmissionCacheEntry(), mapTransmissions(), removeNonInterferingTransmissions(), removeRadio(), removeTransmission(), and ~MapCommunicationCache().

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

◆ ~MapCommunicationCache()

Member Function Documentation

◆ addRadio()

◆ addTransmission()

◆ getNumRadios()

◆ getNumTransmissions()

◆ getRadio()

◆ getRadioCacheEntry()

◆ getReceptionCacheEntry()

◆ getTransmission()

◆ getTransmissionCacheEntry()

◆ mapRadios()

◆ mapTransmissions()

◆ printToStream()

◆ removeNonInterferingTransmissions()

◆ removeRadio()

◆ removeTransmission()

Member Data Documentation

◆ radioCache

◆ transmissionCache