#include <tpl_dynBinHeap.H>

Diagrama de herencias de Aleph::DynBinHeap< T, Compare >

Diagrama de colaboración para Aleph::DynBinHeap< T, Compare >:

Tipos públicos
typedef DynBinHeap	Set_Type
	El tipo de conjunto sobre el cual se itera.

typedef T	Item_Type
	El tipo de elemento que retorna get_current().

typedef T	Key_Type

Tipos públicos heredados desde Aleph::BinHeap< T, Compare >
typedef BinHeapNode< T >	Node
	El tipo de nodo del heap.

Tipos públicos heredados desde Aleph::GenBinHeap< BinHeapNode, T, Compare >
typedef BinHeapNode< T >	Node

Métodos públicos
	DynBinHeap (Compare &cmp)

	DynBinHeap (Compare &&cmp=Compare())

	DynBinHeap (const DynBinHeap &h)

	DynBinHeap (DynBinHeap &&h)

DynBinHeap &	operator= (const DynBinHeap &h)

DynBinHeap &	operator= (DynBinHeap &&h)

T &	insert (const T &item) throw (std::exception, std::bad_alloc)

T &	insert (T &&item) throw (std::exception, std::bad_alloc)

T &	put (const T &item) throw (std::exception, std::bad_alloc)

T &	put (T &&item) throw (std::exception, std::bad_alloc)

T	getMin () throw (std::exception, std::underflow_error)

T	getMax () throw (std::exception, std::underflow_error)

T	get () throw (std::exception, std::underflow_error)

void	update (T &data)

void	remove (T &data)

void	erase (T &data)
	Sinónimo de remove.

T &	top () const throw (std::exception, std::underflow_error)

void	empty ()
	Vacía todos los elementos del heap dinámico.

	~DynBinHeap ()
	Destructor.

template<class Operation >
bool	traverse (Operation &op)

template<class Operation >
bool	traverse (Operation &&op=Operation())

template<class Operation >
bool	traverse (Operation &op) const

template<class Operation >
bool	traverse (Operation &&op=Operation()) const

	Functional_Methods (T)

Métodos públicos heredados desde Aleph::GenBinHeap< BinHeapNode, T, Compare >
Compare &	key_comp ()

Compare &	get_compare ()

void	swap (GenBinHeap &h)

Node *	getRoot ()

Node *	getRoot () const

void	for_each_in_preorder (Node *p, Op &op)

void	for_each_in_preorder (Node *p, Op &&op())

bool	level_traverse (Node *root, Op &operation)

bool	level_traverse (Node *root, Op &&operation=Op())

bool	level_traverse (Node *root, Op &operation) const

bool	level_traverse (Node *root, Op &&operation=Op()) const

	GenBinHeap (Compare &__cmp)

	GenBinHeap (Compare &&__cmp=Compare())

Node *	insert (Node *p)

Node *	getMin () throw (std::exception, std::underflow_error)

Node *	getMax () throw (std::exception, std::underflow_error)

void	update (Node *p)

Node *	remove (Node *node) throw (std::exception, std::underflow_error)

void	remove_all_and_delete ()

Node *	top () const throw (std::exception, std::underflow_error)

const size_t &	size () const
	Retorna la cardinalidad del heap.

bool	is_empty () const
	Retorna true si el heap está vacío.

bool	verify_heap ()

Otros miembros heredados
Métodos protegidos heredados desde Aleph::GenBinHeap< BinHeapNode, T, Compare >
Node *	advance_left (Node *p)

Node *	advance_right (Node *p)

virtual bool	verify_heap (Node *p)

Descripción detallada

template<class T, class Compare = Aleph::less<T>>
class Aleph::DynBinHeap< T, Compare >

Heap dinámico de elementos de tipo genérico T con criterio de comparación Compare.

DynBinHeap instrumenta un heap dinámico de elementos de tipo T ordenados según criterio de comparación Compare()().

Por dinámico se entiende que el heap puede crecer o disminuir en función de los recursos. Dicho de otro modo, no está supeditado por el uso de un arreglo interno.

Autor: Leandro Rabindranath León (lrleon en ula punto ve)

Documentación de las funciones miembro

template<class T, class Compare = Aleph::less<T>>

T Aleph::DynBinHeap< T, Compare >::get	(		)
throw	(	std::exception,
		std::underflow_error
	)

inline

Elimina el menor elemento de un heap dinámico y retorna una copia.

Devuelve: una copia del elemento eliminado

Excepciones

underflow_error si el heap está vacío.

template<class T, class Compare = Aleph::less<T>>

T Aleph::DynBinHeap< T, Compare >::getMax	(		)
throw	(	std::exception,
		std::underflow_error
	)

inline

Esta es una función miembro sobrecargada que se suministra por conveniencia. Difiere de la anterior función solamente en los argumentos que acepta.

template<class T, class Compare = Aleph::less<T>>

T Aleph::DynBinHeap< T, Compare >::getMin	(		)
throw	(	std::exception,
		std::underflow_error
	)

inline

Elimina el menor elemento de un heap dinámico y retorna una copia.

Devuelve: una copia del elemento eliminado

Excepciones

underflow_error si el heap está vacío.

Referenciado por Aleph::DynBinHeap< Aleph::Sim_Event *, Aleph::Cmp_Sim_Event >::get(), Aleph::DynBinHeap< Aleph::Sim_Event *, Aleph::Cmp_Sim_Event >::getMax() y Aleph::priority_queue< T, Compare >::pop().

Gráfico de llamadas a esta función:

template<class T, class Compare = Aleph::less<T>>

T& Aleph::DynBinHeap< T, Compare >::insert	(	const T &	item	)
throw	(	std::exception,
		std::bad_alloc
	)

inline

Inserta en el heap una copia de item.

Inserta una copia de item en el heap dinámico.

Parámetros

[in] item elemento a insertar en el heap.

Devuelve: una referencia modificable al elemento copiado e insertado en el heap.

Excepciones

bad_alloc si no hay suficiente memoria.

Referenciado por Aleph::priority_queue< T, Compare >::priority_queue(), Aleph::priority_queue< T, Compare >::push() y Aleph::DynBinHeap< Aleph::Sim_Event *, Aleph::Cmp_Sim_Event >::put().

Gráfico de llamadas a esta función:

template<class T, class Compare = Aleph::less<T>>

T& Aleph::DynBinHeap< T, Compare >::put	(	const T &	item	)
throw	(	std::exception,
		std::bad_alloc
	)

inline

Inserta en el heap una copia de item.

Sinónimo de insert();

Parámetros

[in] item elemento a insertar en el heap.

Devuelve: una referencia modificable al elemento copiado e insertado en el heap.

Excepciones

bad_alloc si no hay suficiente memoria.

template<class T, class Compare = Aleph::less<T>>

void Aleph::DynBinHeap< T, Compare >::remove ( T & data )

inline

Elimina un elemento arbitrario del heap.

remove(data) elimina un elemento cualquiera que esté dentro del heap.

data debe pertenecer al heap.

Esta operación es útil cuando de alguna manera, según la aplicación, el elemento data pierda vigencia dentro del heap. Por ejemplo, la cancelación de un evento.

Parámetros

data	el elemento a eliminar.

Nota: Resultados inesperados si data no pertenece al heap.

template<class T, class Compare = Aleph::less<T>>

T& Aleph::DynBinHeap< T, Compare >::top	(		)	const
throw	(	std::exception,
		std::underflow_error
	)

inline

Retorna una referencia modificable al menor elemento dentro del heap dinámico según el orden determinado por el criterio de comparación dado en la declaración.

Referenciado por Aleph::priority_queue< T, Compare >::top().

Gráfico de llamadas a esta función:

template<class T, class Compare = Aleph::less<T>>

void Aleph::DynBinHeap< T, Compare >::update ( T & data )

inline

Actualiza una prioridad en el heap.

update(data) toma una referencia a un elemento del heap, cuya prioridad ha sido presumiblemente modificada, y actualiza su posición en el heap.

Parámetros

[in] data referencia modificable a un elemento dentro del heap.

Nota: La referencia debe ser válida en el sentido de que debe tratarse de una referencia retornada por insert(). No se hacen verificaciones al respecto.

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

tpl_dynBinHeap.H

Tipos públicos

Métodos públicos

Otros miembros heredados

Descripción detallada

template<class T, class Compare = Aleph::less<T>> class Aleph::DynBinHeap< T, Compare >

Documentación de las funciones miembro

template<class T, class Compare = Aleph::less<T>>
class Aleph::DynBinHeap< T, Compare >