inet::AbstractQueue Class Reference

Abstract base class for single-server queues. More...

#include <AbstractQueue.h>

Inheritance diagram for inet::AbstractQueue:

Public Member Functions
	AbstractQueue ()
virtual	~AbstractQueue ()

Protected Member Functions
virtual void	initialize () override
virtual void	handleMessage (cMessage *msg) override
virtual void	arrival (cPacket *msg)=0
	Functions to (re)define behaviour. More...
virtual cPacket *	arrivalWhenIdle (cPacket *msg)=0
	Called when a message arrives at the module when the queue is empty. More...
virtual simtime_t	startService (cPacket *msg)=0
	Called when a message starts service, and should return the service time. More...
virtual void	endService (cPacket *msg)=0
	Called when a message completes service. More...
virtual cPacket *	cancelService ()
	If a message is under service, aborts its service and returns the message. More...

Protected Attributes
cPacketQueue	queue
	The queue. More...

Private Member Functions
void	doStartService ()
void	doEndService ()

Private Attributes
cPacket *	msgServiced
cMessage *	endServiceMsg

Detailed Description

Abstract base class for single-server queues.

Contains special optimization for zero service time (i.e. it does not schedule the endService timer then).

Constructor & Destructor Documentation

inet::AbstractQueue::AbstractQueue

(

)

{
    msgServiced = nullptr;
    endServiceMsg = nullptr;
}

inet::AbstractQueue::~AbstractQueue ( )

virtual

{
    delete msgServiced;
    cancelAndDelete(endServiceMsg);
}

Member Function Documentation

virtual void inet::AbstractQueue::arrival ( cPacket *  msg )

protectedpure virtual

Functions to (re)define behaviour.

Called when a message arrives at the module. The method should either enqueue this message (usual behaviour), or discard it. It may also wrap the it into another message, and insert that one in the queue.

Most straightforward implementation: queue.insert(msg);

Implemented in inet::QueueBase.

Referenced by handleMessage().

virtual cPacket* inet::AbstractQueue::arrivalWhenIdle ( cPacket *  msg )

protectedpure virtual

Called when a message arrives at the module when the queue is empty.

The message doesn't need to be enqueued in this case, it can start service immediately. This method may:

1. simply return the the same pointer (usual behaviour), or
2. discard the message and return nullptr pointer (the effect being this message being ignored)
3. or modify the message, wrap in into another message etc, and return the (new) message's pointer.

Most straightforward implementation: return msg;

Implemented in inet::QueueBase.

Referenced by handleMessage().

cPacket * inet::AbstractQueue::cancelService ( )

protectedvirtual

If a message is under service, aborts its service and returns the message.

Returns nullptr if no message is being serviced. The caller is free to delete the message, reinsert it into the queue, or handle it otherwise.

Referenced by inet::IPv4::flush().

{
    if (!msgServiced)
        return nullptr;
    else {
        cancelEvent(endServiceMsg);
        cPacket *ret = msgServiced;
        msgServiced = nullptr;
        return ret;
    }
}

void inet::AbstractQueue::doEndService ( )

private

Referenced by doStartService(), and handleMessage().

{
    endService(msgServiced);
    if (queue.isEmpty()) {
        msgServiced = nullptr;
    }
    else {
        msgServiced = queue.pop();
        doStartService();
    }
}

void inet::AbstractQueue::doStartService ( )

private

Referenced by doEndService(), and handleMessage().

{
    simtime_t serviceTime = startService(msgServiced);
    if (serviceTime != SIMTIME_ZERO)
        scheduleAt(simTime() + serviceTime, endServiceMsg);
    else
        doEndService();
}

virtual void inet::AbstractQueue::endService ( cPacket *  msg )

protectedpure virtual

Called when a message completes service.

The function may send it to another module, discard it, or in general do anything with it.

Most straightforward implementation: send(msg,"out");

Implemented in inet::IPv4, inet::IPv6, and inet::GenericNetworkProtocol.

Referenced by doEndService().

void inet::AbstractQueue::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

Reimplemented in inet::IPv4, inet::IPv6, and inet::GenericNetworkProtocol.

Referenced by inet::GenericNetworkProtocol::handleMessage(), inet::IPv6::handleMessage(), and inet::IPv4::handleMessage().

{
    if (msg == endServiceMsg) {
        doEndService();
    }
    else if (!msgServiced) {
        cPacket *msg2 = arrivalWhenIdle(PK(msg));
        if (msg2) {
            msgServiced = msg2;
            doStartService();
        }
    }
    else {
        arrival(PK(msg));
    }
}

void inet::AbstractQueue::initialize ( )

overrideprotectedvirtual

Reimplemented in inet::GenericNetworkProtocol, and inet::QueueBase.

Referenced by inet::QueueBase::initialize().

{
    msgServiced = nullptr;
    endServiceMsg = new cMessage("end-service");
    queue.setName("queue");
}

virtual simtime_t inet::AbstractQueue::startService ( cPacket *  msg )

protectedpure virtual

Called when a message starts service, and should return the service time.

Example implementation: return 1.0;

Implemented in inet::QueueBase.

Referenced by doStartService().

Member Data Documentation

cMessage* inet::AbstractQueue::endServiceMsg

private

Referenced by AbstractQueue(), cancelService(), doStartService(), handleMessage(), initialize(), and ~AbstractQueue().

cPacket* inet::AbstractQueue::msgServiced

private

Referenced by AbstractQueue(), cancelService(), doEndService(), doStartService(), handleMessage(), initialize(), and ~AbstractQueue().

cPacketQueue inet::AbstractQueue::queue

protected

The queue.

Referenced by inet::QueueBase::arrival(), doEndService(), inet::IPv6::endService(), inet::IPv4::flush(), inet::IPv6::fragmentAndSend(), initialize(), and inet::IPv4::start().

---

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

• AbstractQueue.h
• AbstractQueue.cc