BaseConnectionManager.h

#ifndef BASECONNECTIONMANAGER_H_
#define BASECONNECTIONMANAGER_H_

#include "NicEntry.h"

class ChannelAccess;

class BaseConnectionManager : public cSimpleModule
{
private:
  class GridCoord
  {
  public:
    static const int UNDEFINED = 0;
    int x;
    int y;
    int z;
    bool use2D;

  public:
    GridCoord()
      :x(0), y(0), z(0), use2D(false) {};

    GridCoord(int x, int y)
      :x(x), y(y), z(UNDEFINED), use2D(true) {};

    GridCoord(int x, int y, int z)
      :x(x), y(y), z(z), use2D(false) {};

    GridCoord(const GridCoord& o) {
      x = o.x;
      y = o.y;
      z = o.z;
      use2D = o.use2D;
        }

        GridCoord(const Coord& c, const Coord& gridCellSize = Coord(1.0,1.0,1.0)) {
            x = static_cast<int>(c.getX() / gridCellSize.getX());
            y = static_cast<int>(c.getY() / gridCellSize.getY());
            z = static_cast<int>(c.getZ() / gridCellSize.getZ());
            use2D = c.is2D();
        }

        std::string info() const {
      std::stringstream os;
      if (use2D) {
        os << "(" << x << "," << y << ")";
      } else {
        os << "(" << x << "," << y << "," << z << ")";
      }
      return os.str();
    }

    friend bool operator==(const GridCoord& a, const GridCoord& b) {
      return a.x == b.x && a.y == b.y && a.z == b.z;
    }

    friend bool operator!=(const GridCoord& a, const GridCoord& b) {
      return !(a==b);
    }
  };

  class CoordSet {
  protected:
    std::vector<GridCoord*> data;
    unsigned maxSize;
    unsigned size;
    unsigned current;

  protected:

    void insert(const GridCoord& c, unsigned pos) {
      if(data[pos] == 0) {
        data[pos] = new GridCoord(c);
        size++;
      } else {
        if(*data[pos] != c) {
          insert(c, (pos + 2) % maxSize);
        }
      }
    }

  public:
    CoordSet(unsigned sz)
      :maxSize(sz), size(0), current(0)
    {
      data.resize(maxSize);
    }

    ~CoordSet() {
      for(unsigned i = 0; i < maxSize; i++) {
        if(data[i] != 0) {
          delete data[i];
        }
      }
    }

    void add(const GridCoord& c) {
      unsigned hash = (c.x * 10000 + c.y * 100 + c.z) % maxSize;
      insert(c, hash);
    }

    GridCoord* next() {
      for(;current < maxSize; current++) {
        if(data[current] != 0) {
          return data[current++];
        }
      }
      return 0;
    }

    unsigned getSize() { return size; }

    unsigned getmaxSize() { return maxSize; }
  };

protected:
  typedef std::map<int, NicEntry*> NicEntries;

  NicEntries nics;

  bool coreDebug;

  bool sendDirect;

  const Coord* playgroundSize;

  double maxInterferenceDistance;

  double maxDistSquared;

  bool useTorus;

  bool drawMIR;

  typedef std::vector<NicEntries> RowVector;
  typedef std::vector<RowVector> NicMatrix;
    typedef std::vector<NicMatrix> NicCube;

    NicCube nicGrid;

    Coord findDistance;

    GridCoord gridDim;

private:
    void updateNicConnections(NicEntries& nmap, NicEntry* nic);

    void checkGrid(GridCoord& oldCell,
                   GridCoord& newCell,
                   int id);

    GridCoord getCellForCoordinate(const Coord& c);

    NicEntries& getCellEntries(GridCoord& cell);

    int wrapIfTorus(int value, int max);

    void fillUnionWithNeighbors(CoordSet& gridUnion, GridCoord cell);
protected:

  virtual double calcInterfDist() = 0;

  virtual void registerNicExt(int nicID);

  virtual void updateConnections(int nicID, const Coord* oldPos, const Coord* newPos);

public:

  virtual ~BaseConnectionManager();

  virtual int numInitStages() const {
    return 2;
  }

  virtual void initialize(int stage);

  bool registerNic(cModule* nic, ChannelAccess* chAccess, const Coord* nicPos);

  bool unregisterNic(cModule* nic);

  void updateNicPos(int nicID, const Coord* newPos);

  const NicEntry::GateList& getGateList( int nicID);

  const cGate* getOutGateTo(const NicEntry* nic, const NicEntry* targetNic);
};

#endif /*BASECONNECTIONMANAGER_H_*/