Referencia de la plantilla de la Clase Aleph::DynLhashTable< Key, Record, Cmp >

#include <tpl_dynLhash.H>

Diagrama de herencias de Aleph::DynLhashTable< Key, Record, Cmp >

Diagrama de colaboración para Aleph::DynLhashTable< Key, Record, Cmp >:

Tipos públicos
typedef DynLhashTable< Key, Record >::Hash_Fct	Hash_Fct
	El tipo de función hash.
Tipos públicos heredados desde Aleph::LhashTable< Key >
typedef GenLhashTable< Key, LhashBucket< Key > , Aleph::equal_to< Key > >	Base
Tipos públicos heredados desde Aleph::GenLhashTable< Key, LhashBucket< Key >, Aleph::equal_to< Key > >
typedef LhashBucket< Key >	Bucket
typedef size_t(*	Hash_Fct )(const Key &)
typedef Key	Key_Type
typedef Key	Item_Type

Métodos públicos
void	swap (DynLhashTable &table)
	DynLhashTable (Hash_Fct hash_fct, const size_t &len=DefaultPrime) throw (std::exception, std::bad_alloc)
	DynLhashTable (const DynLhashTable &table)
	DynLhashTable (DynLhashTable &&table)
DynLhashTable &	operator= (const DynLhashTable &table)
DynLhashTable &	operator= (DynLhashTable &&table)
Record *	insert (const Key &key, const Record &record) throw (std::exception, std::bad_alloc)
Record *	insert (const Key &key, Record &&record=Record()) throw (std::exception, std::bad_alloc)
Record *	insert (Key &&key, const Record &record) throw (std::exception, std::bad_alloc)
Record *	insert (Key &&key, Record &&record) throw (std::exception, std::bad_alloc)
Record *	search (const Key &key)
void	remove (Record *record)
DLProxy	operator[] (const Key &key) const throw (std::exception, std::invalid_argument)
DLProxy	operator[] (const Key &key) throw (std::exception, std::bad_alloc, std::invalid_argument)
Métodos públicos heredados desde Aleph::GenLhashTable< Key, LhashBucket< Key >, Aleph::equal_to< Key > >
	GenLhashTable (Hash_Fct __hash_fct, size_t table_size=Primes::DefaultPrime, const float &__lower_alpha=hash_default_lower_alpha, const float &__upper_alpha=hash_default_upper_alpha, const bool __remove_all_buckets=true, const bool __with_resize=true) throw (std::exception, std::bad_alloc)
void	swap (GenLhashTable &other)
void	empty ()
	Vacía la tabla hash; libera memoria de todas las cubetas.
Hash_Fct	get_hash_fct () const
void	set_hash_fct (Hash_Fct fct)
	Set the internal hash function.
float	current_alpha () const
	return the current table load
Bucket *	insert (Bucket *bucket)
Bucket *	search (const Key &key) const
Bucket *	remove (Bucket *bucket)
size_t	resize (size_t new_size) throw (std::exception, std::bad_alloc)
virtual	~GenLhashTable ()
Bucket *	search_next (Bucket *bucket) const
const size_t &	capacity () const
	Retorna el tamaño de la tabla.
const size_t &	size () const
	Retorna el número de elementos que contiene la tabla.
const size_t &	get_num_busy_slots () const
	Retorna la cantidad de entradas del arreglo que están ocupadas.
bool	is_empty () const
	HASH_STATS ()

Otros miembros heredados
Atributos protegidos heredados desde Aleph::GenLhashTable< Key, LhashBucket< Key >, Aleph::equal_to< Key > >
Hash_Fct	hash_fct
size_t	len
float	lower_alpha
float	upper_alpha

Descripción detallada

template<typename Key, typename Record, class Cmp = Aleph::equal_to<Key>>
class Aleph::DynLhashTable< Key, Record, Cmp >

Mapeo dinámico clave-rango instrumentado mediante una tabla hash con resolución de colisiones por encadenamiento separado.

El tipo DynLhashTable<Key,Record> instrumenta un mapeo mediante una tabla hash con resolución de colisiones por encadenamiento separado. El tipo exporta observadores para conocer el radio de uso y, eventualmente, reajustar el tamaño de la tabla, de modo que ésta exhiba un mejor desempeño.

Pueden usarse de manera segura punteros a registros dentro de la tabla.

Aparte los métodos tradicionales de inserción y búsqueda, el operador [] funge a la vez como consulta e inserción. La asignación tabla[key]=record se corresponde con una inserción; mientras que cualquier expresión del tipo table[key] que involucre lectura se corresponde con una búsqueda.

Parámetros

Key	el tipo de clave de indización
Record	el tipo de rango asociado a las claves.
Cmp	clase de comparación entre las claves.

Documentación del constructor y destructor

template<typename Key, typename Record, class Cmp = Aleph::equal_to<Key>>

Aleph::DynLhashTable< Key, Record, Cmp >::DynLhashTable ( Hash_Fct  hash_fct, const size_t &  len = DefaultPrime  ) throw ( std::exception, std::bad_alloc )

inline

Instancia un mapeo hash dinámico con función hash hash_fct y tabla de longitud len. Dispara excepción bad_alloc si no hay memoria para apartar la tabla interna.

Documentación de las funciones miembro

template<typename Key, typename Record, class Cmp = Aleph::equal_to<Key>>

Record* Aleph::DynLhashTable< Key, Record, Cmp >::insert ( const Key &  key, const Record &  record  ) throw ( std::exception, std::bad_alloc )

inline

Inserta en el mapeo hash el par (key,record) indizado por la clave key. Retorna un puntero al registro dentro de la tabla. Dispara la excepción bad_alloc si no hay suficiente memoria.

template<typename Key, typename Record, class Cmp = Aleph::equal_to<Key>>

void Aleph::DynLhashTable< Key, Record, Cmp >::remove ( Record *  record )

inline

Elimina de la tabla el registro record (que debe haber sido obtenido mediante la inserción o búsqueda.

Hace referencia a Aleph::GenLhashTable< Key, LhashBucket< Key >, Cmp >::remove().

Gráfico de llamadas para esta función:

template<typename Key, typename Record, class Cmp = Aleph::equal_to<Key>>

Record* Aleph::DynLhashTable< Key, Record, Cmp >::search ( const Key &  key )

inline

Busca la clave key y, si se encuentra, entonces retorna un puntero dentro de la tabla al registro asociado. De lo contrario -no se encuentra la clave-, se retorna NULL:

---

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

• tpl_dynLhash.H