Network.hpp

Go to the documentation of this file.

/****************************************************************
 * NETWORK.HPP
 *
 * This file contains all the data related class and methods.
 *
 * Authors: J. Barthelemy
 * Date   : 08 april 2013
 ****************************************************************/

#ifndef NETWORK_HPP_
#define NETWORK_HPP_

#include <map>
#include <vector>
#include <iostream>
#include <functional>
#include <limits>
#include <utility>
#include <sstream>
#include <set>
#include "Random.hpp"
#include "FiboHeap.hpp"


class Node {

private:

  long   _id;                       
  float _x;                        
  float _y;                        
  int    _ins;                      

  std::vector<long> _links_out_id;  
  float             _key;           
  int               _index;         

  std::map<std::string,long> _indicators;    


public:

  Node() : _id(0), _x(0), _y(0), _ins(0), _links_out_id(), _key(-1), _index(-1), _indicators() {};


  Node(long id, float x, float y, int ins);

  virtual ~Node() {};


  long getId() const {
    return _id;
  }


  void setId(long id) {
    _id = id;
  }


  int getIns() const {
    return _ins;
  }


  void setIns(int ins) {
    _ins = ins;
  }


  const std::vector<long>& getLinksOutId() const {
    return _links_out_id;
  }


  void setLinksOutId(const std::vector<long>& linksOutId) {
    _links_out_id = linksOutId;
  }


  void addLinkOutId( long linkId ) {
    _links_out_id.push_back(linkId);
  }


  float getKey() const {
    return _key;
  }


  void setKey(float key) {
    _key = key;
  }


  float getX() const {
    return _x;
  }


  void setX(float x) {
    _x = x;
  }


  float getY() const {
    return _y;
  }


  void setY(float y) {
    _y = y;
  }


  int getIndex() const {
    return _index;
  }


  void setIndex(int index) {
    _index = index;
  }


  const std::map<std::string, long>& getIndicators() const {
    return _indicators;
  }


  void setIndicators(const std::map<std::string, long>& indicators) {
    _indicators = indicators;
  }


  void addIndicator(std::string aIndicator, long aIndicatorValue );


  friend bool operator<(const Node &aNode1, const Node &aNode2);


  friend bool operator>(const Node &aNode1, const Node &aNode2);


  bool operator<(Node &aNode) {
    return this->_key < aNode.getKey();
  }


  bool operator>(Node &aNode) {
    return this->_key > aNode.getKey();
  }

};



class Link {

private:

  long  _id;                 
  long  _start_node_id;      
  long  _end_node_id;        
  float _length;             

public:

  Link() : _id(0), _start_node_id(0), _end_node_id(0), _length(0) {};


  Link(long id, long start_node, long end_node, float length);

  virtual ~Link() {};


  long getEndNodeId() const {
    return _end_node_id;
  }


  void setEndNodeId(long endNodeId) {
    _end_node_id = endNodeId;
  }


  long getId() const {
    return _id;
  }


  void setId(long id) {
    _id = id;
  }


  float getLength() const {
    return _length;
  }


  void setLength(float length) {
    _length = length;
  }


  long getStartNodeId() const {
    return _start_node_id;
  }


  void setStartNodeId(long startNodeId) {
    _start_node_id = startNodeId;
  }

};



class DHeap {

private:

  std::vector<Node> heap;                  
  std::map<long,int> _map_nodeid_index;    
  int _d;                                  


  int parent(int child);


  int child(int parent, int ith);


  void heapifyup(int index);


  void heapifydown(int index);

public:

  DHeap();


  DHeap(unsigned long size, unsigned int d);


  DHeap(unsigned int d, long node_id, std::map<long, Node> &Nodes);

  virtual ~DHeap();


  void insert(Node &element);


  void pushBack(Node &element);


  const Node deletemin();


  void decreaseKey( int index, float key );


  std::map<long, int> getMapNodeidIndex() const {
    return _map_nodeid_index;
  }


  int size() {
    return heap.size();
  }

};


class Network {

private:

  std::map<long, Node> _Nodes;                                    
  std::map<long, Link> _Links;                                    

  float min_x;                                                   
  float max_x;                                                   
  float min_y;                                                   
  float max_y;                                                   

public:

  Network() {

    min_x = 0.0;
    max_x = 0.0;
    min_y = 0.0;
    max_y = 0.0;

  };

  virtual ~Network() {};


  const std::map<long, Link>& getLinks() const {
    return _Links;
  }


  void setLinks(const std::map<long, Link>& links) {
    _Links = links;
  }


  const std::map<long, Node>& getNodes() const {
    return _Nodes;
  }


  void setNodes(const std::map<long, Node>& nodes) {
    _Nodes = nodes;
  }

  /*
   /param nodeId the source node's id
   /param linkId the id of link to be added
   */
  void addLinkOutToNode(long nodeId, long linkId) {
    _Nodes[nodeId].addLinkOutId(linkId);
  }


  void addNode(Node aNode);


  void addLink(Link aLink);


  long getDestFromSource(long source_id, float dist);


  float getDistanceNodes(long source_id, long dest_id);


  float getMaxX() const {
    return max_x;
  }


  void setMaxX(float maxX) {
    max_x = maxX;
  }


  float getMaxY() const {
    return max_y;
  }


  void setMaxY(float maxY) {
    max_y = maxY;
  }


  float getMinX() const {
    return min_x;
  }


  void setMinX(float minX) {
    min_x = minX;
  }


  float getMinY() const {
    return min_y;
  }


  void setMinY(float minY) {
    min_y = minY;
  }

};

#endif /* NETWORK_HPP_ */