#include <tpl_dynarray_set.H>

Diagrama de herencias de DynArray_Set< T, Equal >

Diagrama de colaboración para DynArray_Set< T, Equal >:

Clases
class	Iterator

Métodos públicos
	DynArray_Set (const size_t &dim=0)
	Constructor por omisión.

	DynArray_Set (size_t pow_dir, size_t pow_seg, size_t pow_block)

T &	put (const T &item)
	Inserción de item.

T *	search (const T &item)

void	remove (T &item)

void	erase (T &item)

Métodos públicos heredados desde Aleph::DynArray< T >
size_t	get_dir_size () const
	Retorna tamaño del directorio.

size_t	get_seg_size () const
	Retorna tamaño del segmento.

size_t	get_block_size () const
	Retorna tamaño del bloque.

size_t	size () const
	Retorna dimensión actual (más lejano índice escrito)

size_t	max_size () const
	Retorna máxima dimensión permitida.

size_t	get_num_blocks () const
	Retorna la cantidad de bloques actualmente apartados.

void	set_default_initial_value (const T &value)

void	set_default_initial_value (T &&value=T())

	DynArray (size_t _pow_dir, size_t _pow_seg, size_t _pow_block) throw (std::exception, std::bad_alloc, std::length_error, std::overflow_error)

	DynArray (const size_t dim=0) throw (std::exception, std::bad_alloc, std::length_error, std::overflow_error)

	DynArray (const DynList< T > &list)

	~DynArray ()
	Destructor que libera toda la memoria ocupada.

void	copy_array (const DynArray< T > &src_array)

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

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

void	swap (DynArray< T > &array)

	DynArray (DynArray &&other)

DynArray &	operator= (DynArray &&other)

T &	access (const size_t i)

T &	operator() (const size_t i)

const T &	access (const size_t i) const

const T &	operator() (const size_t i) const

bool	exist (const size_t i) const throw (std::exception, std::out_of_range)

T *	test (const size_t i) const

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

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

void	reserve (const size_t dim)

void	cut (const size_t new_dim=0) throw (std::exception, std::domain_error)

void	empty ()

Proxy	operator[] (const size_t i) const throw (std::exception, std::bad_alloc, std::length_error, std::invalid_argument)

Proxy	operator[] (const size_t i) throw (std::exception, std::length_error, std::invalid_argument, std::bad_alloc)

T &	append ()

T &	append (const T &data)

T &	append (T &&data)

void	push (const T &data)
	Inserta como en una pila un elemento al final del arreglo.

T &	push ()
	Aparta un elemento al final del arrreglo.

bool	is_empty ()

T	pop ()
	Elimina el último elemento del arreglo como si fuese una pila.

T &	top ()
	Retorna el último elemento del arreglo como si fuese una pila.

T &	get_first ()
	Retorna el último elemento del arreglo como si fuese una cola.

T &	get_last ()
	Retorna el primer elemento del arreglo como si fuese una cola.

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

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

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

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

	Functional_Methods (T)

Otros miembros heredados
Tipos públicos heredados desde Aleph::DynArray< T >
typedef T	Item_Type

typedef T	Key_Type

Métodos públicos estáticos heredados desde Aleph::DynArray< T >
static void	compute_sizes (const size_t n, size_t &d, size_t &s, size_t &b)

Atributos públicos estáticos heredados desde Aleph::DynArray< T >
static const size_t	Default_Pow_Dir = 6

static const size_t	Default_Pow_Seg = 8

static const size_t	Default_Pow_Block = 12

static const size_t	Max_Bits_Allowed = 8 * sizeof(size_t)

static const unsigned long long	Max_Dim_Allowed

Descripción detallada

template<typename T, class Equal = Aleph::equal_to<T>>
class DynArray_Set< T, Equal >

Conjunto de elementos implantado mediante un arreglo dinámico.

DynArray_Set instrumenta un conjunto de elementos de tipo T.

El conjunto está internamente representado mediante un arreglo dinámico del tipo DynArray. Consecuentemente, el consumo en memoria es proporcional al número de elementos.

La inserción es sumamente rápida, la búsqueda es lineal y la eliminación de un elementpo ya encontrado también es muy rápida.

La clase recibe dos parámetros tipo: el tipo de elemento del conjunto y una clase de comparación cuyo único rol es determinar si un elemento es igual a no a otro.

Por razones de rapidez, se permite duplicar elementos.

Ver también: DynArray

Documentación del constructor y destructor

template<typename T , class Equal = Aleph::equal_to<T>>

DynArray_Set< T, Equal >::DynArray_Set	(	size_t	pow_dir,
		size_t	pow_seg,
		size_t	pow_block
	)

inline

Constructor especializado.

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.

Documentación de las funciones miembro

template<typename T , class Equal = Aleph::equal_to<T>>

void DynArray_Set< T, Equal >::erase ( T & item )

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<typename T , class Equal = Aleph::equal_to<T>>

void DynArray_Set< T, Equal >::remove ( T & item )

inline

Elimina el elemento del conjunto item, el cual debe haberse encontrado previamente mediante search o ser resultado de insert.

Hace referencia a Aleph::DynArray< T >::access(), Aleph::DynArray< T >::cut() y Aleph::DynArray< T >::size().

Gráfico de llamadas para esta función:

template<typename T , class Equal = Aleph::equal_to<T>>

T* DynArray_Set< T, Equal >::search ( const T & item )

inline

Busca item en el conjunto. Retorna puntero si lo encuentra; NULL de lo contrario.

Hace referencia a Aleph::DynArray< T >::access() y Aleph::DynArray< T >::size().

Gráfico de llamadas para esta función:

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

tpl_dynarray_set.H

Clases

Métodos públicos

Otros miembros heredados

Descripción detallada

template<typename T, class Equal = Aleph::equal_to<T>> class DynArray_Set< T, Equal >

Documentación del constructor y destructor

Documentación de las funciones miembro

template<typename T, class Equal = Aleph::equal_to<T>>
class DynArray_Set< T, Equal >