ChannelControl.h

Go to the documentation of this file.

/* -*- mode:c++ -*- ********************************************************
 * file:        ChannelControl.h
 *
 * copyright:   (C) 2006 Levente Meszaros, 2005 Andras Varga
 *
 *              This program is free software; you can redistribute it
 *              and/or modify it under the terms of the GNU General Public
 *              License as published by the Free Software Foundation; either
 *              version 2 of the License, or (at your option) any later
 *              version.
 *              For further information see file COPYING
 *              in the top level directory
 ***************************************************************************
 * part of:     framework implementation developed by tkn
 **************************************************************************/

#ifndef CHANNELCONTROL_H
#define CHANNELCONTROL_H

#include <vector>
#include <list>
#include <deque>
#include <set>
#include <omnetpp.h>
#include "AirFrame_m.h"
#include "Coord.h"

#define LIGHT_SPEED 3.0E+8
#define TRANSMISSION_PURGE_INTERVAL 1.0

//TODO complete support multiple NICs per host
class INET_API ChannelControl : public cSimpleModule
{
  protected:
    struct HostEntry;
    typedef std::list<HostEntry> HostList;

  public:
    typedef HostEntry *HostRef; // handle for ChannelControl's clients
    typedef std::vector<HostRef> HostRefVector;
    typedef std::list<AirFrame*> TransmissionList;

  protected:
    struct HostEntry {
        cModule *host;
        cGate *radioInGate;
        int channel;
        Coord pos; // cached
        std::set<HostRef> neighbors;  // cached neighbour list

        // we cache neighbors set in an std::vector, because std::set iteration is slow;
        // std::vector is created and updated on demand
        bool isNeighborListValid;
        HostRefVector neighborList;
    };
    HostList hosts;

    typedef std::vector<TransmissionList> ChannelTransmissionLists;
    ChannelTransmissionLists transmissions; // indexed by channel number (size=numChannels)

    simtime_t lastOngoingTransmissionsUpdate;

    friend std::ostream& operator<<(std::ostream&, const HostEntry&);
    friend std::ostream& operator<<(std::ostream&, const TransmissionList&);

    bool coreDebug;

    Coord playgroundSize;

    double maxInterferenceDistance;

    int numChannels;

  protected:
    virtual void updateConnections(HostRef h);

    virtual double calcInterfDist();

    virtual void updateDisplayString(cModule *playgroundMod);

    virtual void initialize();

    virtual void purgeOngoingTransmissions();

    virtual void checkChannel(const int channel);

  public:
    ChannelControl();
    virtual ~ChannelControl();

    static ChannelControl *get();

    virtual HostRef registerHost(cModule *host, const Coord& initialPos, cGate *radioInGate=NULL);

    cModule *getHost(HostRef h) const {return h->host;}

    cGate *getRadioGate(HostRef h) const {return h->radioInGate;}

    int getHostChannel(HostRef h) const {return h->channel;}

    virtual HostRef lookupHost(cModule *host);

    virtual void updateHostPosition(HostRef h, const Coord& pos);

    virtual void updateHostChannel(HostRef h, const int channel);

    const TransmissionList& getOngoingTransmissions(const int channel);

    virtual void addOngoingTransmission(HostRef h, AirFrame *frame);

    const Coord& getHostPosition(HostRef h)  {return h->pos;}

    const HostRefVector& getNeighbors(HostRef h);

    virtual void sendToChannel(cSimpleModule *srcRadioMod, HostRef srcHost, AirFrame *airFrame);

    virtual double getCommunicationRange(HostRef h) {
        return maxInterferenceDistance;
    }

    const Coord *getPgs()  {return &playgroundSize;}

    const int getNumChannels() {return numChannels;}
};

#endif