tpl_indexGraph.H

# ifndef TPL_INDEXGRAPH
# define TPL_INDEXGRAPH

# include <tpl_indexNode.H>
# include <tpl_indexArc.H>

namespace Aleph
{

template 
<class GT, 
 class Compare = Dft_Node_Cmp<GT>,
 template <class /* Key */, class /* Compare */> class Tree = Treap>
class Index_Graph
{
private:

  typedef typename GT::Arc GT_Arc;
  typedef typename GT::Node GT_Node;
  typedef typename GT::Arc_Type GT_Arc_Type;
  typedef typename GT::Node_Type GT_Node_Type;

  IndexNode<GT, Compare, Tree> idx_node;
  IndexArc<GT, Tree>           idx_arc;

public:

  Index_Graph(GT & g) : idx_node(g), idx_arc(g)
  {
    // empty
  }

  GT_Node * insert_node(const GT_Node_Type & info)
  {
    return idx_node.insert_in_graph(info);
  }

  GT_Arc * insert_arc(GT_Node * src, GT_Node * tgt, 
                      const GT_Arc_Type & info = GT_Arc_Type())
    throw (std::exception, std::domain_error)
  {
    if (idx_node.search(src) == NULL)
      throw std::domain_error("src node not in index");

    if (idx_node.search(tgt) == NULL)
      throw std::domain_error("tgt node not in index");

    return idx_arc.insert_in_graph(src, tgt, info);
  }

  GT_Node * search_node(GT_Node * p)
  {
    return idx_node.search(p);
  } 

  GT_Node * search_node(const GT_Node_Type & info)
  {
    return idx_node.search(info);
  }

  GT_Arc * search_arc(GT_Node * src, GT_Node * tgt)
  {
    return idx_arc.search(src, tgt);
  }

  void remove_node(GT_Node * p)
  {
        // eliminar del índice los arcos emanantes del nodo (ellos serán
        // eliminados por la eliminación de nodo del grafo)
    for (typename GT::Node_Arc_Iterator it(p); it.has_current(); it.next())
      idx_arc.remove(it.get_current());

    return idx_node.remove_from_graph(p); 
  }

  void remove_arc(GT_Arc * a)
  {
    return idx_arc.remove_from_graph(a);
  }

  size_t get_num_arcs() const { return idx_arc.size(); }

  size_t get_num_nodes() const { return idx_node.size(); }
};


}

# endif // TPL_INDEXGRAPH