grapher.h

#ifndef GRAPHER_H_
#define GRAPHER_H_

#include <string>
#include <map>
#include <iostream>
#include <algorithm> // for_each
#include <utility> // pair

#include "math.h"
#include "AdjacencyList.h"
#include "ForceLayout.h"
#include "bubble_tree_layout.h"
#include "tree_layout.h"
#include "defines.h"
#include "graph_filter_list.h"
#include "graph_properties.h"

template<typename V_type, typename E_type, typename V_CompareFunctor, typename E_CompareFunctor = CompareSWUDependency > class Grapher {
  public:
    Grapher(){
       position_map_ = NULL;
       filter_ = NULL;
    }

    Grapher(const Grapher& g) : filter_(g.filter_) {
      if(g.position_map_ != 0)
        position_map_ = new position_map_t(*(g.position_map_));
    }

    ~Grapher() {
      if(position_map_ != 0)
        delete position_map_;
    }

    typedef Grapher<V_type, E_type, V_CompareFunctor, E_CompareFunctor> GraphType;

    typedef unsigned int index_type_t;

    typedef V_type node_value_type;

    typedef E_type edge_value_type;

    typedef V_CompareFunctor comparator;

    typedef std::map<index_type_t, std::set<index_type_t> > incoming_map_t;

    typedef std::map<V_type, index_type_t, V_CompareFunctor> node_map_t;

    typedef std::map<index_type_t, V_type> node_data_t;

    typedef std::map< std::pair< index_type_t, index_type_t> , E_type> edge_map_t;

    typedef std::vector< std::pair<int, int> > position_map_t;

    typedef std::map<std::string, std::string> property_map_t;

    typedef std::map<V_type, property_map_t*, V_CompareFunctor> node_property_map_t;

    typedef std::map<E_type, property_map_t*, E_CompareFunctor> edge_property_map_t; 

    typedef typename node_data_t::iterator node_iterator;
    typedef typename node_data_t::const_iterator const_node_iterator;
    node_iterator node_begin() { return node_data_.begin(); }
    node_iterator node_end() { return node_data_.end(); }

    typedef typename edge_map_t::iterator edge_iterator;
    typedef typename edge_map_t::const_iterator const_edge_iterator;
    edge_iterator edge_begin() { return edge_data_.begin(); }
    edge_iterator edge_end() { return edge_data_.end(); }

    enum LayoutType { FORCE, HIERARCHY, BUBBLE };

    void Layout(double width, double height, LayoutType l = HIERARCHY) {
      if(position_map_ != 0)
        delete position_map_;
      position_map_ = 0;

      // use the ForceLayout which takes the adjlist graph and number of steps
      switch(l) {
        case FORCE:
          position_map_ = Layout::layout(g_, 100, width, height);
          break;
        case BUBBLE:
          position_map_ = Layout::bubble_tree_layout(g_);//, 100, width, height);
          break;
        case HIERARCHY:
        default:
          position_map_ = Layout::tree_layout(g_);
          break;
      }
    }

    void Layout(V_type v, double width, double height, LayoutType l = HIERARCHY) {
      if(v == 0 || l == FORCE) {
        Layout(width, height, l);
        return;
      }
        
      if(position_map_ != 0)
        delete position_map_;

      position_map_ = 0;

      switch(l) {
        case BUBBLE:
          position_map_ = Layout::bubble_tree_layout(g_, vertex(v));
          break;
        case HIERARCHY:
        default:
          position_map_ = Layout::tree_layout(g_, vertex(v));
          break;
      } 
    }

    bool has_layout() {
      return (position_map_ != 0);
    }

    GraphProperties<GraphType>& properties() { return properties_; }

    unsigned int num_nodes() {
      return node_map_.size();
    }

    unsigned int num_edges() {
      return edge_data_.size();
    }

    unsigned int num_nodedata() {
      return node_data_.size();
    }

    position_map_t::value_type position(const V_type v) {
      if(position_map_ != 0) {
        if(position_map_->size() > node_map_[v])
          return position_map_->at(node_map_[v]);
      } else {
        return std::make_pair(0,0);
      }
      return std::make_pair(0,0);
    }

    bool exists(V_type v) {
      typename node_map_t::iterator it = node_map_.find(v);

      //  Check if it was found or not !
      return (it !=  node_map_.end()) ;
    }

    bool add_node(V_type v){ 
      if(filter_ != NULL)
        if(!(*filter_)(v))
          return false;

      // give this module a vertex number
      index_type_t node =  (index_type_t)g_.add_node();

      // Set up the maps
      node_map_[v] = node;
      node_data_[node] = v;

      // add an empty set of incoming edges for this node
      incoming_map_[node] = std::set<index_type_t>();

      return true;
    }

    bool add_edge(V_type from, V_type to, E_type edge_data) {
      if(!exists(from) || !exists(to))
        return false;
      
      if (filter_ != NULL) {
        if (!(*filter_)(edge_data)) {
          return false;
        }
      }

      index_type_t u = node_map_[from];
      index_type_t v = node_map_[to];

      g_.add_edge(u,v);

      edge_data_[std::make_pair(u,v)] = edge_data;

      // add u to the incoming of v
      incoming_map_[v].insert(u);

      return true;
    }

    index_type_t vertex(V_type node) {
      // TODO: om node inte finns kommer det här lägga till node som
      // nyckel iaf, bättre att kolla med find om den finns först?
      return node_map_[node];
    }

    V_type vertex(index_type_t index) {
      typename node_data_t::iterator it = node_data_.find(index);

      if (it != node_data_.end()) {
        return node_data_[index];
      }

      return NULL;
    }

    std::vector<E_type>* edges(V_type v){
      std::vector<E_type>* return_edges = new std::vector<E_type>();

      std::set<index_type_t>& edges = *g_.adjacent_vertices(node_map_[v]);
      
      std::set<index_type_t>::iterator it = edges.begin();
      for (; it != edges.end(); it++) {
        return_edges->push_back(edge_data_[std::make_pair(node_map_[v], *it)]);
      }

      return return_edges;
    }

    std::vector<E_type>* incoming_edges(V_type v) {
      std::vector<E_type>* return_edges = new std::vector<E_type>();

      index_type_t ni = node_map_[v];
      
      std::set<index_type_t>::iterator it = incoming_map_[ni].begin();

      for (; it != incoming_map_[ni].end(); it++) {
        return_edges->push_back(edge_data_[std::make_pair(*it, ni)]);
      }

      return return_edges;
    }

    const GraphFilterList<GraphType>* filter() {
        return filter_;
    }

    void set_filter(GraphFilterList<GraphType>* filter) {
       filter_ = filter;
    }

    private:
      AdjacencyList g_;

      incoming_map_t incoming_map_;

      GraphFilterList<GraphType>* filter_;

      // NOTE: the AdjacencyList and the map are used in conjunction
      // to map a node type to a vertex in the AdjacencyList

      node_map_t node_map_;

      node_data_t node_data_;

      edge_map_t edge_data_;

      position_map_t* position_map_;

      GraphProperties<GraphType> properties_;
};


#endif