inet::MessageDispatcher Class Reference

This class implements the corresponding module. More...

#include <MessageDispatcher.h>

Inheritance diagram for inet::MessageDispatcher:

Classes
class	Key

Public Member Functions
virtual void	handleRegisterInterface (const NetworkInterface &interface, cGate *out, cGate *in) override
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyService (cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyProtocol (cGate *gate, ServicePrimitive servicePrimitive) override
Public Member Functions inherited from inet::DefaultProtocolRegistrationListener
virtual void	handleRegisterServiceGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocolGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	arrived (cMessage *message, cGate *gate, const SendOptions &options, simtime_t time) override
virtual cGate *	handlePacket (Packet *packet, cGate *inGate)
virtual cGate *	handleMessage (Message *request, cGate *inGate)

Protected Attributes
bool	forwardServiceRegistration
bool	forwardProtocolRegistration
std::map< int, int >	socketIdToGateIndex
std::map< int, int >	interfaceIdToGateIndex
std::map< Key, int >	serviceToGateIndex
std::map< Key, int >	protocolToGateIndex
const Protocol *	registeringProtocol = nullptr
bool	registeringAny = false

Detailed Description

This class implements the corresponding module.

See module documentation for more details.

Member Function Documentation

arrived()

void inet::MessageDispatcher::arrived ( cMessage *  message, cGate *  gate, const SendOptions &  options, simtime_t  time  )

overrideprotectedvirtual

{
    Enter_Method("arrived");
    cGate *outGate = nullptr;
    if (message->isPacket()) {
        auto packet = check_and_cast<Packet *>(message);
        outGate = handlePacket(packet, inGate);
#ifdef INET_WITH_QUEUEING
        handlePacketProcessed(packet);
#endif // #ifdef INET_WITH_QUEUEING
    }
    else
        outGate = handleMessage(check_and_cast<Message *>(message), inGate);
    outGate->deliver(message, options, time);
#ifdef INET_WITH_QUEUEING
    updateDisplayString();
#endif // #ifdef INET_WITH_QUEUEING
}

handleMessage()

cGate * inet::MessageDispatcher::handleMessage ( Message *  request, cGate *  inGate  )

protectedvirtual

{
    const auto& socketReq = message->findTag<SocketReq>();
    if (socketReq != nullptr) {
        int socketReqId = socketReq->getSocketId();
        auto it = socketIdToGateIndex.find(socketReqId);
        if (it == socketIdToGateIndex.end())
            socketIdToGateIndex[socketReqId] = inGate->getIndex();
        else if (it->first != socketReqId)
            throw cRuntimeError("handleMessage(): Socket is already registered: socketId = %d, current gateIndex = %d, new gateIndex = %d, pathStartGate = %s, pathEndGate = %s", socketReqId, it->second, inGate->getIndex(), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
    }
    const auto& socketInd = message->findTag<SocketInd>();
    if (socketInd != nullptr) {
        int socketId = socketInd->getSocketId();
        auto it = socketIdToGateIndex.find(socketId);
        if (it != socketIdToGateIndex.end()) {
            auto outGate = gate("out", it->second);
            EV_INFO << "Dispatching message to socket" << EV_FIELD(socketId) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(message) << EV_ENDL;
            return outGate;
        }
        else
            throw cRuntimeError("handleMessage(): Unknown socket: socketId = %d, pathStartGate = %s, pathEndGate = %s", socketId, inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
    }
    const auto& dispatchProtocolReq = message->findTag<DispatchProtocolReq>();
    if (dispatchProtocolReq != nullptr) {
        auto servicePrimitive = dispatchProtocolReq->getServicePrimitive();
        // KLUDGE eliminate this by adding ServicePrimitive to every DispatchProtocolReq
        if (servicePrimitive == static_cast<ServicePrimitive>(-1))
            servicePrimitive = SP_REQUEST;
        auto protocol = dispatchProtocolReq->getProtocol();
        if (servicePrimitive == SP_REQUEST) {
            auto it = serviceToGateIndex.find(Key(protocol->getId(), servicePrimitive));
            if (it != serviceToGateIndex.end()) {
                auto outGate = gate("out", it->second);
                EV_INFO << "Dispatching message to service" << EV_FIELD(protocol, *protocol) << EV_FIELD(servicePrimitive) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(message) << EV_ENDL;
                return outGate;
            }
            else {
                auto it = serviceToGateIndex.find(Key(-1, servicePrimitive));
                if (it != serviceToGateIndex.end()) {
                    auto outGate = gate("out", it->second);
                    EV_INFO << "Dispatching message to any service" << EV_FIELD(servicePrimitive) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(message) << EV_ENDL;
                    return outGate;
                }
                else
                    throw cRuntimeError("handleMessage(): Unknown protocol: protocolId = %d, protocolName = %s, servicePrimitive = REQUEST, pathStartGate = %s, pathEndGate = %s", protocol->getId(), protocol->getName(), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
            }
        }
        else if (servicePrimitive == SP_INDICATION) {
            auto it = protocolToGateIndex.find(Key(protocol->getId(), servicePrimitive));
            if (it != protocolToGateIndex.end()) {
                auto outGate = gate("out", it->second);
                EV_INFO << "Dispatching message to protocol" << EV_FIELD(protocol, *protocol) << EV_FIELD(servicePrimitive) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(message) << EV_ENDL;
                return outGate;
            }
            else {
                auto it = protocolToGateIndex.find(Key(-1, servicePrimitive));
                if (it != protocolToGateIndex.end()) {
                    auto outGate = gate("out", it->second);
                    EV_INFO << "Dispatching message to any protocol" << EV_FIELD(servicePrimitive) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(message) << EV_ENDL;
                    return outGate;
                }
                else
                    throw cRuntimeError("handleMessage(): Unknown protocol: protocolId = %d, protocolName = %s, servicePrimitive = INDICATION, pathStartGate = %s, pathEndGate = %s", protocol->getId(), protocol->getName(), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
            }
        }
        else
            throw cRuntimeError("handleMessage(): Unknown service primitive: servicePrimitive = %d, pathStartGate = %s, pathEndGate = %s", static_cast<int>(servicePrimitive), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
    }
    const auto& interfaceReq = message->findTag<InterfaceReq>();
    if (interfaceReq != nullptr) {
        int interfaceId = interfaceReq->getInterfaceId();
        auto it = interfaceIdToGateIndex.find(interfaceId);
        if (it != interfaceIdToGateIndex.end()) {
            auto outGate = gate("out", it->second);
            EV_INFO << "Dispatching message to interface" << EV_FIELD(interfaceId) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(message) << EV_ENDL;
            return outGate;
        }
        else
            throw cRuntimeError("handleMessage(): Unknown interface: interfaceId = %d, pathStartGate = %s, pathEndGate = %s", interfaceId, inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
    }
    throw cRuntimeError("handleMessage(): Unknown message: %s(%s), pathStartGate = %s, pathEndGate = %s", message->getName(), message->getClassName(), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
}

Referenced by arrived().

handlePacket()

cGate * inet::MessageDispatcher::handlePacket ( Packet *  packet, cGate *  inGate  )

protectedvirtual

{
    const auto& socketInd = packet->findTag<SocketInd>();
    if (socketInd != nullptr) {
        int socketId = socketInd->getSocketId();
        auto it = socketIdToGateIndex.find(socketId);
        if (it != socketIdToGateIndex.end()) {
            auto outGate = gate("out", it->second);
            EV_INFO << "Dispatching packet to socket" << EV_FIELD(socketId) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(packet) << EV_ENDL;
            return outGate;
        }
        else
            throw cRuntimeError("handlePacket(): Unknown socket: socketId = %d, pathStartGate = %s, pathEndGate = %s", socketId, inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
    }
    const auto& dispatchProtocolReq = packet->findTag<DispatchProtocolReq>();
    if (dispatchProtocolReq != nullptr) {
        const auto& packetProtocolTag = packet->findTag<PacketProtocolTag>();
        auto servicePrimitive = dispatchProtocolReq->getServicePrimitive();
        // KLUDGE eliminate this by adding ServicePrimitive to every DispatchProtocolReq
        if (servicePrimitive == static_cast<ServicePrimitive>(-1)) {
            if (packetProtocolTag != nullptr && dispatchProtocolReq->getProtocol() == packetProtocolTag->getProtocol())
                servicePrimitive = SP_INDICATION;
            else
                servicePrimitive = SP_REQUEST;
        }
        auto protocol = dispatchProtocolReq->getProtocol();
        if (servicePrimitive == SP_REQUEST) {
            auto it = serviceToGateIndex.find(Key(protocol->getId(), servicePrimitive));
            if (it != serviceToGateIndex.end()) {
                auto outGate = gate("out", it->second);
                EV_INFO << "Dispatching packet to service" << EV_FIELD(protocol, *protocol) << EV_FIELD(servicePrimitive) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(packet) << EV_ENDL;
                return outGate;
            }
            else {
                auto it = serviceToGateIndex.find(Key(-1, servicePrimitive));
                if (it != serviceToGateIndex.end()) {
                    auto outGate = gate("out", it->second);
                    EV_INFO << "Dispatching packet to any service" << EV_FIELD(servicePrimitive) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(packet) << EV_ENDL;
                    return outGate;
                }
                else
                    throw cRuntimeError("handlePacket(): Unknown protocol: protocolId = %d, protocolName = %s, servicePrimitive = REQUEST, pathStartGate = %s, pathEndGate = %s", protocol->getId(), protocol->getName(), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
            }
        }
        else if (servicePrimitive == SP_INDICATION) {
            auto it = protocolToGateIndex.find(Key(protocol->getId(), servicePrimitive));
            if (it != protocolToGateIndex.end()) {
                auto outGate = gate("out", it->second);
                EV_INFO << "Dispatching packet to protocol" << EV_FIELD(protocol, *protocol) << EV_FIELD(servicePrimitive) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(packet) << EV_ENDL;
                return outGate;
            }
            else {
                auto it = protocolToGateIndex.find(Key(-1, servicePrimitive));
                if (it != protocolToGateIndex.end()) {
                    auto outGate = gate("out", it->second);
                    EV_INFO << "Dispatching packet to any protocol" << EV_FIELD(servicePrimitive) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(packet) << EV_ENDL;
                    return outGate;
                }
                else
                    throw cRuntimeError("handlePacket(): Unknown protocol: protocolId = %d, protocolName = %s, servicePrimitive = INDICATION, pathStartGate = %s, pathEndGate = %s", protocol->getId(), protocol->getName(), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
            }
        }
        else
            throw cRuntimeError("handlePacket(): Unknown service primitive: servicePrimitive = %d, pathStartGate = %s, pathEndGate = %s", static_cast<int>(servicePrimitive), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
    }
    const auto& interfaceReq = packet->findTag<InterfaceReq>();
    if (interfaceReq != nullptr) {
        int interfaceId = interfaceReq->getInterfaceId();
        auto it = interfaceIdToGateIndex.find(interfaceId);
        if (it != interfaceIdToGateIndex.end()) {
            auto outGate = gate("out", it->second);
            EV_INFO << "Dispatching packet to interface" << EV_FIELD(interfaceId) << EV_FIELD(inGate) << EV_FIELD(outGate) << EV_FIELD(packet) << EV_ENDL;
            return outGate;
        }
        else
            throw cRuntimeError("handlePacket(): Unknown interface: interfaceId = %d, pathStartGate = %s, pathEndGate = %s", interfaceId, inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
    }
    throw cRuntimeError("handlePacket(): Unknown packet: %s(%s), pathStartGate = %s, pathEndGate = %s", packet->getName(), packet->getClassName(), inGate->getPathStartGate()->getFullPath().c_str(), inGate->getPathEndGate()->getFullPath().c_str());
}

Referenced by arrived().

handleRegisterAnyProtocol()

void inet::MessageDispatcher::handleRegisterAnyProtocol ( cGate *  gate, ServicePrimitive  servicePrimitive  )

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterAnyProtocol");
    if (!registeringAny) {
        registeringAny = true;
        EV_INFO << "Handling any protocol registration" << EV_FIELD(servicePrimitive) << EV_FIELD(gate, g) << EV_ENDL;
        auto key = Key(-1, servicePrimitive);
        auto it = protocolToGateIndex.find(key);
        if (it != protocolToGateIndex.end()) {
            if (it->second != g->getIndex())
                throw cRuntimeError("handleRegisterAnyProtocol(): any protocol is already registered: servicePrimitive = %d, pathStartGate = %s, pathEndGate = %s", static_cast<int>(servicePrimitive), g->getPathStartGate()->getFullPath().c_str(), g->getPathEndGate()->getFullPath().c_str());
        }
        else {
            protocolToGateIndex[key] = g->getIndex();
            if (forwardProtocolRegistration) {
                auto gateName = g->getType() == cGate::INPUT ? "out" : "in";
                int size = gateSize(gateName);
                for (int i = 0; i < size; i++)
                    registerAnyProtocol(gate(gateName, i), servicePrimitive);
            }
        }
        registeringAny = false;
    }
}

handleRegisterAnyService()

void inet::MessageDispatcher::handleRegisterAnyService ( cGate *  gate, ServicePrimitive  servicePrimitive  )

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterAnyService");
    if (!registeringAny) {
        registeringAny = true;
        EV_INFO << "Handling any service registration" << EV_FIELD(servicePrimitive) << EV_FIELD(gate, g) << EV_ENDL;
        auto key = Key(-1, servicePrimitive);
        auto it = serviceToGateIndex.find(key);
        if (it != serviceToGateIndex.end()) {
            if (it->second != g->getIndex())
                throw cRuntimeError("handleRegisterAnyService(): any service is already registered: servicePrimitive = %d, pathStartGate = %s, pathEndGate = %s", static_cast<int>(servicePrimitive), g->getPathStartGate()->getFullPath().c_str(), g->getPathEndGate()->getFullPath().c_str());
        }
        else {
            serviceToGateIndex[key] = g->getIndex();
            if (forwardServiceRegistration) {
                auto gateName = g->getType() == cGate::INPUT ? "out" : "in";
                int size = gateSize(gateName);
                for (int i = 0; i < size; i++)
                    registerAnyService(gate(gateName, i), servicePrimitive);
            }
        }
        registeringAny = false;
    }
}

handleRegisterInterface()

void inet::MessageDispatcher::handleRegisterInterface ( const NetworkInterface &  interface, cGate *  out, cGate *  in  )

overridevirtual

Implements inet::IInterfaceRegistrationListener.

{
    Enter_Method("handleRegisterInterface");
    EV_INFO << "Handling interface registration" << EV_FIELD(interface) << EV_FIELD(out, out) << EV_FIELD(in) << EV_ENDL;
    auto it = interfaceIdToGateIndex.find(interface.getInterfaceId());
    if (it != interfaceIdToGateIndex.end()) {
        if (it->second != out->getIndex())
            throw cRuntimeError("handleRegisterInterface(): interface is already registered: interfaceId = %d, interfaceName = %s, pathStartGate = %s, pathEndGate = %s", interface.getInterfaceId(), interface.str().c_str(), out->getPathStartGate()->getFullPath().c_str(), out->getPathEndGate()->getFullPath().c_str());
    }
    else {
        interfaceIdToGateIndex[interface.getInterfaceId()] = out->getIndex();
        int size = gateSize("out");
        for (int i = 0; i < size; i++)
            if (i != in->getIndex())
                registerInterface(interface, gate("in", i), gate("out", i));
    }
}

handleRegisterProtocol()

void inet::MessageDispatcher::handleRegisterProtocol ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterProtocol");
    if (registeringProtocol != nullptr) {
        if (registeringProtocol != &protocol)
            throw cRuntimeError("handleRegisterProtocol(): cannot register protocol while another registration is being done");
    }
    else {
        registeringProtocol = &protocol;
        EV_INFO << "Handling protocol registration" << EV_FIELD(protocol) << EV_FIELD(servicePrimitive) << EV_FIELD(gate, g) << EV_ENDL;
        auto key = Key(protocol.getId(), servicePrimitive);
        auto it = protocolToGateIndex.find(key);
        if (it != protocolToGateIndex.end()) {
            if (it->second != g->getIndex())
                throw cRuntimeError("handleRegisterProtocol(): protocol is already registered: protocolId = %d, protocolName = %s, servicePrimitive = %d, pathStartGate = %s, pathEndGate = %s", protocol.getId(), protocol.str().c_str(), static_cast<int>(servicePrimitive), g->getPathStartGate()->getFullPath().c_str(), g->getPathEndGate()->getFullPath().c_str());
        }
        else {
            protocolToGateIndex[key] = g->getIndex();
            if (forwardProtocolRegistration) {
                auto gateName = g->getType() == cGate::INPUT ? "out" : "in";
                int size = gateSize(gateName);
                for (int i = 0; i < size; i++)
                    registerProtocol(protocol, gate(gateName, i), servicePrimitive);
            }
        }
        registeringProtocol = nullptr;
    }
}

handleRegisterService()

void inet::MessageDispatcher::handleRegisterService ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
    if (registeringProtocol != nullptr) {
        if (registeringProtocol != &protocol)
            throw cRuntimeError("handleRegisterService(): cannot register protocol while another registration is being done");
    }
    else {
        registeringProtocol = &protocol;
        EV_INFO << "Handling service registration" << EV_FIELD(protocol) << EV_FIELD(servicePrimitive) << EV_FIELD(gate, g) << EV_ENDL;
        auto key = Key(protocol.getId(), servicePrimitive);
        auto it = serviceToGateIndex.find(key);
        if (it != serviceToGateIndex.end()) {
            if (it->second != g->getIndex())
                throw cRuntimeError("handleRegisterService(): service is already registered: protocolId = %d, protocolName = %s, servicePrimitive = %d, pathStartGate = %s, pathEndGate = %s", protocol.getId(), protocol.str().c_str(), static_cast<int>(servicePrimitive), g->getPathStartGate()->getFullPath().c_str(), g->getPathEndGate()->getFullPath().c_str());
        }
        else {
            serviceToGateIndex[key] = g->getIndex();
            if (forwardServiceRegistration) {
                auto gateName = g->getType() == cGate::INPUT ? "out" : "in";
                int size = gateSize(gateName);
                for (int i = 0; i < size; i++)
                    registerService(protocol, gate(gateName, i), servicePrimitive);
            }
        }
        registeringProtocol = nullptr;
    }
}

initialize()

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

overrideprotectedvirtual

{
#ifdef INET_WITH_QUEUEING
    PacketProcessorBase::initialize(stage);
#endif // #ifdef INET_WITH_QUEUEING
    if (stage == INITSTAGE_LOCAL) {
        forwardServiceRegistration = par("forwardServiceRegistration");
        forwardProtocolRegistration = par("forwardProtocolRegistration");
        WATCH_MAP(socketIdToGateIndex);
        WATCH_MAP(interfaceIdToGateIndex);
        WATCH_MAP(serviceToGateIndex);
        WATCH_MAP(protocolToGateIndex);
    }
}

Member Data Documentation

forwardProtocolRegistration

bool inet::MessageDispatcher::forwardProtocolRegistration

protected

Referenced by handleRegisterAnyProtocol(), handleRegisterProtocol(), and initialize().

forwardServiceRegistration

bool inet::MessageDispatcher::forwardServiceRegistration

protected

Referenced by handleRegisterAnyService(), handleRegisterService(), and initialize().

interfaceIdToGateIndex

std::map<int, int> inet::MessageDispatcher::interfaceIdToGateIndex

protected

Referenced by handleMessage(), handlePacket(), handleRegisterInterface(), and initialize().

protocolToGateIndex

std::map<Key, int> inet::MessageDispatcher::protocolToGateIndex

protected

Referenced by handleMessage(), handlePacket(), handleRegisterAnyProtocol(), handleRegisterProtocol(), and initialize().

registeringAny

bool inet::MessageDispatcher::registeringAny = false

protected

Referenced by handleRegisterAnyProtocol(), and handleRegisterAnyService().

registeringProtocol

const Protocol* inet::MessageDispatcher::registeringProtocol = nullptr

protected

Referenced by handleRegisterProtocol(), and handleRegisterService().

serviceToGateIndex

std::map<Key, int> inet::MessageDispatcher::serviceToGateIndex

protected

Referenced by handleMessage(), handlePacket(), handleRegisterAnyService(), handleRegisterService(), and initialize().

socketIdToGateIndex

std::map<int, int> inet::MessageDispatcher::socketIdToGateIndex

protected

Referenced by handleMessage(), handlePacket(), and initialize().

---

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

• MessageDispatcher.h
• MessageDispatcher.cc