Referencia de la plantilla de la Clase Concurrent_Graph
[Grafos.]

Clase grafo concurrente implementado con listas de adyacencia. Más...

Diagrama de herencias de Concurrent_Graph

Diagrama de colaboración para Concurrent_Graph:

Lista de todos los miembros.

Tipos públicos

typedef Arc Arc

Tipo de arco.

typedef Arc::Arc_Type Arc_Type

El tipo de arco concurrente.

typedef Node Node

Tipo de nodo.

typedef Node::Node_Type Node_Type

El tipo de nodo concurrente.

Métodos públicos

bool arc_belong_to_graph (Arc *arc)

Retorna true si el arco arc pertenece al grafo.

void clear_graph ()

Limpia todo el grafo (todos sus nodos y arcos son eliminados y la memoria es liberada).

Concurrent_Graph (const Concurrent_Graph &g)

Instancia un grafo concurrente copia de otro grafo concurrente.

Concurrent_Graph ()

Instancia un grafo concurrente vacío.

void copy_graph (List_Graph &src_graph, const bool cookie_map=false)

Copia explícita de grafos.

Node * get_connected_node (Arc *arc, Node *node)

Retorna el nodo conectado a node mediante el arco arc.

Bit_Fields & get_control_bits (Node *node)

Retorna los bits de control de un nodo.

void *& get_cookie (Arc *arc)

Obtiene el cookie de un arco.

void *& get_cookie (Node *node)

Obtiene el cookie de un nodo.

long & get_counter (Arc *arc)

Accede a contador de arco.

long & get_counter (Node *node)

Accede a contador de nodo.

Arc * get_first_arc ()

Retorna el primer arco de un grafo.

Node * get_first_node ()

Retorna el primer nodo de un grafo; no hay un orden determinado.

const size_t & get_num_arcs (Node *node) const

Retorna la cantidad total de arcos que tiene un nodo.

const size_t & get_num_arcs () const

Retorna la cantidad total de arcos que tiene el grafo.

size_t get_num_arcs ()

Retorna el número de arcos que tiene el grafo concurrente.

const size_t & get_num_nodes () const

Retorna el número de nodos que tiene el grafo.

size_t get_num_nodes ()

Retorna el número de nodos que tiene el grafo concurrente.

Node * get_src_node (Arc *arc)

Retorna el nodo origen de arc.

Node * get_tgt_node (Arc *arc)

Retorna el nodo destino de arc.

Arc * insert_arc (Node *src_node, Node *tgt_node, const typename Arc::Arc_Type &arc_info)

Crea un nuevo arco entre dos nodos.

Arc * insert_arc (Node *src_node, Node *tgt_node, const Arc_Type &arc_info)

Crea un arco en un grafo concurrente.

Node * insert_node (const Node_Type &node_info)

Crea e inserta un nuevo nodo con información node_info.

Node * insert_node (Node *node)

Inserta un nodo ya creado en un grafo.

bool is_digraph () const

Retorna true si this es un digrafo.

bool node_belong_to_arc (Arc *arc, Node *node) const

Retorna true si el nodo node está conectado por el arco arc.

bool node_belong_to_graph (Node *node)

Retorna true si el nodo apuntado por node está inserto dentro del grafo.

void operate_on_arcs (Node *node, void *ptr)

Actuador sobre todos los arcos de un nodo con parámetro adicional.

void operate_on_arcs (Node *node)

Actuador sobre todos los arcos de un grafo.

template<class Operation>

void operate_on_arcs (void *ptr)

Ejecuta una operación sobre todos los arcos de un grafo concurrente.

template<class Operation>

void operate_on_arcs ()

Ejecuta una operación sobre todos los arcos de un grafo concurrente.

template<class Operation>

void operate_on_nodes (void *ptr)

Ejecuta una operación sobre todos los nodos de un grafo concurrente.

template<class Operation>

void operate_on_nodes ()

Ejecuta una operación sobre todos los nodos de un grafo concurrente.

Concurrent_Graph & operator= (const Concurrent_Graph &g)

Asignación de grafo concurrente.

void remove_arc (Arc *arc)

Elimina un arco en un grafo concurrente.

void remove_node (Node *node)

Elimina un nodo de un grafo (junto con todos sus arcos adyacentes).

void reset_arc (Arc *arc)

Reinicia un arco (bits de control, contador y cookie).

void reset_arcs ()

Reinicia todos los arcos de un grafo (bits de control, contador y cookie).

void reset_bit (Arc *arc, const int &bit)

Reinicia a cero un bit de control de un arco.

void reset_bit (Node *node, const int &bit)

Reinicia a cero un bit de control de un nodo.

void reset_bit_arcs (const int &bit)

Reinicia en cero un bit en todos los arcos de un grafo.

void reset_bit_nodes (const int &bit)

Reinicia en cero un bit en todos los nodos de un grafo.

void reset_cookie_arcs ()

Reinicia todos el cookie a NULL en todos los arcos del grafo.

void reset_cookie_nodes ()

Reinicia todos el cookie a NULL en todos los nodos del grafo.

void reset_counter (Arc *arc)

Reinicia en cero el contador de arco.

void reset_counter (Node *node)

Reinicia en cero el contador de nodo.

void reset_counter_arcs ()

Reinicia en cero todos los contadores de los arcos.

void reset_counter_nodes ()

Reinicia en cero todos los contadores de los nodos.

void reset_node (Node *node)

Reinicia un nodo (bits de control, contador y cookie).

void reset_nodes ()

Reinicia todos los nodos de un grafo (bits de control, contador y cookie).

Arc * search_arc (void *ptr)

Búsqueda de nodo con criterio de igualdad y parámetro adicional.

Arc * search_arc (const Arc_Type &arc_info)

Busca un arco con información arc_info.

Arc * search_arc (Node *src_node, Node *tgt_node)

Busca un arco que conecte a dos nodos.

Node * search_node (void *ptr)

Búsqueda de nodo con criterio de igualdad y parámetro adicional.

Node * search_node (const Node_Type &node_info)

Busca un nodo según su información contenida.

void set_bit (Arc *arc, const int &bit, const int &value)

Escribe un valor de bit sobre un arco.

void set_bit (Node *node, const int &bit, const int &value)

Escribe un valor de bit sobre un nodo.

template<class Compare>

void sort_arcs ()

ordena los arcos de un grafo concurrente según criterio Compare.

Métodos públicos estáticos

static void map_arcs (Arc *p, Arc *q)

Mapea dos arcos mediante sus cookies.

static void map_nodes (Node *p, Node *q)

Mapea dos nodos mediante sus cookies.

Clases

class Arc_Iterator

Iterador sobre los arcos de un grafo concurrente. Más...

class Node_Iterator

Iterador sobre nodos de un grafo concurrente. Más...

Descripción detallada

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

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:

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

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.

Definición en la línea 216 del archivo tpl_concurrent_graph.H.

Documentación de las funciones miembro

void copy_graph	(	List_Graph< Node, Arc > &	src_graph,
		const bool	cookie_map = `false`
	)			`[inherited]`

La rutina primero limpia el grafo this (se eliminan sus nodos arcos y se libera toda la memoria); luego copia enteramente el grafo (o digrafo) g a this. Si el valor lógico cookie_map es cierto, entonces la copia es mapeada; es decir, todos los cookies de los nodos y arcos de ambos grafos quedan mapeados entre sí.

Parámetros:

`[in]`	src_graph	grafo o digrafo a ser copiado.
`[in]`	cookie_map	si el valor es true, entonces la copia es mapeada. Por omisión no se realiza copia mapeada.

Excepciones:

bad_alloc

si no hay suficiente memoria para la copia.

Nota:: La copia no incluye los atributos de control del grafo (bit, contador y cookies)

Referenciado por Concurrent_Graph< __Node, __Arc >::operator=().

Node* get_connected_node	(	Arc *	arc,
		Node *	node
	)			`[inline, inherited]`

Esta es la primitiva a utilizar cuando se accede a un arco de un grafo (no digrafo) y se desea discernir un extremo del arco dado el otro nodo extremo.

Parámetros:

`[in]`	arc	arco del grafo
`[in]`	node	nodo conectado al arco

Devuelve:: el nodo conectado a node a través del arco arc

Nota:: No se verifica que node esté conectado a arc

Bit_Fields& get_control_bits ( Node * node ) [inline, inherited]

Parámetros:

[in] node puntero a nodo al cual se desea leer los bits de control.

Devuelve:: referencia a los bits de control.

void*& get_cookie ( Arc * arc ) [inline, inherited]

Parámetros:

[in] arc puntero al arco al cual se desea obtener el cookie.

Devuelve:: referencia al puntero cookie.

void*& get_cookie ( Node * node ) [inline, inherited]

Parámetros:

[in] node puntero al nodo al cual se desea obtener el cookie.

Devuelve:: referencia al puntero cookie.

long& get_counter ( Arc * arc ) [inline, inherited]

Parámetros:

[in] arc puntero a arco al cual se desea acceder al contador.

Devuelve:: referencia modificable al contador.

long& get_counter ( Node * node ) [inline, inherited]

Parámetros:

[in] node puntero a nodo al cual se desea acceder al contador.

Devuelve:: referencia modificable al contador.

const size_t& get_num_arcs ( Node * node ) const [inline, inherited]

Parámetros:

[in] node nodo sobre el cual se desea conocer el número de arcos.

Devuelve:: la cantidad de arcos.

Node* get_src_node ( Arc * arc ) [inline, inherited]

Parámetros:

[in] arc puntero al arco sobre el cual se desea consultar el nodo origen.

Devuelve:: puntero al nodo origen.

Nota:: Si se trata de un grafo, entonces la noción de nodo origen o destino no tiene sentido bien definido.

Node* get_tgt_node ( Arc * arc ) [inline, inherited]

Parámetros:

[in] arc puntero al arco sobre el cual se desea consultar el nodo destino.

Devuelve:: puntero al nodo destino.

Nota:: Si se trata de un grafo, entonces la noción de nodo origen o destino no tiene sentido bien definido.

Arc* insert_arc	(	Node *	src_node,
		Node *	tgt_node,
		const typename Arc::Arc_Type &	arc_info
	)			`[inline, inherited]`

Este método aparta memoria para un nuevo arco entre los nodos previamente definidos, src_node y tgt_node con valor de contenido en el arco arc_info.

Los nodos deben haber sido previamente insertados en el grafo. A este respecto, no se hace ninguna verificación. El operador de asignación de la clase Arc::Arc_Type debe haber sido definido.

No se realiza ninguna verificación de existencia previa de un arco entre los nodos involucrados (esto es necesario para operar con multigrafos).

Parámetros:

`[in]`	src_node	puntero al nodo origen.
`[in]`	tgt_node	puntero al nodo destino.
`[in]`	arc_info	valor de información a ser copiado en el arco.

Devuelve:: puntero al arco insertado

Excepciones:

bad_alloc

si no hay memoria para el arco.

Referenciado por Concurrent_Graph< __Node, __Arc >::insert_arc().

static void map_arcs	(	Arc *	p,
		Arc *	q
	)			`[static, inherited]`

Dados dos punteros a arcos, por lo general de instancias distintas de grafos, esta función realiza un mapeo mediante los punteros cookies. Luego del mapeo, el cookie de un arco apunta al otro y viceversa.

Si el valor del cookie de p es distintos de NULL, entonces la primitiva asume que p ya está mapeado a otro arco y la primitiva continua el mapeo como una composición.

Por lo general, el mapeo se utiliza por algoritmos que requieren copiar grafos o subgrafos. Mediante el mapeo, se puede tener una imagen del grafo original en el subgrafo y viceversa.

Parámetros:

	p	puntero a arco a ser mapeado.
	q	puntero a arco a ser mapeado.

static void map_nodes	(	Node *	p,
		Node *	q
	)			`[static, inherited]`

Dados dos punteros a nodos, por lo general de instancias distintas de grafos, esta función realiza un mapeo mediante los punteros cookies. Luego del mapeo, el cookie de un nodo apunta al otro y viceversa.

Si el valor del cookie de p es distintos de NULL, entonces la primitiva asume que p ya está mapeado a otro nodo y la primitiva continua el mapeo como una composición.

Por lo general, el mapeo se utiliza por algoritmos que requieren copiar grafos o subgrafos. Mediante el mapeo, se puede tener una imagen del grafo original en el subgrafo y viceversa.

Parámetros:

	p	puntero a nodo a ser mapeado.
	q	puntero a nodo a ser mapeado.

bool node_belong_to_arc	(	Arc *	arc,
		Node *	node
	)			const `[inline, inherited]`

Parámetros:

`[in]`	arc	puntero a arco
`[in]`	node	puntero a nodo

Devuelve:: true si node está conectado por arc; false de lo contrario.

void operate_on_arcs	(	Node *	node,
		void *	ptr
	)			`[inline, inherited]`

Esta rutina recorre cada arco de un nodo de grafo y sobre él ejecuta la operación Operation()(this, arco_actual, ptr).

Este es el actuador de escogencia en caso de que la operación requiera otra información que no pueda obtenerse del grafo o del arco.

Parámetros:

	node	nodo sobre el cual se recorrerán sus arcos.
	ptr	puntero opaco por el cual se puede pasar cualquier otra información a la operación.

Definición en la línea 1594 del archivo tpl_graph.H.

void operate_on_arcs ( Node * node ) [inline, inherited]

Esta rutina recorre cada arco de un nodo y sobre el ejecuta la operación Operation()(this, arco_actual).

Parámetros:

[in] node nodo sobre el cual se recorrerán sus arcos.

Definición en la línea 1575 del archivo tpl_graph.H.

void reset_arc ( Arc * arc ) [inline, inherited]

Parámetros:

[in] arc puntero a arco a ser reiniciado.

void reset_bit	(	Arc *	arc,
		const int &	bit
	)			`[inline, inherited]`

Parámetros:

`[in]`	arc	puntero del nodo cuyo bit se desea reiniciar.
`[in]`	bit	valor del bit a reiniciar.

void reset_bit	(	Node *	node,
		const int &	bit
	)			`[inline, inherited]`

Parámetros:

`[in]`	node	puntero del nodo cuyo bit se desea reiniciar.
`[in]`	bit	valor del bit a reiniciar.

void reset_bit_arcs ( const int & bit ) [inline, inherited]

Parámetros:

[in] bit número de bit a reiniciar.

Definición en la línea 1647 del archivo tpl_graph.H.

void reset_bit_nodes ( const int & bit ) [inline, inherited]

Parámetros:

[in] bit número de bit a reiniciar.

Definición en la línea 1638 del archivo tpl_graph.H.

void reset_counter ( Arc * arc ) [inline, inherited]

Parámetros:

[in] arc puntero a arco al cual se desea acceder al contador.

void reset_counter ( Node * node ) [inline, inherited]

Parámetros:

[in] node puntero a nodo al cual se desea acceder al contador.

void reset_node ( Node * node ) [inline, inherited]

Parámetros:

[in] node puntero a nodo a ser reiniciado.

Arc* search_arc ( void * ptr ) [inline, inherited]

La rutina recorre linealmente todos los arcos del grafo. Por cada nodo revisado, aplica el criterio de igualdad Equal()() con parámetro especial dado mediante el puntero opaco ptr.

Este es el método para buscar arcos cuando lo que contenga el arco no pueda discernirse según el sistema de tipos. Por ejemplo, para buscar algo específico guardado en el cookie.

Parámetros:

[in] ptr puntero opaco a la información usada como criterio de búsqueda.

Nota:: En caso de que se encuentre un arco que cumpla el criterio de igualdad, se retorna el primero encontrado. Si existen arcos con información duplicada, entonces este método no es adecuado.

Devuelve:: puntero al primer arco encontrado; NULL de lo contrario.

Node* search_node ( void * ptr ) [inline, inherited]

La rutina recorre linealmente todos los nodos del grafo. Por cada nodo revisado, la rutina aplica el criterio de igualdad Equal()() para verificar si hay una correspondencia con el valor del parámetro apuntado por ptr.

Este es el método para buscar nodos cuando lo que contenga el nodo no pueda discernirse según el sistema de tipos. Por ejemplo, para buscar algo específico guardado en el cookie.

Parámetros:

[in] ptr puntero opaco a la información usada como criterio. de búsqueda.

Nota:: En caso de que se encuentre un nodo que cumpla el criterio de igualdad, se retorna el primero encontrado. Si existen nodos con información duplicada, entonces este método no es el adecuado.

Devuelve:: puntero al primer nodo encontrado; NULL de lo contrario.

void set_bit	(	Arc *	arc,
		const int &	bit,
		const int &	value
	)			`[inline, inherited]`

Parámetros:

`[in]`	arc	puntero del arco cuyo bit se desea escribir.
`[in]`	bit	valor del bit a escribir.
`[in]`	value	valor a escribir.

void set_bit	(	Node *	node,
		const int &	bit,
		const int &	value
	)			`[inline, inherited]`

Parámetros:

`[in]`	node	puntero del nodo cuyo bit se desea escribir.
`[in]`	bit	valor del bit a escribir.
`[in]`	value	valor a escribir.

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

tpl_concurrent_graph.H


Tipos públicos
typedef Arc	Arc
	Tipo de arco.
typedef Arc::Arc_Type	Arc_Type
	El tipo de arco concurrente.
typedef Node	Node
	Tipo de nodo.
typedef Node::Node_Type	Node_Type
	El tipo de nodo concurrente.
Métodos públicos
bool	arc_belong_to_graph (Arc *arc)
	Retorna true si el arco arc pertenece al grafo.
void	clear_graph ()
	Limpia todo el grafo (todos sus nodos y arcos son eliminados y la memoria es liberada).
	Concurrent_Graph (const Concurrent_Graph &g)
	Instancia un grafo concurrente copia de otro grafo concurrente.
	Concurrent_Graph ()
	Instancia un grafo concurrente vacío.
void	copy_graph (List_Graph &src_graph, const bool cookie_map=false)
	Copia explícita de grafos.
Node *	get_connected_node (Arc arc, Node node)
	Retorna el nodo conectado a `node` mediante el arco `arc`.
Bit_Fields &	get_control_bits (Node *node)
	Retorna los bits de control de un nodo.
void *&	get_cookie (Arc *arc)
	Obtiene el cookie de un arco.
void *&	get_cookie (Node *node)
	Obtiene el cookie de un nodo.
long &	get_counter (Arc *arc)
	Accede a contador de arco.
long &	get_counter (Node *node)
	Accede a contador de nodo.
Arc *	get_first_arc ()
	Retorna el primer arco de un grafo.
Node *	get_first_node ()
	Retorna el primer nodo de un grafo; no hay un orden determinado.
const size_t &	get_num_arcs (Node *node) const
	Retorna la cantidad total de arcos que tiene un nodo.
const size_t &	get_num_arcs () const
	Retorna la cantidad total de arcos que tiene el grafo.
size_t	get_num_arcs ()
	Retorna el número de arcos que tiene el grafo concurrente.
const size_t &	get_num_nodes () const
	Retorna el número de nodos que tiene el grafo.
size_t	get_num_nodes ()
	Retorna el número de nodos que tiene el grafo concurrente.
Node *	get_src_node (Arc *arc)
	Retorna el nodo origen de arc.
Node *	get_tgt_node (Arc *arc)
	Retorna el nodo destino de arc.
Arc *	insert_arc (Node src_node, Node tgt_node, const typename Arc::Arc_Type &arc_info)
	Crea un nuevo arco entre dos nodos.
Arc *	insert_arc (Node src_node, Node tgt_node, const Arc_Type &arc_info)
	Crea un arco en un grafo concurrente.
Node *	insert_node (const Node_Type &node_info)
	Crea e inserta un nuevo nodo con información node_info.
Node *	insert_node (Node *node)
	Inserta un nodo ya creado en un grafo.
bool	is_digraph () const
	Retorna true si `this` es un digrafo.
bool	node_belong_to_arc (Arc arc, Node node) const
	Retorna true si el nodo `node` está conectado por el arco `arc`.
bool	node_belong_to_graph (Node *node)
	Retorna true si el nodo apuntado por node está inserto dentro del grafo.
void	operate_on_arcs (Node node, void ptr)
	Actuador sobre todos los arcos de un nodo con parámetro adicional.
void	operate_on_arcs (Node *node)
	Actuador sobre todos los arcos de un grafo.
template<class Operation>
void	operate_on_arcs (void *ptr)
	Ejecuta una operación sobre todos los arcos de un grafo concurrente.
template<class Operation>
void	operate_on_arcs ()
	Ejecuta una operación sobre todos los arcos de un grafo concurrente.
template<class Operation>
void	operate_on_nodes (void *ptr)
	Ejecuta una operación sobre todos los nodos de un grafo concurrente.
template<class Operation>
void	operate_on_nodes ()
	Ejecuta una operación sobre todos los nodos de un grafo concurrente.
Concurrent_Graph &	operator= (const Concurrent_Graph &g)
	Asignación de grafo concurrente.
void	remove_arc (Arc *arc)
	Elimina un arco en un grafo concurrente.
void	remove_node (Node *node)
	Elimina un nodo de un grafo (junto con todos sus arcos adyacentes).
void	reset_arc (Arc *arc)
	Reinicia un arco (bits de control, contador y cookie).
void	reset_arcs ()
	Reinicia todos los arcos de un grafo (bits de control, contador y cookie).
void	reset_bit (Arc *arc, const int &bit)
	Reinicia a cero un bit de control de un arco.
void	reset_bit (Node *node, const int &bit)
	Reinicia a cero un bit de control de un nodo.
void	reset_bit_arcs (const int &bit)
	Reinicia en cero un bit en todos los arcos de un grafo.
void	reset_bit_nodes (const int &bit)
	Reinicia en cero un bit en todos los nodos de un grafo.
void	reset_cookie_arcs ()
	Reinicia todos el cookie a NULL en todos los arcos del grafo.
void	reset_cookie_nodes ()
	Reinicia todos el cookie a NULL en todos los nodos del grafo.
void	reset_counter (Arc *arc)
	Reinicia en cero el contador de arco.
void	reset_counter (Node *node)
	Reinicia en cero el contador de nodo.
void	reset_counter_arcs ()
	Reinicia en cero todos los contadores de los arcos.
void	reset_counter_nodes ()
	Reinicia en cero todos los contadores de los nodos.
void	reset_node (Node *node)
	Reinicia un nodo (bits de control, contador y cookie).
void	reset_nodes ()
	Reinicia todos los nodos de un grafo (bits de control, contador y cookie).
Arc *	search_arc (void *ptr)
	Búsqueda de nodo con criterio de igualdad y parámetro adicional.
Arc *	search_arc (const Arc_Type &arc_info)
	Busca un arco con información arc_info.
Arc *	search_arc (Node src_node, Node tgt_node)
	Busca un arco que conecte a dos nodos.
Node *	search_node (void *ptr)
	Búsqueda de nodo con criterio de igualdad y parámetro adicional.
Node *	search_node (const Node_Type &node_info)
	Busca un nodo según su información contenida.
void	set_bit (Arc *arc, const int &bit, const int &value)
	Escribe un valor de bit sobre un arco.
void	set_bit (Node *node, const int &bit, const int &value)
	Escribe un valor de bit sobre un nodo.
template<class Compare>
void	sort_arcs ()
	ordena los arcos de un grafo concurrente según criterio Compare.
Métodos públicos estáticos
static void	map_arcs (Arc p, Arc q)
	Mapea dos arcos mediante sus cookies.
static void	map_nodes (Node p, Node q)
	Mapea dos nodos mediante sus cookies.
Clases
class	Arc_Iterator
	Iterador sobre los arcos de un grafo concurrente. Más...
class	Node_Iterator
	Iterador sobre nodos de un grafo concurrente. Más...

Referencia de la plantilla de la Clase Concurrent_Graph [Grafos.]

Tipos públicos

Métodos públicos

Métodos públicos estáticos

Clases

Descripción detallada

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

Documentación de las funciones miembro

Referencia de la plantilla de la Clase Concurrent_Graph
[Grafos.]

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