#include <bitArray.H>

Métodos públicos
	BitArray (const size_t dim=0) throw (std::exception, std::bad_alloc)

void	reserve (size_t dim)

size_t	size () const
	Retorna la dimensión del arreglo de bits.

void	set_size (const size_t sz)
	Reajusta la dimensión del arreglo.

BitProxy	operator[] (const size_t i) const

BitProxy	operator[] (const size_t i)

int	read_bit (const size_t i) const

void	write_bit (const size_t i, const unsigned int value)

int	read (const size_t i) const

void	write (const size_t i, const unsigned int value)

void	push (const unsigned int value)
	Inserta al final del arreglo el valor value.

void	pop ()
	Elimina el último bit del arreglo.

void	empty ()
	Elimina todos los bits insertados.

	BitArray (const BitArray &array) throw (std::exception, std::bad_alloc)

void	swap (BitArray &array)

	BitArray (BitArray &&array)

BitArray &	operator= (BitArray &&array)

DynList< char >	bits_list ()
	Lo convierte a una lista.

BitArray &	operator= (const BitArray &array) throw (std::exception, std::bad_alloc)

void	save (ofstream &output)

void	load (ifstream &input)

	BitArray (ifstream &input)

void	save_in_array_of_chars (const string &name, ofstream &output)

void	load_from_array_of_chars (const unsigned char str[], const size_t num_bits)

void	left_shift (const size_t n=1)

void	right_shift (const size_t n=1)

void	dyn_left_shift (const size_t n=1)

void	dyn_right_shift (const size_t n=1)

void	circular_left_shift (const size_t n=1)

void	circular_right_shift (const size_t n=1)

template<typename T >
void	set_num (T n)

void	set_num (const char &c)

void	set_num (const short &c)

void	set_num (const int &c)

void	set_num (const long &c)

long	get_num ()

void	set_bit_str (const std::string &str)

std::string	get_bit_str () const

	BitArray (const unsigned char str[], const size_t num_bits)

Amigas
ostream &	operator<< (ostream &out, const BitArray &array)

Descripción detallada

Arreglo contiguo de bits.

BitArray define una arreglo contiguo de bits. El consumo de memoria es proporcional a la n/8; donde n es la cantidad de bits que se desean manejar.

El arreglo es dinámico, lo que implica que éste puede expandirse dinámicamente según la necesidad.

El acceso al i-ésimo bit puede realizarse mediante el operador []. Sin embargo, puesto que esta clase de acceso está implementada mediante una clase proxy, el acceso puede fallar en algunas expresiones donde el compilador no logre efectuar las transformaciones de tipos adecuadas.

Autor: Alejandro Mujica; Leandro Rabindranath Leon

Documentación del constructor y destructor

Aleph::BitArray::BitArray	(	const size_t	dim = `0`	)
throw	(	std::exception,
		std::bad_alloc
	)

inline

Constructor de arreglo de dim bits.

Parámetros

[in] dim cantidad de bits. Por omisión es 256.

Excepciones

bad_alloc si no hay suficiente memoria para un bloque continuo de dim/8 bytes

Hace referencia a Aleph::DynArray< T >::set_default_initial_value().

Gráfico de llamadas para esta función:

Aleph::BitArray::BitArray	(	const BitArray &	array	)
throw	(	std::exception,
		std::bad_alloc
	)

inline

Constructor copia.

Instancia un arreglo de bits copia exacta de array.

Parámetros

[in] array el arreglo de bits a ser copiado.

Excepciones

bad_alloc si no hay suficiente memoria para un bloque continuo de dim/8 bytes

Aleph::BitArray::BitArray ( ifstream & input )

inline

Construye un nuevo arreglo de bits a partir de un archivo construido mediante el método save().

Hace referencia a load().

Gráfico de llamadas para esta función:

Aleph::BitArray::BitArray	(	const unsigned char	str[],
		const size_t	num_bits
	)

inline

Construye un nuevo arreglo de bits a partir de un arreglo de caracteres previamente generado con load_from_array_of_chars

Hace referencia a load_from_array_of_chars().

Gráfico de llamadas para esta función:

Documentación de las funciones miembro

void Aleph::BitArray::circular_left_shift ( const size_t n = 1 )

inline

Desplaza los bits n posiciones a la izquierda circularmente.

Los bits son desplazados sin perderse ninguno, los n primeros bits pasan a ocupar las últimas n posiciones del arreglo.

Parámetros

[in] n la cantidad de posiciones que se van a desplazar los bits.

Hace referencia a read_bit() y write_bit().

Gráfico de llamadas para esta función:

void Aleph::BitArray::circular_right_shift ( const size_t n = 1 )

inline

Desplaza los bits n posiciones a la derecha circularmente.

Los bits son desplazados sin perderse ninguno, los últimos n bits pasan a ocupar las primeras n posiciones del arreglo.

Parámetros

[in] n la cantidad de posiciones que se van a desplazar los bits.

Hace referencia a read_bit() y write_bit().

Gráfico de llamadas para esta función:

void Aleph::BitArray::dyn_left_shift ( const size_t n = 1 )

inline

Desplaza los bits n posiciones a la izquierda dinámicamente.

Los bits son desplazados sin perderse ninguno y el arreglo crece agregando n ceros a la derecha.

Parámetros

[in] n la cantidad de posiciones que se van a desplazar los bits.

Hace referencia a push().

Gráfico de llamadas para esta función:

void Aleph::BitArray::dyn_right_shift ( const size_t n = 1 )

inline

Desplaza los bits n posiciones a la derecha dinámicamente.

Los bits son desplazados sin perderse ninguno y el arreglo decrece eliminando los n ceros que quedarían a la izquierda

Parámetros

[in] n la cantidad de posiciones que se van a desplazar los bits.

Hace referencia a read_bit(), Aleph::DynArray< T >::set_default_initial_value(), set_size() y write_bit().

Gráfico de llamadas para esta función:

void Aleph::BitArray::left_shift ( const size_t n = 1 )

inline

Desplaza los bits n posiciones a la izquierda.

Los bits son desplazados y se considera al arreglo de tamaño fijo, es decir, los n primeros bits se pierden.

Parámetros

[in] n la cantidad de posiciones que se van a desplazar los bits.

Hace referencia a read_bit() y write_bit().

Gráfico de llamadas para esta función:

void Aleph::BitArray::load ( ifstream & input )

inline

Carga desde un archivo un arreglo de bits.

load(input) toma el archivo abierto en input, previamente guardado con el método load(), y restaura el arreglo al valro guardado.

Parámetros

[in] input stream de entrada donde se encuentra fguarado el arreglo y que debe haber sido previamente guardado con save().

Hace referencia a Aleph::DynArray< T >::cut() y Aleph::DynArray< T >::touch().

Referenciado por BitArray() y Aleph::load_tree().

Gráfico de llamadas para esta función:

Gráfico de llamadas a esta función:

void Aleph::BitArray::load_from_array_of_chars	(	const unsigned char	str[],
		const size_t	num_bits
	)

inline

Lee un arreglo de bits guardado en un arreglo de caracteres.

load_from_array_of_chars(str, num_bits) toma un arreglo str, previamente generado con save_in_array_of_chars, de num_bits de largo, y lo carga.

Parámetros

[in]	str	el arreglo de caracteres donde se encuentra el de bits.
[in]	num_bits	la cantidad de bits del arreglo. Note que no es la misma que la cantidad de bytes.

Hace referencia a Aleph::DynArray< T >::cut() y Aleph::DynArray< T >::touch().

Referenciado por BitArray() y Aleph::load_tree_from_array().

Gráfico de llamadas para esta función:

Gráfico de llamadas a esta función:

BitArray& Aleph::BitArray::operator=	(	const BitArray &	array	)
throw	(	std::exception,
		std::bad_alloc
	)

inline

Asignación de arreglo de bits.

Libera toda la memoria de this, aparta nueva memoria para albergar array y copia exactamente los bits de array a this.

Parámetros

[in] array el arreglo de bits a ser copiado.

Excepciones

bad_alloc si no hay suficiente memoria para un bloque continuo de dim/8 bytes.

Nota: Si ocurre esta excepción, el estado de this permanece el mismo anterior a la asignación.

int Aleph::BitArray::read ( const size_t i ) const

inline

Lectura rápida del bit i.

Lee el bit i sin verificar memoria

Parámetros

[in] i índice del bit a ser leído.

Devuelve: el valor del bit i

Nota: No se verifica fuera de rango.

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

Gráfico de llamadas para esta función:

int Aleph::BitArray::read_bit ( const size_t i ) const

inline

Lee el bit i.

Parámetros

[in] i índice del bit a ser leído.

Devuelve: el valor del bit i

Nota: No se verifica fuera de rango.

Referenciado por bits_list(), circular_left_shift(), circular_right_shift(), Aleph::Huffman_Decoder_Engine::decode(), dyn_right_shift(), left_shift() y right_shift().

Gráfico de llamadas a esta función:

void Aleph::BitArray::reserve ( size_t dim )

inline

Reserva por adelantado memoria para el arreglo de bits a la dimensión dim.

reserve() aparta por adelantado la memoria suficiente para guardar dim bits. De este modo, los accesos de escritura o lectura pueden hacerse directa y más rápidamente mediante los métodos read() y write().

Excepciones

bad_alloc si no hay suficiente memoria

Hace referencia a Aleph::DynArray< T >::reserve().

Gráfico de llamadas para esta función:

void Aleph::BitArray::right_shift ( const size_t n = 1 )

inline

Desplaza los bits n posiciones a la derecha.

Los bits son desplazados y se considera al arreglo de tamaño fijo, es decir, los últimos n bits se pierden.

Parámetros

[in] n la cantidad de posiciones que se van a desplazar los bits.

Hace referencia a read_bit() y write_bit().

Gráfico de llamadas para esta función:

void Aleph::BitArray::save ( ofstream & output )

inline

Guarda en un archivo texto la secuencia de bits.

save() almacena en el archivo texto output, ya abierto, la secuencia de bits en formato decimal.

La primera línea siempre guarda el tamaño en bytes y en bits. Seguidamente se guardan en valor decimal los bytes secuenciales correspondientes al arreglo.

Parámetros

[in] output stream de salida abierto donde se guardaría el arreglo.

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

Referenciado por Aleph::save_tree().

Gráfico de llamadas para esta función:

Gráfico de llamadas a esta función:

void Aleph::BitArray::save_in_array_of_chars	(	const string &	name,
		ofstream &	output
	)

inline

Guarda en un archivo texto una declaración estática de cadena de carateres que representa el arreglo.

save_in_array_of_chars(name, output) genera una declaración del tipo:

char name [ size ] = { valores del arreglo separados con comas };

La declaración es guardada en el stream de salida output y el nombre del arreglo es name.

Parámetros

[in]	name	nombre de la variable arreglo.
[in]	output	stream de salida donde se desea guardar la declaración.

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

Referenciado por Aleph::save_tree_in_array_of_chars().

Gráfico de llamadas para esta función:

Gráfico de llamadas a esta función:

void Aleph::BitArray::write	(	const size_t	i,
		const unsigned int	value
	)

inline

Escribe el bit i con el valor value sin verificación de memoria.

Parámetros

[in]	i	índice del bit a ser escrito.
[in]	value	valor a ser escrito en la posición i.

Nota: No se verifica fuera de rango y no verifica que value tenga un valor binario.

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

Gráfico de llamadas para esta función:

void Aleph::BitArray::write_bit	(	const size_t	i,
		const unsigned int	value
	)

inline

Escribe el bit i con el valor value

Parámetros

[in]	i	índice del bit a ser escrito.
[in]	value	valor a ser escrito en la posición i.

Nota: No se verifica fuera de rango y no verifica que value tenga un valor binario.

Hace referencia a Aleph::DynArray< T >::touch().

Referenciado por circular_left_shift(), circular_right_shift(), dyn_right_shift(), left_shift(), push() y right_shift().

Gráfico de llamadas para esta función:

Gráfico de llamadas a esta función:

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

bitArray.H

Métodos públicos

Amigas

Descripción detallada

Documentación del constructor y destructor

Documentación de las funciones miembro