#include <tpl_concurrent_graph.H>

Diagrama de herencias de Aleph::Concurrent_Graph< GT, __Node, __Arc >

Diagrama de colaboración para Aleph::Concurrent_Graph< GT, __Node, __Arc >:

Clases
class	Arc_Iterator

class	Node_Iterator

Tipos públicos
typedef __GT< Lock_Object < __Node >, Lock_Object< __Arc > >	GT

typedef GT::Node	Node

typedef GT::Arc	Arc

typedef GT::Node_Type	Node_Type
	El tipo de nodo concurrente.

typedef GT::Arc_Type	Arc_Type
	El tipo de arco concurrente.

Métodos públicos
pthread_mutex_t *	get_mutex (int i)

pthread_mutex_t *	allocate_mutex ()

	Concurrent_Graph (const size_t &n_mut=1)
	Instancia un grafo concurrente vacío.

	Concurrent_Graph (const Concurrent_Graph &g)
	Instancia un grafo concurrente copia de otro grafo concurrente.

void	set_num_mutexes (const size_t &n)

void	distribute_mutexes_randomly ()

void	distribute_mutexes_uniformly ()

size_t	get_num_nodes ()
	Retorna el número de nodos que tiene el grafo concurrente.

size_t	get_num_arcs ()
	Retorna el número de arcos que tiene el grafo concurrente.

size_t	get_num_mutexes ()

Node *	search_node (const Node_Type &node_info)
	Busca un nodo según su información contenida.

Node *	insert_node (Node *node)
	Inserta un nodo ya creado en un grafo.

Node *	insert_node (const Node_Type &node_info)
	Crea e inserta un nuevo nodo con información node_info.

Node *	get_first_node ()
	Retorna el primer nodo de un grafo; no hay un orden determinado.

Arc *	get_first_arc ()
	Retorna el primer arco de un grafo.

void	verify_graphs (Concurrent_Graph &g)

void	remove_node (Node *node)
	Elimina un nodo de un grafo (junto con todos sus arcos adyacentes).

template<class Compare >
void	sort_arcs ()
	ordena los arcos de un grafo concurrente según criterio Compare.

Arc *	insert_arc (Node src_node, Node tgt_node, const Arc_Type &arc_info)
	Crea un arco en un grafo concurrente.

Arc *	insert_arc (Node src_node, Node tgt_node)
	Crea un arco en un grafo concurrente.

void	remove_arc (Arc *arc)
	Elimina un arco en un grafo concurrente.

Arc *	search_arc (Node src_node, Node tgt_node)
	Busca un arco que conecte a dos nodos.

Arc *	search_arc (const Arc_Type &arc_info)
	Busca un arco con información arc_info.

bool	arc_belong_to_graph (Arc *arc)
	Retorna true si el arco arc pertenece al grafo.

Métodos protegidos
void	init_mutexes ()

void	uninit_mutexes ()

Atributos protegidos
pthread_mutex_t	mutex

size_t	num_mutexes

DynArray< pthread_mutex_t >	mutexes

Descripción detallada

template<template< class, class > class GT, class Node, class Arc>
class Aleph::Concurrent_Graph< GT, Node, Arc >

Clase grafo concurrente implementado con listas de adyacencia.

Concurrent_Graph<Node, Arc> es una clase que modeliza grafos representados mediante listas de adyacencia en la cual todas sus operaciones son reentrantes y pueden ser manejadas concurrente y coherentemente por varias threads.

Esencialmente, la interfaz es casi idéntica a la de List_Graph. La diferencia fundamental es que los métodos que modifican la topología del grafo u operan con ella están protegido por un semáforo binario global. Estos métodos conciernen a la inserción y eliminación de nodos y arcos, así como a su búsqueda.

Los métodos de consulta y modificación de nodos y arcos no están protegidos; tampoco el iterador de arcos de un nodo. Úsese el semáforo de un nodo o arco si se requiere protegerlo.

La clase maneja dos parámetros tipo fundamentales:

Concurrent_Node: el tipo de los nodos que debe estar definido mediante la clase Concurrent_Node.
Concurrent_Arc: el tipo de los nodos que debe estar definido mediante la clase Concurrent_Arc.

Estas clases deben haberse definido previamente.

Una vez instanciado un Concurrent_Graph<Node, Arc>, los nodos y arcos deben accederse mediante los tipos internos:

Concurrent_Graph<Node, Arc>::Node.
Concurrent_Graph<Node, Arc>::Arc.

Parámetros

Concurrent_Node	El tipo de nodo. Debe estar definido a partir de la clase Concurrent_Node, bien sea por inclusión de atributos, por derivación o por combinación de ambos
Concurrent_Arc	El tipo de arco. Debe estar definido a partir de la clase Concurrent_Arc, bien sea por inclusión de atributos, por derivación o por combinación de ambos

Ver también: Concurrent_Node Concurrent_Arc; List_Digraph Path

Tareas pendientes:

Camino concurrente.

Nota: Los métodos sobre esta clase están brevemente documentados, pues su semántica es la misma que para la clase List_Graph. La excepción es que los métodos de Concurrent_Graph son reentrantes y seguros ante varias threads de acceso.

La documentación para esta clase fue generada a partir del siguiente fichero:

tpl_concurrent_graph.H

Clases

Tipos públicos

Métodos públicos

Métodos protegidos

Atributos protegidos

Descripción detallada

template<template< class, class > class GT, class __Node, class __Arc> class Aleph::Concurrent_Graph< GT, __Node, __Arc >

template<template< class, class > class GT, class Node, class Arc>
class Aleph::Concurrent_Graph< GT, Node, Arc >