#include <tpl_arrayQueue.H>

Diagrama de herencias de Aleph::ArrayQueue< T >

Diagrama de colaboración para Aleph::ArrayQueue< T >:

Métodos públicos
void	swap (ArrayQueue &q)

	ArrayQueue (const size_t sz=8)

	ArrayQueue (const ArrayQueue &q)

	ArrayQueue (ArrayQueue &&q)

ArrayQueue &	operator= (const ArrayQueue &q)

ArrayQueue &	operator= (ArrayQueue &&q)

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

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

T &	putn (size_t sz) throw (std::exception, std::bad_alloc)

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

T &	getn (const size_t i) throw (std::exception, std::underflow_error)

T &	front (const size_t i=0) throw (std::exception, std::range_error)

const T &	front (const size_t i=0) const throw (std::exception, std::range_error)

T &	rear (const size_t i=0) throw (std::exception, std::range_error)

const T &	rear (const size_t i=0) const throw (std::exception, std::range_error)

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

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

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

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

	Functional_Methods (T)

	Generic_Items (T)

Métodos públicos heredados desde Aleph::MemArray< T >
const size_t &	capacity () const
	Retorna la capacidad del arreglo.

const size_t &	size () const

bool	is_empty () const

	MemArray (size_t __dim=8)

void	swap (MemArray &a)

	MemArray (const MemArray &a)

	MemArray (MemArray &&a)

MemArray &	operator= (const MemArray &a)

MemArray &	operator= (MemArray &&a)

void	empty ()

T &	put (const T &item)
	Coloca item al final de arreglo. Se expande si se alcanza el final.

T &	put (T &&item)

T &	put (const size_t i, const T &item)

T &	put (const size_t i, T &&item)

void	putn (const size_t more)
	inserta entradas para el arreglo.

T	get (int i=1)
	elimina i entradas. Retorna la última entrada eliminada

T &	last ()

T &	first ()

T &	access (const size_t i)

const T &	last () const

const T &	first () const

const T &	access (const size_t i) const

T &	operator[] (const size_t i)
	acceso a la i-ésima entrada válida

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

T &	operator() (const size_t i)

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

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

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

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

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

	Functional_Methods (T)

Otros miembros heredados
Métodos protegidos heredados desde Aleph::MemArray< T >
void	allocate ()

bool	expand (const size_t first=0)

bool	contract (const size_t first=0)

Métodos protegidos estáticos heredados desde Aleph::MemArray< T >
static size_t	init_dim (const size_t dim)

Atributos protegidos heredados desde Aleph::MemArray< T >
T *	ptr

size_t	dim

size_t	n

size_t	contract_threshold

Descripción detallada

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

Pila implantada con arreglos estáticos y verificación de número de elementos.

ArrayQueue<T> instrumenta una cola de elementos de tipo T con una capacidad máxima de dim elementos especificada en tiempo de construcción. Para este tipo, todas las operaciones efectúan verificación acerca del número de elementos y excepciones son disparadas si la cola se excede, o se intenta consultar o eliminar de una cola vacía.

Una cola instrumentada mediante un arreglo es mucho más rápida que una instrumentada con listas enlazadas.

El arreglo interno se aparta en memoria.

Parámetros

T	tipo de elemento que alberga la cola. equivalente a la dimensión del arreglo.
dim	la dimensión de arreglo interno.

Ver también: FixedQueue DynListQueue

Nota: Si se tiene la certitud de la correctitud, entonces úsese el tipo FixedQueue, que es más rápido.

Documentación del constructor y destructor

template<typename T>

Aleph::ArrayQueue< T >::ArrayQueue ( const size_t sz = 8 )

inline

Constructor que especifica capacidad máxima.

Construye una cola con capacidad máxima de $2^{tp}$ elementos.

Parámetros

[in] tp potencia de dos de la capacidad deseada; la capacidad será de $2^{tp}$ elementos.

Excepciones

bad_alloc si no hay suficiente memoria.

Documentación de las funciones miembro

template<typename T>

T& Aleph::ArrayQueue< T >::front	(	const size_t	i = `0`	)
throw	(	std::exception,
		std::range_error
	)

inline

Accede al i-ésimo elemento desde el frente de la cola.

front(i) accede a la i-ésima posición desde el frente de la cola. Esto es equivalente a conocer el i-ésimo elemento más antiguo.

Parámetros

[in] i posición de acceso.

Devuelve: una referencia modificable al i-ésimo elemento desde el frente de la cola.

Excepciones

range_error si i está fuera de rango.

template<typename T>

T Aleph::ArrayQueue< T >::get	(		)
throw	(	std::exception,
		std::underflow_error,
		std::bad_alloc
	)

inline

Elimina el elemento del frente de la cola y retorna una copia.

get() sobre la cola elimina el elemento del frente y retorna una copia del elemento recién eliminado.

Devuelve: una copia del elemento recién eliminado.

Excepciones

underflow_error si i está fuera de rango.

Referenciado por Aleph::levelOrder().

Gráfico de llamadas a esta función:

template<typename T>

T& Aleph::ArrayQueue< T >::getn	(	const size_t	i	)
throw	(	std::exception,
		std::underflow_error
	)

inline

Elimina i elementos de la cola y retorna el elemento situado en el frente.

getn(n) saca i elementos de la cola en tiempo constante.

Parámetros

[in] i número de elementos a sacar.

Devuelve: una referencia modificable al elemento situado en el frente.

Excepciones

underflow_error si i está fuera de rango.

template<typename T>

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

inline

Inserta un elemento en la cola.

put(item) inserta una copia de item en la cola.

Parámetros

[in] item el elemento a insertar.

Devuelve: una referencia modificable al elemento recién insertado.

Excepciones

overflow_error si la cola está llena.

Referenciado por Aleph::levelOrder().

Gráfico de llamadas a esta función:

template<typename T>

T& Aleph::ArrayQueue< T >::putn	(	size_t	sz	)
throw	(	std::exception,
		std::bad_alloc
	)

inline

Aparta n espacios de inserción en la cola.

putn(n) aparta n espacios de inserción en la cola. Esto es equivalente a que se hubiesen realizado n inserciones consecutivas, con la bondad de que la operación toma tiempo constante.

Los valores de los espacios insertados son indeterminados. Pueden accederse mediante las operaciones front() y rear().

Parámetros

[in] n cantidad de espacios insertar.

Devuelve: referencia modificable al último espacio en el trasero de la cola.

Excepciones

overflow_error si la cantidad total de elementos luego de insertar los n espacios excede la capacidad.

template<typename T>

T& Aleph::ArrayQueue< T >::rear	(	const size_t	i = `0`	)
throw	(	std::exception,
		std::range_error
	)

inline

Accede al i-ésimo elemento desde el trasero de la cola.

rear(i) accede a la i-ésima posición desde el trasero de la cola. Esto es equivalente a conocer el i-ésimo elemento más joven.

Parámetros

[in] i posición de acceso.

Devuelve: una referencia modificable al i-ésimo elemento desde el trasero de la cola.

Excepciones

range_error si i está fuera de rango.

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

tpl_arrayQueue.H

Métodos públicos

Otros miembros heredados

Descripción detallada

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

Documentación del constructor y destructor

Documentación de las funciones miembro

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