inet::physicallayer::CommunicationCacheBase Class Reference

#include <CommunicationCacheBase.h>

Inheritance diagram for inet::physicallayer::CommunicationCacheBase:

Classes
class	RadioCacheEntry
	Caches the intermediate computation results related to a radio. More...
class	ReceptionCacheEntry
	Caches the intermediate computation results related to a reception. More...
class	TransmissionCacheEntry
	Caches the intermediate computation results related to a transmission. More...

Public Member Functions
Radio cache
virtual int	getNumRadios () const override
Transmission cache
virtual int	getNumTransmissions () const override
Interference cache
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
Reception cache
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 ()
virtual void	addRadio (const IRadio *radio)=0
virtual void	removeRadio (const IRadio *radio)=0
virtual const IRadio *	getRadio (int id) const =0
virtual void	mapRadios (std::function< void(const IRadio *)> f) const =0
virtual void	addTransmission (const ITransmission *transmission)=0
virtual void	removeTransmission (const ITransmission *transmission)=0
virtual const ITransmission *	getTransmission (int id) const =0
virtual void	mapTransmissions (std::function< void(const ITransmission *)> f) const =0
virtual void	removeNonInterferingTransmissions (std::function< void(const ITransmission *transmission)> f)=0
Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const
	Prints this object to the provided output stream. More...
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
Cache data structures
virtual RadioCacheEntry *	getRadioCacheEntry (const IRadio *radio)=0
virtual TransmissionCacheEntry *	getTransmissionCacheEntry (const ITransmission *transmission)=0
virtual ReceptionCacheEntry *	getReceptionCacheEntry (const IRadio *radio, const ITransmission *transmission)=0

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) }

Member Function Documentation

computeInterferingTransmissions()

std::vector< const ITransmission * > * inet::physicallayer::CommunicationCacheBase::computeInterferingTransmissions ( const IRadio *  radio, const simtime_t  startTime, const simtime_t  endTime  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    RadioCacheEntry *radioCacheEntry = getRadioCacheEntry(radio);
    std::vector<const ITransmission *> *interferingTransmissions = new std::vector<const ITransmission *>();
    if (radioCacheEntry->receptionIntervals != nullptr) {
        std::deque<const IntervalTree::Interval *> interferingIntervals = radioCacheEntry->receptionIntervals->query(startTime, endTime);
        for (auto interferingInterval : interferingIntervals) {
            const ITransmission *interferingTransmission = (ITransmission *)interferingInterval->value;
            interferingTransmissions->push_back(interferingTransmission);
        }
    }
    return interferingTransmissions;
}

getCachedArrival()

const IArrival * inet::physicallayer::CommunicationCacheBase::getCachedArrival ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->arrival : nullptr;
}

getCachedInterference()

const IInterference * inet::physicallayer::CommunicationCacheBase::getCachedInterference ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->interference : nullptr;
}

getCachedInterferenceEndTime()

const simtime_t inet::physicallayer::CommunicationCacheBase::getCachedInterferenceEndTime ( const ITransmission *  transmission )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    return getTransmissionCacheEntry(transmission)->interferenceEndTime;
}

getCachedInterval()

const IntervalTree::Interval * inet::physicallayer::CommunicationCacheBase::getCachedInterval ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->interval : nullptr;
}

getCachedListening()

const IListening * inet::physicallayer::CommunicationCacheBase::getCachedListening ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->listening : nullptr;
}

getCachedNoise()

const INoise * inet::physicallayer::CommunicationCacheBase::getCachedNoise ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->noise : nullptr;
}

getCachedReception()

const IReception * inet::physicallayer::CommunicationCacheBase::getCachedReception ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->reception : nullptr;
}

getCachedReceptionDecision()

const IReceptionDecision * inet::physicallayer::CommunicationCacheBase::getCachedReceptionDecision ( const IRadio *  receiver, const ITransmission *  transmission, IRadioSignal::SignalPart  part  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ASSERT(part != IRadioSignal::SIGNAL_PART_NONE);
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->receptionDecisions[part] : nullptr;
}

getCachedReceptionResult()

const IReceptionResult * inet::physicallayer::CommunicationCacheBase::getCachedReceptionResult ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->receptionResult : nullptr;
}

getCachedSignal() [1/2]

const IWirelessSignal * inet::physicallayer::CommunicationCacheBase::getCachedSignal ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->signal : nullptr;
}

getCachedSignal() [2/2]

const IWirelessSignal * inet::physicallayer::CommunicationCacheBase::getCachedSignal ( const ITransmission *  transmission )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    return getTransmissionCacheEntry(transmission)->signal;
}

getCachedSNIR()

const ISnir * inet::physicallayer::CommunicationCacheBase::getCachedSNIR ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    return cacheEntry ? cacheEntry->snir : nullptr;
}

getNumRadios()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::MapCommunicationCache, and inet::physicallayer::ReferenceCommunicationCache.

{
    int numRadios = 0;
    mapRadios([&](const IRadio *radio) { numRadios++; });
    return numRadios;
}

getNumTransmissions()

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

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::MapCommunicationCache, and inet::physicallayer::ReferenceCommunicationCache.

{
    int numTransmissions = 0;
    mapTransmissions([&](const ITransmission *transmission) { numTransmissions++; });
    return numTransmissions;
}

getRadioCacheEntry()

virtual RadioCacheEntry* inet::physicallayer::CommunicationCacheBase::getRadioCacheEntry ( const IRadio *  radio )

protectedpure virtual

Implemented in inet::physicallayer::VectorCommunicationCache, inet::physicallayer::MapCommunicationCache, and inet::physicallayer::ReferenceCommunicationCache.

Referenced by computeInterferingTransmissions(), and setCachedInterval().

getReceptionCacheEntry()

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

protectedpure virtual

Implemented in inet::physicallayer::VectorCommunicationCache, inet::physicallayer::MapCommunicationCache, and inet::physicallayer::ReferenceCommunicationCache.

Referenced by getCachedArrival(), getCachedInterference(), getCachedInterval(), getCachedListening(), getCachedNoise(), getCachedReception(), getCachedReceptionDecision(), getCachedReceptionResult(), getCachedSignal(), getCachedSNIR(), removeCachedArrival(), removeCachedInterference(), removeCachedInterval(), removeCachedListening(), removeCachedNoise(), removeCachedReception(), removeCachedReceptionDecision(), removeCachedReceptionResult(), removeCachedSignal(), removeCachedSNIR(), setCachedArrival(), setCachedInterference(), setCachedInterval(), setCachedListening(), setCachedNoise(), setCachedReception(), setCachedReceptionDecision(), setCachedReceptionResult(), setCachedSignal(), and setCachedSNIR().

getTransmissionCacheEntry()

virtual TransmissionCacheEntry* inet::physicallayer::CommunicationCacheBase::getTransmissionCacheEntry ( const ITransmission *  transmission )

protectedpure virtual

Implemented in inet::physicallayer::VectorCommunicationCache, inet::physicallayer::MapCommunicationCache, and inet::physicallayer::ReferenceCommunicationCache.

Referenced by getCachedInterferenceEndTime(), getCachedSignal(), removeCachedInterferenceEndTime(), removeCachedSignal(), setCachedInterferenceEndTime(), and setCachedSignal().

removeCachedArrival()

void inet::physicallayer::CommunicationCacheBase::removeCachedArrival ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->arrival = nullptr;
}

removeCachedInterference()

void inet::physicallayer::CommunicationCacheBase::removeCachedInterference ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->interference = nullptr;
}

removeCachedInterferenceEndTime()

void inet::physicallayer::CommunicationCacheBase::removeCachedInterferenceEndTime ( const ITransmission *  transmission )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    getTransmissionCacheEntry(transmission)->interferenceEndTime = -1;
}

removeCachedInterval()

void inet::physicallayer::CommunicationCacheBase::removeCachedInterval ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->interval = nullptr;
}

removeCachedListening()

void inet::physicallayer::CommunicationCacheBase::removeCachedListening ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->listening = nullptr;
}

removeCachedNoise()

void inet::physicallayer::CommunicationCacheBase::removeCachedNoise ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->noise = nullptr;
}

removeCachedReception()

void inet::physicallayer::CommunicationCacheBase::removeCachedReception ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->reception = nullptr;
}

removeCachedReceptionDecision()

void inet::physicallayer::CommunicationCacheBase::removeCachedReceptionDecision ( const IRadio *  receiver, const ITransmission *  transmission, IRadioSignal::SignalPart  part  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ASSERT(part != IRadioSignal::SIGNAL_PART_NONE);
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr) {
        delete cacheEntry->receptionDecisions[part];
        cacheEntry->receptionDecisions[part] = nullptr;
    }
}

removeCachedReceptionResult()

void inet::physicallayer::CommunicationCacheBase::removeCachedReceptionResult ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->receptionResult = nullptr;
}

removeCachedSignal() [1/2]

void inet::physicallayer::CommunicationCacheBase::removeCachedSignal ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->signal = nullptr;
}

removeCachedSignal() [2/2]

void inet::physicallayer::CommunicationCacheBase::removeCachedSignal ( const ITransmission *  transmission )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    getTransmissionCacheEntry(transmission)->signal = nullptr;
}

removeCachedSNIR()

void inet::physicallayer::CommunicationCacheBase::removeCachedSNIR ( const IRadio *  receiver, const ITransmission *  transmission  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry != nullptr)
        cacheEntry->snir = nullptr;
}

setCachedArrival()

void inet::physicallayer::CommunicationCacheBase::setCachedArrival ( const IRadio *  receiver, const ITransmission *  transmission, const IArrival *  arrival  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->arrival = arrival;
}

setCachedInterference()

void inet::physicallayer::CommunicationCacheBase::setCachedInterference ( const IRadio *  receiver, const ITransmission *  transmission, const IInterference *  interference  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->interference = interference;
}

setCachedInterferenceEndTime()

void inet::physicallayer::CommunicationCacheBase::setCachedInterferenceEndTime ( const ITransmission *  transmission, const simtime_t  interferenceEndTime  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    getTransmissionCacheEntry(transmission)->interferenceEndTime = interferenceEndTime;
}

setCachedInterval()

void inet::physicallayer::CommunicationCacheBase::setCachedInterval ( const IRadio *  receiver, const ITransmission *  transmission, const IntervalTree::Interval *  interval  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->interval = interval;
    RadioCacheEntry *radioCacheEntry = getRadioCacheEntry(receiver);
    if (radioCacheEntry->receptionIntervals == nullptr)
        radioCacheEntry->receptionIntervals = new IntervalTree();
    radioCacheEntry->receptionIntervals->insert(interval);
}

setCachedListening()

void inet::physicallayer::CommunicationCacheBase::setCachedListening ( const IRadio *  receiver, const ITransmission *  transmission, const IListening *  listening  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->listening = listening;
}

setCachedNoise()

void inet::physicallayer::CommunicationCacheBase::setCachedNoise ( const IRadio *  receiver, const ITransmission *  transmission, const INoise *  noise  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->noise = noise;
}

setCachedReception()

void inet::physicallayer::CommunicationCacheBase::setCachedReception ( const IRadio *  receiver, const ITransmission *  transmission, const IReception *  reception  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->reception = reception;
}

setCachedReceptionDecision()

void inet::physicallayer::CommunicationCacheBase::setCachedReceptionDecision ( const IRadio *  receiver, const ITransmission *  transmission, IRadioSignal::SignalPart  part, const IReceptionDecision *  receptionDecision  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ASSERT(part != IRadioSignal::SIGNAL_PART_NONE);
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else {
        delete cacheEntry->receptionDecisions[part];
        cacheEntry->receptionDecisions[part] = receptionDecision;
    }
}

setCachedReceptionResult()

void inet::physicallayer::CommunicationCacheBase::setCachedReceptionResult ( const IRadio *  receiver, const ITransmission *  transmission, const IReceptionResult *  receptionResult  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->receptionResult = receptionResult;
}

setCachedSignal() [1/2]

void inet::physicallayer::CommunicationCacheBase::setCachedSignal ( const IRadio *  receiver, const ITransmission *  transmission, const IWirelessSignal *  signal  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->signal = signal;
}

setCachedSignal() [2/2]

void inet::physicallayer::CommunicationCacheBase::setCachedSignal ( const ITransmission *  transmission, const IWirelessSignal *  signal  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

{
    getTransmissionCacheEntry(transmission)->signal = signal;
}

setCachedSNIR()

void inet::physicallayer::CommunicationCacheBase::setCachedSNIR ( const IRadio *  receiver, const ITransmission *  transmission, const ISnir *  snir  )

overridevirtual

Implements inet::physicallayer::ICommunicationCache.

Reimplemented in inet::physicallayer::ReferenceCommunicationCache.

{
    ReceptionCacheEntry *cacheEntry = getReceptionCacheEntry(receiver, transmission);
    if (cacheEntry == nullptr)
        throw cRuntimeError("Cache entry not found");
    else
        cacheEntry->snir = snir;
}

---

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

• CommunicationCacheBase.h
• CommunicationCacheBase.cc