inet::ieee80211::InProgressFrames Class Reference

#include <InProgressFrames.h>

Inheritance diagram for inet::ieee80211::InProgressFrames:

Public Member Functions
virtual	~InProgressFrames ()
virtual std::string	str () const override
virtual void	forEachChild (cVisitor *v) override
virtual int	getLength () const
virtual Packet *	getFrames (int i) const
virtual Packet *	getFrameToTransmit ()
virtual Packet *	getPendingFrameFor (Packet *frame)
virtual void	dropFrame (Packet *packet)
virtual void	dropFrames (std::set< std::pair< MacAddress, std::pair< Tid, SequenceControlField >>> seqAndFragNums)
virtual bool	hasInProgressFrames ()
virtual std::vector< Packet * >	getOutstandingFrames ()
virtual void	clearDroppedFrames ()

Static Public Attributes
static simsignal_t	packetEnqueuedSignal = cComponent::registerSignal("packetEnqueued")
static simsignal_t	packetDequeuedSignal = cComponent::registerSignal("packetDequeued")

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	updateDisplayString () const
void	ensureHasFrameToTransmit ()
bool	hasEligibleFrameToTransmit ()

Protected Attributes
queueing::IPacketQueue *	pendingQueue = nullptr
IOriginatorMacDataService *	dataService = nullptr
IAckHandler *	ackHandler = nullptr
std::vector< Packet * >	inProgressFrames
std::vector< Packet * >	droppedFrames

Constructor & Destructor Documentation

~InProgressFrames()

inet::ieee80211::InProgressFrames::~InProgressFrames ( )

virtual

{
    for (auto frame : inProgressFrames)
        delete frame;
    for (auto frame : droppedFrames)
        delete frame;
}

Member Function Documentation

clearDroppedFrames()

void inet::ieee80211::InProgressFrames::clearDroppedFrames ( )

virtual

{
    Enter_Method("clearDroppedFrames");
    for (auto frame : droppedFrames)
        delete frame;
    droppedFrames.clear();
}

dropFrame()

void inet::ieee80211::InProgressFrames::dropFrame ( Packet *  packet )

virtual

{
    EV_DEBUG << "Dropping frame " << packet->getName() << ".\n";
    inProgressFrames.erase(std::remove(inProgressFrames.begin(), inProgressFrames.end(), packet), inProgressFrames.end());
    droppedFrames.push_back(packet);
    updateDisplayString();
    emit(packetDequeuedSignal, packet);
}

dropFrames()

void inet::ieee80211::InProgressFrames::dropFrames ( std::set< std::pair< MacAddress, std::pair< Tid, SequenceControlField >>>  seqAndFragNums )

virtual

{
    for (auto it = inProgressFrames.begin(); it != inProgressFrames.end();) {
        auto frame = *it;
        auto header = frame->peekAtFront<Ieee80211MacHeader>();
        if (header->getType() == ST_DATA_WITH_QOS) {
            auto dataheader = CHK(dynamicPtrCast<const Ieee80211DataHeader>(header));
            if (seqAndFragNums.count(std::make_pair(dataheader->getReceiverAddress(), std::make_pair(dataheader->getTid(), SequenceControlField(dataheader->getSequenceNumber().get(), dataheader->getFragmentNumber())))) != 0) {
                EV_DEBUG << "Dropping frame " << frame->getName() << ".\n";
                it = inProgressFrames.erase(it);
                droppedFrames.push_back(frame);
                updateDisplayString();
                emit(packetDequeuedSignal, frame);
            }
            else
                it++;
        }
        else
            it++;
    }
}

ensureHasFrameToTransmit()

void inet::ieee80211::InProgressFrames::ensureHasFrameToTransmit ( )

protected

{
//    TODO delete old frames from inProgressFrames
//    if (auto dataFrame = dynamic_cast<Ieee80211DataHeader*>(frame)) {
//        if (transmitLifetimeHandler->isLifetimeExpired(dataFrame))
//            return frame;
//    }
    if (!hasEligibleFrameToTransmit()) {
        auto frames = dataService->extractFramesToTransmit(pendingQueue);
        if (frames) {
            for (auto frame : *frames) {
                EV_DEBUG << "Inserting frame " << frame->getName() << " extracted from MAC data service.\n";
                take(frame);
                ackHandler->frameGotInProgress(frame->peekAtFront<Ieee80211DataOrMgmtHeader>());
                inProgressFrames.push_back(frame);
                frame->setArrivalTime(simTime());
                updateDisplayString();
                emit(packetEnqueuedSignal, frame);
            }
            delete frames;
        }
    }
}

Referenced by getFrameToTransmit().

forEachChild()

void inet::ieee80211::InProgressFrames::forEachChild ( cVisitor *  v )

overridevirtual

{
    cSimpleModule::forEachChild(v);
    for (auto frame : inProgressFrames)
        v->visit(frame);
}

getFrames()

virtual Packet* inet::ieee80211::InProgressFrames::getFrames ( int  i ) const

inlinevirtual

{ return inProgressFrames[i]; }

getFrameToTransmit()

Packet * inet::ieee80211::InProgressFrames::getFrameToTransmit ( )

virtual

{
    ensureHasFrameToTransmit();
    for (auto frame : inProgressFrames) {
        if (ackHandler->isEligibleToTransmit(frame->peekAtFront<Ieee80211DataOrMgmtHeader>()))
            return frame;
    }
    return nullptr;
}

Referenced by getPendingFrameFor(), inet::ieee80211::DcfFs::hasMoreFragments(), inet::ieee80211::HcfFs::hasMoreTxOps(), inet::ieee80211::HcfFs::hasMoreTxOpsAndMulticast(), inet::ieee80211::DcfFs::isBroadcastManagementOrGroupDataSequenceNeeded(), inet::ieee80211::DcfFs::isFragFrameSequenceNeeded(), inet::ieee80211::TxOpFs::isRtsCtsNeeded(), inet::ieee80211::DcfFs::isRtsCtsNeeded(), inet::ieee80211::DataFs::prepareStep(), inet::ieee80211::ManagementAckFs::prepareStep(), inet::ieee80211::ManagementFs::prepareStep(), inet::ieee80211::RtsCtsFs::prepareStep(), inet::ieee80211::RtsFs::prepareStep(), inet::ieee80211::FragFrameAckFs::prepareStep(), inet::ieee80211::LastFrameAckFs::prepareStep(), inet::ieee80211::HcfFs::selectDataOrManagementSequence(), inet::ieee80211::HcfFs::selectHcfSequence(), inet::ieee80211::DcfFs::selectMulticastDataOrMgmt(), and inet::ieee80211::TxOpFs::selectTxOpSequence().

getLength()

virtual int inet::ieee80211::InProgressFrames::getLength ( ) const

inlinevirtual

{ return inProgressFrames.size(); }

getOutstandingFrames()

std::vector< Packet * > inet::ieee80211::InProgressFrames::getOutstandingFrames ( )

virtual

{
    std::vector<Packet *> outstandingFrames;
    for (auto frame : inProgressFrames) {
        if (ackHandler->isOutstandingFrame(frame->peekAtFront<Ieee80211DataOrMgmtHeader>()))
            outstandingFrames.push_back(frame);
    }
    return outstandingFrames;
}

Referenced by inet::ieee80211::OriginatorQosAckPolicy::getOutstandingFramesPerReceiver().

getPendingFrameFor()

Packet * inet::ieee80211::InProgressFrames::getPendingFrameFor ( Packet *  frame )

virtual

{
    auto frameToTransmit = getFrameToTransmit();
    if (dynamicPtrCast<const Ieee80211RtsFrame>(frame->peekAtFront<Ieee80211MacHeader>()))
        return frameToTransmit;
    else {
        for (auto frame : inProgressFrames) {
            if (ackHandler->isEligibleToTransmit(frame->peekAtFront<Ieee80211DataOrMgmtHeader>()) && frameToTransmit != frame)
                return frame;
        }
        auto frames = dataService->extractFramesToTransmit(pendingQueue);
        if (frames) {
            auto firstFrame = (*frames)[0];
            for (auto frame : *frames) {
                take(frame);
                ackHandler->frameGotInProgress(frame->peekAtFront<Ieee80211DataOrMgmtHeader>());
                inProgressFrames.push_back(frame);
                frame->setArrivalTime(simTime());
                updateDisplayString();
                emit(packetEnqueuedSignal, frame);
            }
            delete frames;
            // FIXME If the next Txop sequence were a BlockAckReqBlockAckFs then this would return
            // a wrong pending frame.
            return firstFrame;
        }
        else
            return nullptr;
    }
}

hasEligibleFrameToTransmit()

bool inet::ieee80211::InProgressFrames::hasEligibleFrameToTransmit ( )

protected

{
    for (auto frame : inProgressFrames) {
        if (ackHandler->isEligibleToTransmit(frame->peekAtFront<Ieee80211DataOrMgmtHeader>()))
            return true;
    }
    return false;
}

Referenced by ensureHasFrameToTransmit().

hasInProgressFrames()

virtual bool inet::ieee80211::InProgressFrames::hasInProgressFrames ( )

inlinevirtual

{ ensureHasFrameToTransmit(); return hasEligibleFrameToTransmit(); }

Referenced by inet::ieee80211::DcfFs::hasMoreFragments(), inet::ieee80211::HcfFs::hasMoreTxOps(), inet::ieee80211::DcfFs::isBroadcastManagementOrGroupDataSequenceNeeded(), and inet::ieee80211::DcfFs::isFragFrameSequenceNeeded().

initialize()

void inet::ieee80211::InProgressFrames::initialize ( int  stage )

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        pendingQueue = check_and_cast<queueing::IPacketQueue *>(getModuleByPath(par("pendingQueueModule")));
        dataService = check_and_cast<IOriginatorMacDataService *>(getModuleByPath(par("originatorMacDataServiceModule")));
        ackHandler = check_and_cast<IAckHandler *>(getModuleByPath(par("ackHandlerModule")));
        updateDisplayString();
    }
}

str()

std::string inet::ieee80211::InProgressFrames::str ( ) const

overridevirtual

{
    if (inProgressFrames.size() == 0)
        return std::string("empty");
    std::stringstream out;
    out << "length=" << inProgressFrames.size();
    return out.str();
}

updateDisplayString()

void inet::ieee80211::InProgressFrames::updateDisplayString ( ) const

protectedvirtual

{
    std::string text = std::to_string(inProgressFrames.size()) + " packets";
    getDisplayString().setTagArg("t", 0, text.c_str());
}

Referenced by dropFrame(), dropFrames(), ensureHasFrameToTransmit(), getPendingFrameFor(), and initialize().

Member Data Documentation

ackHandler

IAckHandler* inet::ieee80211::InProgressFrames::ackHandler = nullptr

protected

Referenced by ensureHasFrameToTransmit(), getFrameToTransmit(), getOutstandingFrames(), getPendingFrameFor(), hasEligibleFrameToTransmit(), and initialize().

dataService

IOriginatorMacDataService* inet::ieee80211::InProgressFrames::dataService = nullptr

protected

Referenced by ensureHasFrameToTransmit(), getPendingFrameFor(), and initialize().

droppedFrames

std::vector<Packet *> inet::ieee80211::InProgressFrames::droppedFrames

protected

Referenced by clearDroppedFrames(), dropFrame(), dropFrames(), and ~InProgressFrames().

inProgressFrames

std::vector<Packet *> inet::ieee80211::InProgressFrames::inProgressFrames

protected

Referenced by dropFrame(), dropFrames(), ensureHasFrameToTransmit(), forEachChild(), getFrameToTransmit(), getOutstandingFrames(), getPendingFrameFor(), hasEligibleFrameToTransmit(), str(), updateDisplayString(), and ~InProgressFrames().

packetDequeuedSignal

simsignal_t inet::ieee80211::InProgressFrames::packetDequeuedSignal = cComponent::registerSignal("packetDequeued")

static

Referenced by dropFrame(), and dropFrames().

packetEnqueuedSignal

simsignal_t inet::ieee80211::InProgressFrames::packetEnqueuedSignal = cComponent::registerSignal("packetEnqueued")

static

Referenced by ensureHasFrameToTransmit(), and getPendingFrameFor().

pendingQueue

queueing::IPacketQueue* inet::ieee80211::InProgressFrames::pendingQueue = nullptr

protected

Referenced by ensureHasFrameToTransmit(), getPendingFrameFor(), and initialize().

---

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

• InProgressFrames.h
• InProgressFrames.cc