tpl_concurrent_graph.H

/*
  This file is part of Aleph system

  Copyright (c) 2002, 2003, 2004, 2005, 2006
  UNIVERSITY LOS ANDES (ULA) Merida - REPÚBLICA BOLIVARIANA DE VENEZUELA  

  - Center of Studies in Microelectronics & Distributed Systems (CEMISID) 
  - ULA Computer Science Department
  - FUNDACITE Mérida - Ministerio de Ciencia y Tecnología

  PERMISSION TO USE, COPY, MODIFY AND DISTRIBUTE THIS SOFTWARE AND ITS
  DOCUMENTATION IS HEREBY GRANTED, PROVIDED THAT BOTH THE COPYRIGHT
  NOTICE AND THIS PERMISSION NOTICE APPEAR IN ALL COPIES OF THE
  SOFTWARE, DERIVATIVE WORKS OR MODIFIED VERSIONS, AND ANY PORTIONS
  THEREOF, AND THAT BOTH NOTICES APPEAR IN SUPPORTING DOCUMENTATION.

  Aleph is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE.

  UNIVERSIDAD DE LOS ANDES requests users of this software to return to 

  Leandro Leon
  CEMISID 
  Ed La Hechicera 
  3er piso, ala sur
  Facultad de Ingenieria 
  Universidad de Los Andes 
  Merida - REPÚBLICA BOLIVARIANA DE VENEZUELA    or

  lrleon@ula.ve

  any improvements or extensions that they make and grant Universidad 
  de Los Andes (ULA) the rights to redistribute these changes. 

  Aleph is (or was) granted by: 
  - Consejo de Desarrollo Cientifico, Humanistico, Tecnico de la ULA 
    (CDCHT)
  - Fundacite Mérida
*/

# ifndef TPL_CONCURRENT_GRAPH_H
# define TPL_CONCURRENT_GRAPH_H

# include <pthread.h>
# include <tpl_graph.H>
# include <useMutex.H>

using namespace Aleph;


namespace Aleph 
{

    template <typename Node_Info, typename Arc_Info> 
class Concurrent_Graph;

     template <typename Node_Info> 
struct Concurrent_Node : public Graph_Node<Node_Info> 
{
  typedef Graph_Node<Node_Info> Base_Node;

  typedef Node_Info Node_Type;
     
  pthread_mutex_t mutex; // protege toda la data asociada al nodo
   
  Concurrent_Node() : Base_Node() 
  {
    init_mutex(mutex);
  }
     
  Concurrent_Node(const Node_Info & node_info) : Base_Node(node_info) 
  {
    init_mutex(mutex);
  }
  
  Concurrent_Node(Base_Node * node) : Base_Node(node) 
  {
    init_mutex(mutex);
  }
     
  ~Concurrent_Node() 
  {
    destroy_mutex(mutex);   
  }
     
  class Critical_Section : public UseMutex
  {
  public:

    Critical_Section(Concurrent_Node * node) 
      : UseMutex(node->mutex) 
    {
      /* empty */ 
    }
  };
};

    template <typename Arc_Info> 
struct Concurrent_Arc : public Graph_Arc<Arc_Info> 
{
  typedef Graph_Arc<Arc_Info> Base_Arc;

  typedef Arc_Info Arc_Type;

  pthread_mutex_t mutex;

  Concurrent_Arc(Base_Arc * arc) : Base_Arc(arc)
  {
    init_mutex(mutex);
  }
     
  Concurrent_Arc() : Base_Arc() 
  {
    init_mutex(mutex);
  }
    
  Concurrent_Arc(void * src, void * tgt, const Arc_Info & data) 
    : Base_Arc(src, tgt, data)
  {
    init_mutex(mutex);
  }
    
  ~Concurrent_Arc() 
  {
    destroy_mutex(mutex);
  }

  class Critical_Section : public UseMutex
  {
  public:

    Critical_Section(Concurrent_Arc * arc) 
      : UseMutex(arc->mutex) { /* empty */ }
  };
};

    template <typename Node, typename Arc> 
class Concurrent_Graph : public List_Graph<Node, Arc> 
{
protected:

  pthread_mutex_t mutex;

public:
     
  typedef List_Graph< Node, Arc > Base_Graph;

  typedef typename Node::Node_Type Node_Type; 

  typedef typename Arc::Arc_Type Arc_Type;

  Concurrent_Graph() : Base_Graph() 
  {
    init_mutex(mutex);  
  }

  Concurrent_Graph(const Concurrent_Graph & g) : Base_Graph(g) 
  {
    init_mutex(mutex); 
  }

  Concurrent_Graph & operator = (const Concurrent_Graph & g)
  {
    CRITICAL_SECTION(mutex);

    if (this == &g)
      return *this;

    copy_graph(*this, g);

    return *this;   
  }
       
  virtual ~Concurrent_Graph() 
  {
    destroy_mutex(mutex);
  }

  class Node_Iterator  
  {
    Concurrent_Graph<Node, Arc> & cg;

    typename Base_Graph::Node_Iterator base_iterator;

  public:
    
    Node_Iterator() : base_iterator() 
    { 
      // empty
    }

    Node_Iterator(Concurrent_Graph & _g) : cg(_g), base_iterator(_g)
    {
      // empty
    }

    Node_Iterator(const Node_Iterator & it) 
      : cg(it.cg), base_iterator(it.base_iterator)
    {
      // empty
    }

    Node_Iterator & operator = (const Node_Iterator & it) 
    {
      CRITICAL_SECTION(cg.mutex);

      if (&it == this)
     return *this;

      base_iterator = it.base_iterator;
      
      return *this;
    }
    
    Node * get_current_node() 
    {
      CRITICAL_SECTION(cg.mutex);

      Node * node = base_iterator.get_current_node();
     
      return node;
    }
     
    bool has_current() 
    {
      CRITICAL_SECTION(cg.mutex);

      return base_iterator.has_current();
    }
     
    void next() 
    {
      CRITICAL_SECTION(cg.mutex);
      
      base_iterator.next();
    }

    void prev() 
    {
      CRITICAL_SECTION(cg.mutex);
      
      base_iterator.prev();
    }
  };

  class Arc_Iterator 
  {
    Concurrent_Graph<Node, Arc> & cg;
     
    typename Base_Graph::Arc_Iterator base_iterator;

  public:
    
    Arc_Iterator() : base_iterator() 
    { 
      // empty
    }

    Arc_Iterator(Concurrent_Graph & _g) : cg(_g), base_iterator(_g)
    {
      // empty
    }

    Arc_Iterator(const Arc_Iterator & it) 
      : cg(it.cg), base_iterator(it.base_iterator)
    {
      // empty
    }
     
    Arc_Iterator & operator = (const Arc_Iterator & it) 
    {
      CRITICAL_SECTION(cg.mutex);

      base_iterator = it.base_iterator;

      return *this;
    }

    Arc * get_current_arc() 
    { 
      CRITICAL_SECTION(cg.mutex);

      Arc * arc = base_iterator.get_current_arc();

      return arc;
    }

    bool has_current() 
    {
      CRITICAL_SECTION(cg.mutex);

      return base_iterator.has_current();
    }
     
    void next() 
    {
      CRITICAL_SECTION(cg.mutex);
      
      base_iterator.next();
    }

    void prev() 
    {
      CRITICAL_SECTION(cg.mutex);
      
      base_iterator.prev();
    }
  };

  size_t get_num_nodes()  
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::get_num_nodes(); 
  }

      // Hace visible get_num_arcs(Node*) heredada de List_Graph
  using List_Graph<Node, Arc>::get_num_arcs;
     
  size_t get_num_arcs() 
  {
    CRITICAL_SECTION(mutex); 

    return Base_Graph::get_num_arcs(); 
  }
 
  Node * search_node(const Node_Type & node_info)
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::search_node(node_info);
  } 

  Node * insert_node(Node * node)
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::insert_node(node);
  }
     
  Node * insert_node(const Node_Type & node_info)
  {
    Node * ret_val = new Node(node_info);

    return insert_node(ret_val);
  }

  Node * get_first_node() 
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::get_first_node();
  }
     
  Arc * get_first_arc() 
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::get_first_arc(); 
  }
     
  void verify_graphs(Concurrent_Graph& g) 
  {
    CRITICAL_SECTION(mutex); 

    Base_Graph::verify_graphs(g);       
  }
     
  void remove_node(Node * node)
  {
    CRITICAL_SECTION(mutex);

    Base_Graph::remove_node(node);           
  }
  
  template <class Operation> void operate_on_nodes()
  {
    CRITICAL_SECTION(mutex);
    
    for (typename Base_Graph::Node_Iterator itor(*this); 
      itor.has_current(); itor.next())
      Operation () (*this, itor.get_current_node());
  }

  template <class Operation> void operate_on_arcs()
  {
    CRITICAL_SECTION(mutex);

    for (typename Base_Graph::Arc_Iterator itor(*this); 
      itor.has_current(); itor.next())
      Operation () (*this, itor.get_current_arc());
  }

  template <class Operation> void operate_on_nodes(void * ptr)
  {
    CRITICAL_SECTION(mutex);

    for (typename Base_Graph::Node_Iterator itor(*this); 
      itor.has_current(); itor.next())
      Operation () (*this, itor.get_current_node(), ptr);
  }

  template <class Operation> void operate_on_arcs(void * ptr)
  {
    CRITICAL_SECTION(mutex);

    for (typename Base_Graph::Arc_Iterator itor(*this); 
      itor.has_current(); itor.next())
      Operation () (*this, itor.get_current_arc(), ptr);
  }

  template <class Compare> void sort_arcs()
  {
    CRITICAL_SECTION(mutex);

    Base_Graph::template sort_arcs<Compare> ();
  }

  Arc * insert_arc(Node *           src_node, 
             Node *           tgt_node, 
             const Arc_Type & arc_info) 
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::insert_arc(src_node, tgt_node, arc_info);      
  }

  void remove_arc(Arc * arc)
  {
    CRITICAL_SECTION(mutex);

    Base_Graph::remove_arc(arc);
  }
    
  Arc * search_arc(Node * src_node, Node * tgt_node) 
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::search_arc(src_node, tgt_node);      
  }
    
  Arc * search_arc(const Arc_Type & arc_info)
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::search_arc(arc_info);      
  }
  
  bool arc_belong_to_graph(Arc * arc) 
  {
    CRITICAL_SECTION(mutex);

    return Base_Graph::arc_belong_to_graph(arc);
  }
};

}

# endif // TPL_CONCURRENT_GRAPH_H

---