ChannelControl.h

/* -*- mode:c++ -*- ********************************************************
 * file:        ChannelControl.h
 *
 * author:      Steffen Sroka, Daniel Willkomm
 *
 * copyright:   (C) 2004 Telecommunication Networks Group (TKN) at
 *              Technische Universitaet Berlin, Germany.
 *
 *              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
 * description: Module to control the channel and handle all connection
 *              related stuff
 **************************************************************************/

#ifndef CHANNELCONTROL_H
#define CHANNELCONTROL_H

#include <omnetpp.h>
#include <list>
#include <vector>

#include "Coord.h"
#include "NicEntry.h"

class ChannelControl : public cSimpleModule
{
protected:
    bool coreDebug;

    typedef std::map<int, NicEntry*> NicEntries;
    typedef std::vector<NicEntries> RowVector;
    typedef std::vector<RowVector> NicMatrix;

    NicMatrix nics;

    bool sendDirect;

    Coord playgroundSize;
    
    double maxInterferenceDistance;

    double maxDistSquared;

    double findDistance;

    unsigned maxX, maxY;

    bool useTorus;
    
protected:
    bool increment(unsigned max, unsigned src, unsigned* target) {
        bool res = true;
        unsigned v = src + 1;
        if(src == max) {
            v = 0;
            if(!useTorus) res = false;
        }
        *target = v;
        return res;
    }
    
    bool decrement(unsigned max, unsigned src, unsigned* target) {
        bool res = true;
        unsigned v = src - 1;
        if(src == 0) {
            v = max;
            if(!useTorus) res = false;
        }
        *target = v;
        return res;
    }

    bool inRangeEuclid(const Coord& a, const Coord& b) {
        return a.sqrdist(b) < maxDistSquared;
    }

    bool inRangeTorus(const Coord& a, const Coord& b);
public:
    Module_Class_Members(ChannelControl, cSimpleModule, 0);
    
    virtual void initialize();
    
    // const Coord* getNicPos( int );
    
    bool registerNic( cModule*, const Coord* );
    
    void updateNicPos(int, const Coord* oldPos, const Coord* newPos);
    
    const Coord* getPgs(){
        return &playgroundSize;
    };
    
    const NicEntry::GateList& getGateList( int, const Coord* );

    const cGate* getOutGateTo(int, int, const Coord*);
  
    static const double speedOfLight;

protected:
    void updateConnections(NicEntries& nmap, NicEntry* nic);
    
    virtual double calcInterfDist();

    void checkGrid(unsigned oldX, unsigned oldY,
                   unsigned newX, unsigned newY,
                   int id);
};

#endif

---