tpl_indexNode.H

# ifndef TPL_INDEXNODE_H
# define TPL_INDEXNODE_H

# include <tpl_dynSetTree.H>
# include <tpl_graph.H>

using namespace Aleph;

namespace Aleph
{

  template <class GT>
struct Dft_Node_Cmp
{
      bool
  operator () (typename GT::Node * p1, typename GT::Node * p2) const
  {
    return p1->get_info() < p2->get_info();
  }
};

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

  typedef typename GT::Node GT_Node;
  typedef typename GT::Node_Type GT_Node_Type;
        
  DynSetTree<GT_Node*, Tree, Compare> index;

  GT & g;
  SN & sn;
                
public:

  GT_Node * insert(GT_Node * p)
  {
    index.put(p);
    return p;
  }

  GT_Node * insert_in_graph(const GT_Node_Type & info)
  {
    GT_Node * ret_val = g.insert_node(info);

    try
      {
        insert(ret_val);

        return ret_val;
      }
    catch (...)
      {
        g.remove_node(ret_val);
        throw;
      }
  }

  GT_Node * insert_in_graph(GT_Node_Type && info = GT_Node_Type())
  {
    GT_Node * ret_val = g.insert_node(std::move(info));

    try
      {
        insert(ret_val);

        return ret_val;
      }
    catch (...)
      {
        g.remove_node(ret_val);
        throw;
      }
  }

  GT_Node * search(GT_Node * p)
  {
    GT_Node ** ret_val = index.search(p);

    if (ret_val == NULL)
      return NULL;

    return *ret_val;
  }

  GT_Node * search(const GT_Node_Type & info)
  {
    GT_Node dummy_node(info);
    GT_Node * dummy_node_ptr = &dummy_node;

    return search(dummy_node_ptr);
  }

  void remove(GT_Node * p)
  {
    index.remove(p);
  }

  void remove_from_graph(GT_Node * p) throw(std::exception, std::domain_error)
  {
    index.find(p); // dispara excepción si p no está en el índice
    index.remove(p);
    g.remove_node(p);
  }

  void clear_index()
  {
    index.empty();
  }

  void build_index()
  {
    for (Node_Iterator<GT, SN> it(g, sn); it.has_curr(); it.next())
      {
        GT_Node * p = it.get_curr();

        if (search(p) != p)
          insert(p);
      }
  }

  void clear_graph()
  {
    clear_index();
    g.clear_graph();
  }

private: 

  void init()
  {
    for (Node_Iterator<GT, SN> it(g, sn); it.has_curr(); it.next())
      insert(it.get_curr());
  }

public:

  IndexNode(GT & __g, SN && __sn = SN()) : g(__g), sn(__sn)
  {
    init();
  }

  IndexNode(GT & __g, SN & __sn) : g(__g), sn(__sn) 
  {
    init();
  }

  size_t size() const { return index.size(); }
};

}

# endif