Referencia de la plantilla de la Clase Hash_Cache
[Tablas hash]

Cache de datos mapeados a una clave. Más...

Lista de todos los miembros.

Métodos públicos

const size_t & capacity () const
 Retorna el tamaño de cache.
void expand (const size_t &plus_size) throw (std::exception, std::range_error, std::bad_alloc)
 Aumenta el tamaño de cache en plus_size entradas. Dispara bad_alloc si no hay suficiente memoria. El nuevo tamaño de la tabla es calculado a ser el mismo radio especificado durante la construcción.
const size_t & get_hash_capacity () const
 Retorna el tamaño de la tabla hash.
const size_t & get_num_busy_slots () const
 Retorna la cantidad de entradas de la tabla hash que tienen elementos. Su relación con el tamaño de la tabla proporciona una idea de la eficiencia de la función hash.
const size_t & get_num_locked () const
 Retorna la cantidad de entradas del cache que están trancadas. La diferencia con el tamaño proporciona su capacidad en entradas que pueden insertarse.
 Hash_Cache (size_t(*hash_fct)(const Key &), const size_t &__hash_size, const size_t &__cache_size) throw (std::exception, std::bad_alloc)
 Instancia un cache.
Cache_Entry * insert (const Key &key, const Data &data)
 Inserta un nuevo par (key,data) en el cache.
void lock_entry (Cache_Entry *cache_entry) throw (std::exception, std::runtime_error, std::domain_error)
 Tranca la entrada cache_entry, la cual debe pertenecer al cache y no debe estar trancada. Dispara excepción runtime_error si la entrada ya está trancada o domain_error si no está en el cache.
void remove (Cache_Entry *cache_entry) throw (std::exception, std::runtime_error, std::domain_error)
 Elimina la entrada cache_entry del cache. Dispara excepción runtime_error si la entrada está trancada o domain_error si no está contenida en el cache.
Cache_Entry * search (const Key &key)
 Busca una clave en el cache.
Cache_Entry * search_next (Cache_Entry *cache_entry)
 Busca la próxima entrada con el mismo valor de clave de cache_entry.
const size_t & size () const
 Retorna en número de datos que están contenidos en el cache.
void unlock_entry (Cache_Entry *cache_entry) throw (std::exception, std::runtime_error)
 Destranca la entrada cache_entry. Dispara excepción runtime_error si la entrada no está trancada.

Clases

class  Cache_Entry
 Entrada de un cache. Más...
class  Iterator
 Iterador sobre los elementos contenidos en un cache. El orden de visita es desde el más recientemente accedido hasta el menos recientemente accedido. Más...

Descripción detallada

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

Hash_Cache<Key,Data> implanta un cache instrumentado mediante una tabla hash que asocia claves de un conjunto dominio Key a datos de un conjunto rango Data.

Los métodos principales de Hash_Cache operan según un tipo denominado Cache_Entry, el cual es la unidad que contiene el par (clave,dato).

Parámetros:
Key tipo de clave de indización.
Data tipo de dato asociado a la clave.
Cmp clase de comparación entre las claves.
Ver también:
Cache_Entry

Definición en la línea 70 del archivo tpl_hash_cache.H.

Documentación del constructor y destructor

Hash_Cache ( size_t(*)(const Key &)  hash_fct,
const size_t &  __hash_size,
const size_t &  __cache_size 
) throw (std::exception, std::bad_alloc) [inline]

Este constructor crea un nuevo cache de capacidad __cache_size e instrumentado mediante una tabla hash de tamaño __hash_size.

Parámetros:
[in] hash_fct puntero a la función hash.
[in] __hash_size tamaño de la tabla hash interna
[in] __cache_size tamaño del cache.
Excepciones:
bad_alloc si no hay suficiente memoria.
Nota:
Puesto que la tabla hash de trasfondo resuelve las colisiones por encadenamiento separado, el tamaño de la tabla puede ser menor que el tamaño del cache. Esto no se valida en absoluto. Si se desea un buen rendimiento, entonces asegúrese de tener una buena función hash y de que el tamaño de la tabla sea al menos un 20% mayor que el de cache.

Definición en la línea 235 del archivo tpl_hash_cache.H.

Documentación de las funciones miembro

void expand ( const size_t &  plus_size  )  throw (std::exception, std::range_error, std::bad_alloc) [inline]

apartar plus_size nuevas entradas

Definición en la línea 421 del archivo tpl_hash_cache.H.

Cache_Entry* insert ( const Key &  key,
const Data &  data 
) [inline]

insert(key,data) inserta en el cache el par (key,data). Si el cache está lleno, entonces el elementos más antiguamente accedido es eliminado y substituido por el par de inserción.

Después de la inserción, el par (key,data) deviene el elemento más recientemente accedido.

Parámetros:
[in] key clave de indización.
[in] data dato asociado a la clave.
Devuelve:
un puntero a un Objeto de tipo [[Cache_Entry]] contentivo del par (key,data) recién insertado.
Excepciones:
underflow_error si el cache está lleno y todas sus entradas trancadas.

Definición en la línea 301 del archivo tpl_hash_cache.H.

Hace referencia a Hash_Cache::Cache_Entry::get_data(), Hash_Cache::Cache_Entry::is_in_hash_table, y Hash_Cache::Cache_Entry::link_inside().

Cache_Entry* search ( const Key &  key  )  [inline]

search(key) busca en el cache una entrada con valor key.

Parámetros:
[in] key clave a buscar.
Devuelve:
un puntero a un Cache_Entry contentivo de la clave con todos los datos asociados si la clave es encontrada. NULL de lo contrario.

Definición en la línea 326 del archivo tpl_hash_cache.H.

Cache_Entry* search_next ( Cache_Entry *  cache_entry  )  [inline]

Esta función se provee para buscar datos distintos que estén insertados en el cache bajo el mismo valor de clave.

Parámetros:
[in] cache_entry una entrada resultante de una búsqueda previa u otra llamada a esta primitiva.
Devuelve:
puntero al próximo Cache_Entry contentivo de la misma clave -si éste existe-, o NULL de lo contrario.

Definición en la línea 350 del archivo tpl_hash_cache.H.

La documentación para esta clase fue generada a partir del siguiente fichero:
Leandro R. León