inet::ClockBase Class Reference

#include <ClockBase.h>

Inheritance diagram for inet::ClockBase:

Public Member Functions
virtual clocktime_t	getClockTime () const override
	Returns the current clock time. More...
virtual void	scheduleClockEventAt (clocktime_t time, ClockEvent *event) override
	Schedules an event to be delivered to the caller module (i.e. More...
virtual void	scheduleClockEventAfter (clocktime_t time, ClockEvent *event) override
	Schedules an event to be delivered to the caller module (i.e. More...
virtual ClockEvent *	cancelClockEvent (ClockEvent *event) override
	Cancels a previously scheduled clock event. More...
virtual void	handleClockEvent (ClockEvent *event) override
	Called by the clock event to be executed in the context of this clock. More...
virtual const char *	resolveDirective (char directive) const override
Public Member Functions inherited from inet::IClock
virtual	~IClock ()
virtual clocktime_t	computeClockTimeFromSimTime (simtime_t time) const =0
	Returns the clock time for the specified future simulation time according to the current state of the clock. More...
virtual simtime_t	computeSimTimeFromClockTime (clocktime_t time) const =0
	Returns the simulation time (first moment) for the specified future clock time according to the current state of the clock. More...

Static Public Attributes
static simsignal_t	timeChangedSignal = cComponent::registerSignal("timeChanged")

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	finish () override
virtual void	refreshDisplay () const override
virtual void	updateDisplayString () const
cSimpleModule *	getTargetModule () const

Protected Attributes
clocktime_t	clockEventTime = -1
const char *	displayStringTextFormat = nullptr

Member Function Documentation

cancelClockEvent()

ClockEvent * inet::ClockBase::cancelClockEvent ( ClockEvent *  event )

overridevirtual

Cancels a previously scheduled clock event.

The clock event ownership is transferred to the caller.

Implements inet::IClock.

Reimplemented in inet::OscillatorBasedClock.

{
    getTargetModule()->cancelEvent(msg);
    msg->setClock(nullptr);
    return msg;
}

Referenced by inet::OscillatorBasedClock::cancelClockEvent().

finish()

void inet::ClockBase::finish ( )

overrideprotectedvirtual

Reimplemented in inet::IdealClock.

{
    emit(timeChangedSignal, getClockTime().asSimTime());
}

Referenced by inet::IdealClock::finish().

getClockTime()

clocktime_t inet::ClockBase::getClockTime ( ) const

overridevirtual

Returns the current clock time.

Note that the clock time is not necessarily monotonous in execution order. For example, the clock time may decrease even at the same simulation time.

Implements inet::IClock.

{
    return clockEventTime != -1 ? clockEventTime : computeClockTimeFromSimTime(simTime());
}

Referenced by inet::OscillatorBasedClock::computeSimTimeFromClockTime(), finish(), initialize(), inet::OscillatorBasedClock::receiveSignal(), resolveDirective(), scheduleClockEventAfter(), scheduleClockEventAt(), and inet::SettableClock::setClockTime().

getTargetModule()

cSimpleModule* inet::ClockBase::getTargetModule ( ) const

inlineprotected

                                           {
        cSimpleModule *target = getSimulation()->getContextSimpleModule();
        if (target == nullptr)
            throw cRuntimeError("scheduleAt()/cancelEvent() must be called with a simple module in context");
        return target;
    }

Referenced by cancelClockEvent(), scheduleClockEventAfter(), and scheduleClockEventAt().

handleClockEvent()

void inet::ClockBase::handleClockEvent ( ClockEvent *  event )

overridevirtual

Called by the clock event to be executed in the context of this clock.

This method is primarily useful for clock implementations to update their internal data structures related to individual clock events.

Implements inet::IClock.

Reimplemented in inet::OscillatorBasedClock.

{
    clockEventTime = msg->getArrivalClockTime();
    msg->setClock(nullptr);
    msg->callBaseExecute();
    clockEventTime = -1;
}

Referenced by inet::OscillatorBasedClock::handleClockEvent().

initialize()

void inet::ClockBase::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented in inet::OscillatorBasedClock, inet::SettableClock, and inet::IdealClock.

{
    if (stage == INITSTAGE_LOCAL)
        displayStringTextFormat = par("displayStringTextFormat");
    else if (stage == INITSTAGE_LAST) {
        updateDisplayString();
        emit(timeChangedSignal, getClockTime().asSimTime());
    }
}

Referenced by inet::IdealClock::initialize(), and inet::OscillatorBasedClock::initialize().

numInitStages()

virtual int inet::ClockBase::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

refreshDisplay()

void inet::ClockBase::refreshDisplay ( ) const

overrideprotectedvirtual

{
    updateDisplayString();
}

resolveDirective()

const char * inet::ClockBase::resolveDirective ( char  directive ) const

overridevirtual

Implements inet::StringFormat::IDirectiveResolver.

Reimplemented in inet::OscillatorBasedClock.

{
    static std::string result;
    switch (directive) {
        case 't':
            result = getClockTime().str() + " s";
            break;
        default:
            throw cRuntimeError("Unknown directive: %c", directive);
    }
    return result.c_str();
}

Referenced by inet::OscillatorBasedClock::resolveDirective().

scheduleClockEventAfter()

void inet::ClockBase::scheduleClockEventAfter ( clocktime_t  delay, ClockEvent *  event  )

overridevirtual

Schedules an event to be delivered to the caller module (i.e.

the context module) after the given clock time delay has elapsed. The event is anchored to a specific clock time duration, so the actual simulation time when this event is executed is not affected if the clock time is set later. On the other hand, setting the clock drift still affects the simulation time of the event execution.

Implements inet::IClock.

Reimplemented in inet::OscillatorBasedClock.

{
    if (clockTimeDelay < 0)
        throw cRuntimeError("Cannot schedule clock event with negative delay");
    cSimpleModule *targetModule = getTargetModule();
    msg->setClock(this);
    msg->setRelative(true);
    clocktime_t nowClock = getClockTime();
    clocktime_t arrivalClockTime = nowClock + clockTimeDelay;
    msg->setArrivalClockTime(arrivalClockTime);
    simtime_t simTimeDelay = clockTimeDelay.isZero() ? SIMTIME_ZERO : computeSimTimeFromClockTime(arrivalClockTime) - simTime();
    targetModule->scheduleAfter(simTimeDelay, msg);
}

Referenced by inet::OscillatorBasedClock::scheduleClockEventAfter().

scheduleClockEventAt()

void inet::ClockBase::scheduleClockEventAt ( clocktime_t  time, ClockEvent *  event  )

overridevirtual

Schedules an event to be delivered to the caller module (i.e.

the context module) at the specified clock time. The event is anchored to a specific clock time value, so the actual simulation time when this event is executed will be affected if the clock time is set later.

Implements inet::IClock.

Reimplemented in inet::OscillatorBasedClock.

{
    if (t < getClockTime())
        throw cRuntimeError("Cannot schedule clock event in the past");
    cSimpleModule *targetModule = getTargetModule();
    msg->setClock(this);
    msg->setRelative(false);
    msg->setArrivalClockTime(t);
    targetModule->scheduleAt(computeSimTimeFromClockTime(t), msg);
}

Referenced by inet::OscillatorBasedClock::scheduleClockEventAt().

updateDisplayString()

void inet::ClockBase::updateDisplayString ( ) const

protectedvirtual

{
    if (getEnvir()->isGUI()) {
        auto text = StringFormat::formatString(displayStringTextFormat, this);
        getDisplayString().setTagArg("t", 0, text);
    }
}

Referenced by initialize(), and refreshDisplay().

Member Data Documentation

clockEventTime

clocktime_t inet::ClockBase::clockEventTime = -1

protected

Referenced by getClockTime(), and handleClockEvent().

displayStringTextFormat

const char* inet::ClockBase::displayStringTextFormat = nullptr

protected

Referenced by initialize(), and updateDisplayString().

timeChangedSignal

simsignal_t inet::ClockBase::timeChangedSignal = cComponent::registerSignal("timeChanged")

static

Referenced by inet::IdealClock::finish(), finish(), inet::MultiClock::handleParameterChange(), inet::IdealClock::initialize(), inet::MultiClock::initialize(), initialize(), inet::MultiClock::receiveSignal(), inet::OscillatorBasedClock::receiveSignal(), and inet::SettableClock::setClockTime().

---

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

• ClockBase.h
• ClockBase.cc