inet::MultiClock Class Reference

#include <MultiClock.h>

Inheritance diagram for inet::MultiClock:

Public Member Functions
virtual clocktime_t	getClockTime () const override
	Returns the current clock time. More...
virtual clocktime_t	computeClockTimeFromSimTime (simtime_t time) const override
	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 override
	Returns the simulation time (first moment) for the specified future clock time according to the current state of the clock. 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 delay, 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 void	receiveSignal (cComponent *source, int signal, const simtime_t &time, cObject *details) override
Public Member Functions inherited from inet::IClock
virtual	~IClock ()

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	handleParameterChange (const char *name) override

Protected Attributes
IClock *	activeClock = nullptr

Member Function Documentation

cancelClockEvent()

virtual ClockEvent* inet::MultiClock::cancelClockEvent ( ClockEvent *  event )

inlineoverridevirtual

Cancels a previously scheduled clock event.

The clock event ownership is transferred to the caller.

Implements inet::IClock.

{ return activeClock->cancelClockEvent(event); }

computeClockTimeFromSimTime()

virtual clocktime_t inet::MultiClock::computeClockTimeFromSimTime ( simtime_t  time ) const

inlineoverridevirtual

Returns the clock time for the specified future simulation time according to the current state of the clock.

This method implements a monotonic function with respect to the simulation time argument. It's allowed to return a different value for the same argument value if the clock is set between calls. The time argument must be greater than or equal to the current simulation time, otherwise an error is raised. See SIMTIME_AS_CLOCKTIME macro for simple type conversion.

Implements inet::IClock.

{ return activeClock->computeClockTimeFromSimTime(time); }

computeSimTimeFromClockTime()

virtual simtime_t inet::MultiClock::computeSimTimeFromClockTime ( clocktime_t  time ) const

inlineoverridevirtual

Returns the simulation time (first moment) for the specified future clock time according to the current state of the clock.

This method implements a monotonic function with respect to the clock time argument. It's allowed to return a different value for the same argument value if the clock is set between calls. The time argument must be greater or than equal to the current clock time, otherwise an error is raised. See CLOCKTIME_AS_SIMTIME macro for simple type conversion.

Implements inet::IClock.

{ return activeClock->computeSimTimeFromClockTime(time); }

getClockTime()

virtual clocktime_t inet::MultiClock::getClockTime ( ) const

inlineoverridevirtual

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 activeClock->getClockTime(); }

Referenced by handleParameterChange().

handleClockEvent()

virtual void inet::MultiClock::handleClockEvent ( ClockEvent *  event )

inlineoverridevirtual

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.

{ activeClock->handleClockEvent(event); }

handleParameterChange()

void inet::MultiClock::handleParameterChange ( const char *  name )

overrideprotectedvirtual

{
    if (name != nullptr) {
        if (!strcmp(name, "activeClockIndex")) {
            emit(ClockBase::timeChangedSignal, getClockTime().asSimTime());
            activeClock = check_and_cast<IClock *>(getSubmodule("clock", par("activeClockIndex")));
            emit(ClockBase::timeChangedSignal, getClockTime().asSimTime());
        }
    }
}

initialize()

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        activeClock = check_and_cast<IClock *>(getSubmodule("clock", par("activeClockIndex")));
        subscribe(ClockBase::timeChangedSignal, this);
    }
}

receiveSignal()

void inet::MultiClock::receiveSignal ( cComponent *  source, int  signal, const simtime_t &  time, cObject *  details  )

overridevirtual

{
    if (signal == ClockBase::timeChangedSignal) {
        if (check_and_cast<IClock *>(source) == activeClock)
            emit(ClockBase::timeChangedSignal, time, details);
    }
    else
        throw cRuntimeError("Unknown signal");
}

scheduleClockEventAfter()

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

inlineoverridevirtual

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.

{ activeClock->scheduleClockEventAfter(delay, event); }

scheduleClockEventAt()

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

inlineoverridevirtual

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.

{ activeClock->scheduleClockEventAt(time, event); }

Member Data Documentation

activeClock

IClock* inet::MultiClock::activeClock = nullptr

protected

Referenced by handleParameterChange(), initialize(), and receiveSignal().

---

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

• MultiClock.h
• MultiClock.cc