Aleph::DynArray

Referencia de la plantilla de la Clase DynArray
[Secuencias.]

Arreglo dinámico perezoso. Más...

Diagrama de herencias de DynArray

Inheritance graph
[leyenda]

Lista de todos los miembros.

Métodos públicos

const T & access (const size_t &i) const
 Acceso rápido sin validación a arreglo constante.
T & access (const size_t &i)
 Acceso rápido sin validación.
void copy_array (const DynArray< T > &src_array)
 Copia de elemento a elemento.
void cut (const size_t &new_dim=0) throw (std::exception, std::domain_error)
 Corta un arreglo; reduce su dimensión.
 DynArray (const DynArray< T > &array) throw (std::exception, std::bad_alloc)
 Constructor copia.
 DynArray (const size_t &dim=10000) throw (std::exception, std::bad_alloc, std::length_error, std::overflow_error)
 Constructor por omisión.
 DynArray (const size_t &_pow_dir, const size_t &_pow_seg, const size_t &_pow_block) throw (std::exception, std::bad_alloc, std::length_error, std::overflow_error)
 Constructor especializado.
bool exist (const size_t &i) const throw (std::exception, std::out_of_range)
 Retorna true si existe la entrada i.
const size_t & get_block_size () const
 Retorna tamaño del bloque.
const size_t & get_dir_size () const
 Retorna tamaño del directorio.
const size_t & get_num_blocks () const
 Retorna la cantidad de bloques actualmente apartados.
const size_t & get_seg_size () const
 Retorna tamaño del segmento.
const size_t & max_size () const
 Retorna máxima dimensión permitida.
DynArray< T > & operator= (const DynArray< T > &array) throw (std::exception, std::bad_alloc)
 Asignación.
void reserve (const size_t &l, const size_t &r) throw (std::exception, std::bad_alloc, std::domain_error, std::length_error)
 Reserva un rango de memoria.
void set_default_initial_value (const T &value)
 Configura el valpor por omisión que debe tener una nueva entrada.
const size_t & size () const
 Retorna dimensión actual (más lejano índice escrito).
void swap (DynArray< T > &array)
 Intercambio rapidísimo entre arreglos.
T & touch (const size_t &i) throw (std::exception, std::bad_alloc, std::out_of_range)
 Toca que la i-ésima entrada de manera de asegurar que haya memoria.
 ~DynArray ()
 Destructor que libera toda la memoria ocupada.

Descripción detallada

template<typename T>
class Aleph::DynArray< T >

Esta clase implementa arreglo dinámicos perezosos. Por dinámico se entiende que la memoria es automáticamente apartada en función de la dimensión. Por perezoso se entiende que la memoria puede apartarse en tiempo de escritura.

Parámetros:
T El tipo de dato del arreglo.
Un arreglo dinámico maneja tres valores muy importantes que determinan su dinamismo. Estos valores son llamados:

Para lograr un acceso constante lo más eficiente posible, estos tamaños son potencias exactas de dos.

Un arreglo dinámico recién inicializado sólo ocupa un arreglo continuo correspondiente al directorio.

La máxima dimensión del arreglo dinámico está limitada por dir_size x seg_size x block_size elementos.

El arreglo dinámico maneja una dimensión actual, la cual se especifica en tiempo de construcción y que se expande automáticamente si se escriben entradas por encima de la dimensión actual.

Los elementos pueden accederse de diversas formas. Siendo la principal mediante el tradicional operador [], la cual realiza todas las verificaciones de rango, aparta automáticamente la memoria y puede expandir la dimensión.

Puesto que la unidad de apartado de memoria es el bloque, no hay garantía de que una entrada leída se corresponda con una ya escrita.

Definición en la línea 113 del archivo tpl_dynArray.H.

Documentación del constructor y destructor

DynArray ( const size_t &  _pow_dir,
const size_t &  _pow_seg,
const size_t &  _pow_block 
) throw (std::exception, std::bad_alloc, std::length_error, std::overflow_error) [inline]

Define un arreglo dinámico con tamaños de directorio, segmento y bloque.

Parámetros:
[in] _pow_dir Potencia de dos tamaño del directorio.
[in] _pow_seg Potencia de dos tamaño del segmento.
[in] _pow_block Potencia de dos tamaño del bloque.
Excepciones:
bad_alloc si no hay memoria para apartar el directorio. Esto puede ocurrir porque es demasiado grande o porque hay muy poca memoria disponible.
length_error Si los tamaños seleccionados exceden la máxima dimensión posible
overflow_error Si ocurre overflow de con las operaciones de bits.

Definición en la línea 525 del archivo tpl_dynArray.H.

DynArray ( const size_t &  dim = 10000  )  throw (std::exception, std::bad_alloc, std::length_error, std::overflow_error) [inline]

Este es el constructor por omisión en el cual se especifica una dimensión. Los tamaños de directorio, segmento y bloque son seleccionados automáticamente.

Parámetros:
[in] dim dimensión inicial del arreglo (puede expandirse automáticamente si se escribe más allá de ella)
Excepciones:
bad_alloc si no hay memoria para apartar el directorio. Esto puede ocurrir porque es demasiado grande o porque hay muy poca memoria disponible.
length_error Si los tamaños seleccionados exceden la máxima dimensión posible
overflow_error Si ocurre overflow de con las operaciones de bits.

Definición en la línea 572 del archivo tpl_dynArray.H.

DynArray ( const DynArray< T > &  array  )  throw (std::exception, std::bad_alloc) [inline]

Copia elemento a elemento el arreglo array a this. Los tamaños de directorio, segmento y bloque de this serán los mismo que los de array.

Parámetros:
[in] array arreglo fuente de la copia.
Excepciones:
bad_alloc si no hay suficiente memoria.

Definición en la línea 636 del archivo tpl_dynArray.H.

Documentación de las funciones miembro

const T& access ( const size_t &  i  )  const [inline]

Esta rutina accede al i-ésimo elemento del arreglo de la manera más rápida posible en detrimento de verificar si la entrada existe, bien sea porque no ha sido escrita o porque está fuera de rango.

El fin de esta función es realizar un acceso a la velocidad máxima bajo la certitud de utilización.

Parámetros:
[in] i índice de la entrada de acceso.
Nota:
Úsese con extremo cuidado. Si la entrada no tiene un bloque apartado, entonces, en el mejor de los casos, habrá una falla de memoria con su correspondiente excepción del sistema operativo. De lo contrario, entonces el acceso será realizado pero ello no implica que sea correcto.
Ver también:
exist

Definición en la línea 755 del archivo tpl_dynArray.H.

T& access ( const size_t &  i  )  [inline]

Esta rutina accede al i-ésimo elemento del arreglo de la manera más rápida posible en detrimento de verificar si la entrada existe, bien sea porque no ha sido escrita o porque está fuera de rango.

El fin de esta función es realizar un acceso a la velocidad máxima bajo la certitud de utilización.

Parámetros:
[in] i índice de la entrada de acceso.
Nota:
Úsese con extremo cuidado. Si la entrada no tiene un bloque apartado, entonces, en el mejor de los casos, habrá una falla de memoria con su correspondiente excepción del sistema operativo. De lo contrario, entonces el acceso será realizado pero ello no implica que sea correcto.
Ver también:
exist

Definición en la línea 727 del archivo tpl_dynArray.H.

Referenciado por Aleph::binary_search(), Aleph::bubble_sort(), DynArray< BucketList >::copy_array(), Aleph::heapsort(), Aleph::insertion_sort(), Matrix_Graph::operator()(), Aleph::search_extreme(), Aleph::selection_sort(), Aleph::sequential_search(), y Aleph::shellsort().

void copy_array ( const DynArray< T > &  src_array  )  [inline]

Copia todos los elementos de src_array a this. La copia se realiza elemento por elemento de entre los escritos en src_array.

Nota:
Los tamaños de directorio, segmento y bloque son independientes.
Parámetros:
[in] src_array arreglo fuente de la copia

Definición en la línea 621 del archivo tpl_dynArray.H.

Referenciado por DynArray< BucketList >::DynArray(), y DynArray< BucketList >::operator=().

void cut ( const size_t &  new_dim = 0  )  throw (std::exception, std::domain_error) [inline]

cut(dim) reduce la dimensión del arreglo al valor de dim. Para que el método tenga sentido, dim debe ser menor que la dimensión actual. Después de la operación, la memoria ocupada por los bloques superiores a la nueva dimensión han sido liberados.

En general, cut() se utiliza para liberar memoria.

Parámetros:
new_dim valor de la nueva dimensión. Por omisión, este valor es cero, en cuyo caso se liberan todos los bloques.
Excepciones:
domain_error si la new_dim es mayor que la dimensión actual.

Definición en la línea 947 del archivo tpl_dynArray.H.

Referenciado por Map_Matrix_Graph::copy_list_graph(), GenLinearHashTable< Key, LhashBucket, Aleph::equal_to< Key > >::empty(), y DynArray< BucketList >::operator=().

bool exist ( const size_t &  i  )  const throw (std::exception, std::out_of_range) [inline]

El método verifica si la entrada i está presente en memoria; es decir, si puede leerse con seguridad de que existe un bloque apartado para la entrada.

El que el método retorne true no necesariamente implica que la entrada fue previamente escrita (podría tratarse de una entrada no escrita pero aledaña a una escrita que comparte el mismo bloque.

Parámetros:
[in] i índice de la entrada que se desea verificar.
Excepciones:
out_of_range si i excede la máxima dimensión.

Definición en la línea 777 del archivo tpl_dynArray.H.

Referenciado por DynArray< BucketList >::copy_array(), y Aleph::sequential_search().

DynArray<T>& operator= ( const DynArray< T > &  array  )  throw (std::exception, std::bad_alloc) [inline]

Asigna a this todos los elementos existentes de array.

Parámetros:
[in] array arreglo fuente de la copia.
Excepciones:
bad_alloc si no hay suficiente memoria.

Definición en la línea 665 del archivo tpl_dynArray.H.

void reserve ( const size_t &  l,
const size_t &  r 
) throw (std::exception, std::bad_alloc, std::domain_error, std::length_error) [inline]

reerve(l, r) verifica el rango de entradas del arreglo comprendido entre l y r y asegura que haya memoria.

Parámetros:
[in] l índice inferior
[in] r índice superior
Excepciones:
std::bad_alloc si no hay suficiente memoria. En ese caso, no hay manera precisa de saber hasta donde ha sido apartada la memoria. Si l es mayor que la antigua dimensión, entonces el valor de la dimensión actual estará modificado hasta el último bloque apartado.
domain_error si l es mayor que r
length_error si r es mayor que la máxima dimensión.

Definición en la línea 881 del archivo tpl_dynArray.H.

void set_default_initial_value ( const T &  value  )  [inline]

Normalmente, cuando se aparta un nuevo bloque, el valor inicial de sus elementos está dado por el valor asignado por el constructor por omisión T::T(). Esta primitiva coloca el valor a colocar en cada elemento de un nuevo bloque al valor value.

Parámetros:
[in] value el valor por omisión que deben tomar las entradas del bloque.

Definición en la línea 501 del archivo tpl_dynArray.H.

void swap ( DynArray< T > &  array  )  [inline]

swap intercambia todos los elementos del arreglo array con los del arreglo this en un muy rápido tiempo constante.

Parámetros:
[in] array arreglo a intercambiar con this
Nota:
Los tamaños de directorio, segmento y bloque también son intercambiados.

Definición en la línea 690 del archivo tpl_dynArray.H.

T& touch ( const size_t &  i  )  throw (std::exception, std::bad_alloc, std::out_of_range) [inline]

touch(i) verifica si el bloque albergante de la entrada i ha sido apartado y, en caso de no existir bloque, aparta la correspondiente memoria.

Parámetros:
[in] i índice de la entrada a tocar.
Excepciones:
bad_alloc si no hay memoria para apartar el bloque
out_of_range si i es mayor que la máxima dimensión
Ver también:
cut

Definición en la línea 829 del archivo tpl_dynArray.H.

Referenciado por GenLinearHashTable< Key, LhashBucket, Aleph::equal_to< Key > >::insert().

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