Secuencias

Clases
class	Aleph::BitArray
class	Aleph::Dlink
class	Aleph::Dlink::Iterator
	Iterador sobre enlaces. Más...
class	Aleph::Filter_Iterator< Container, It, Show_Item >
class	Aleph::HTList
class	Aleph::DynList< T >
class	Aleph::Slink
class	Aleph::Slink_Nc
class	Aleph::ArrayQueue< T >
class	Aleph::FixedQueue< T >
class	Aleph::ArrayStack< T >
class	Aleph::FixedStack< T >
class	Aleph::Dlist_Node< T >
class	Aleph::Dlist_Node_Vtl< T >
class	Aleph::GenDlist< Node_Type, T >
	Lista genérica doblemente enlazada de nodos. Más...
class	Aleph::Dlist< T >
	Lista doblemente enlazada de nodos sin destructor virtual. Más...
class	Aleph::DlistVtl< T >
	Lista doblemente enlazada de nodos con destructor virtual. Más...
class	Aleph::Dnode< T >
	Nodo perteneciente a lista doblemente enlazada circular. Más...
class	Aleph::Dyn_Slist_Nc< T >
class	Aleph::DynArray< T >
class	DynArray_Set< T, Equal >
class	Aleph::DynDlist< T >
class	Aleph::DynListQueue< T >
class	Aleph::DynListStack< T >
class	Aleph::DynMatrix< T >
class	Aleph::DynSlist< T >
class	Aleph::ListQueue< T >
class	Aleph::ListStack< T >
class	Aleph::Random_Set< T >
class	Aleph::Slist< T >
class	Aleph::Snode< T >
class	Wrapper_Iterator< Container, It, Show_Item >

'defines'
#define	DLINK_TO_TYPE(type_name, link_name)
#define	LINKNAME_TO_TYPE(type_name, link_name)
#define	DLINK_TO_BASE(type_name, link_name)
#define	SLINK_TO_TYPE(type_name, link_name)

Descripción detallada

Secuencias

En Aleph una secuencia comprende toda estructura de datos que involucre a un arreglo o a una lista enlazada y algoritmos pertinentes a estas técnicas de organización de datos.

Dentro de esta categoría, comprende los siguientes grupos de algoritmos y estructuras de datos:

1. Arreglos: arreglos dinámicos DynArray<T> y arreglos de bits BitArray. #- Listas enlazadas: la doctrina de Aleph es manejar listas enlazadas bajos los siguientes niveles:
   • Manejo de enlaces: en este nivel se asume un enlace simple (Slink) o uno doble (Dlink) que definen enlaces de nodos de listas enlazadas simples o dobles, respectivamente.
   • Manejo de nodos: en este nivel se define la abstracción de nodo de una lista enlazada que contiene un dato de algún tipo T. A este tenor, se proveen las clases Snode<T> y Dnode<T>.
   • Listas de nodos: Slist y Dlist.
   • Listas dinámicas: DynSlist y DynDlist.
2. Algoritmos de inserción, búsqueda y eliminación sobre arreglos y listas.
3. Métodos de ordenamiento

Autor

Leandro Rabindranath León (lrleon en ula punto ve)

Documentación de los 'defines'

#define DLINK_TO_BASE	(		type_name,
			link_name
	)

Valor:

inline static type_name * dlink_to_base(Dlink * link)                   \
  {                                                                     \
    type_name * ptr_zero = 0;                                           \
    size_t offset_link = reinterpret_cast<size_t>(&(ptr_zero->link_name)); \
    char * address_type = reinterpret_cast<char*>(link) - offset_link;  \
    return reinterpret_cast<type_name *>(address_type);                 \
  }

Genera una función link_to_base de enlace doble a estructura que lo contenga.

Este macro se utiliza cuando se tiene un dlink que es parte de una estructura, se desea obtener un apuntador a la estructura desde el enlace y se requiere un nombre fijo. Los otros macros generan nombres que contienen el nombre de la clase.

Si tenemos, por ejemplo: struct Registro { ... Dlink l; ... };

Entonces DLINK_TO_BASE(Registro, l) generará la función:

Registro * dlink_to_base(Dlink * link), la cual recibe un apuntador Dlink al campo de un registro "Registro" y retorna el puntero al registro.

Parámetros

type_name	el tipo de la estructura (struct o class) que contiene al dlink.
link_name	el nombre del campo del enlace doble dentro de la estructura.

#define DLINK_TO_TYPE	(		type_name,
			link_name
	)

Valor:

inline static type_name * dlink_to_##type_name(Dlink * link) \
{ \
  type_name * ptr_zero = 0; \
  size_t offset_link = reinterpret_cast<size_t>(&(ptr_zero->link_name));\
  char * address_type = reinterpret_cast<char*>(link) - offset_link; \
  return reinterpret_cast<type_name *>(address_type); \
}

Genera una función de conversión de nombre de enlace doble a estructura que lo contenga.

Este macro se utiliza cuando se tiene un dlink que es parte de una estructura y se desea obtener un apuntador a la estructura desde el enlace.

Si tenemos, por ejemplo: struct Registro { ... Dlink l; ... };

Entonces DLINK_TO_TYPE(Registro, l) generará la función:

Registro * dlink_to_Registro(Dlink * link), la cual recibe un apuntador Dlink al campo de un registro "Registro" y retorna el puntero al registro.

Parámetros

type_name	el tipo de la estructura (struct o class) que contiene al dlink.
link_name	el nombre del campo del enlace doble dentro de la estructura.

#define LINKNAME_TO_TYPE	(		type_name,
			link_name
	)

Valor:

inline static type_name * link_name##_to_##type_name(Dlink * link) \
{ \
  type_name * ptr_zero = 0; \
  size_t offset_link = reinterpret_cast<size_t>(&(ptr_zero->link_name));\
  char * address_type = reinterpret_cast<char*>(link) - offset_link; \
  return reinterpret_cast<type_name *>(address_type); \
}

Genera función de conversión de nombre de enlace doble a estructura que lo contenga. El nombre de la función es literalmente el parámetro que se instancie como link_name

Este macro se utiliza cuando se tiene dos o más Dlink que son parte de una estructura y se desea obtener un apuntador a la estructura desde algunos de los enlaces.

Si tenemos, por ejemplo: struct Registro { ... Dlink l1; Dlink l2; ... };

Entonces LINKNAME_TO_TYPE(Registro, l1) y LINKNAME_TO_TYPE(Registro, l2) generará las funciones:

1. Registro * l1_to_type(Dlink * link), la cual recibe un apuntador al campo l1 del registro y retorna el puntero al registro.
2. Registro * l2_to_type(Dlink * link), la cual recibe un apuntador al campo l2 del registro y retorna el puntero al registro.

La idea es disponer de esquemas de nombramiento que permitan hacer la distición entre los campos.

Parámetros

type_name	el tipo de la estructura (struct o class) que contiene al Dlink.
link_name	el nombre del campo del enlace doble dentro de la estructura.

#define SLINK_TO_TYPE	(		type_name,
			link_name
	)

Valor:

static type_name * slink_to_type(Slink * link)                  \
  {                                                                     \
    type_name * ptr_zero = 0;                                           \
    size_t offset_link = (size_t) &(ptr_zero->link_name);               \
    unsigned long address_type = ((unsigned long) link) - offset_link;  \
    return (type_name *) address_type;                                  \
  }

Genera función de conversión de nombre de enlace simple a estructura que lo contenga. El nombre de la función es literalmente el parámetro que se instancie como link_name

Este macro se utiliza cuando se tiene dos o más Slink que son parte de una estructura y se desea obtener un apuntador a la estructura desde algunos de los enlaces.

Si tenemos, por ejemplo: struct Registro { ... Slink l1; Slink l2; ... };

Entonces slink_TO_TYPE(Registro, l1) y SLINK_TO_TYPE(Registro, l2) generará las funciones:

1. Registro * l1_to_type(Slink * link), la cual recibe un apuntador al campo l1 del registro y retorna el puntero al registro.
2. Registro * l2_to_type(Slink * link), la cual recibe un apuntador al campo l2 del registro y retorna el puntero al registro.

La idea es disponer de esquemas de nombramiento que prmitan hacer la distición entre los campos.

Parámetros

type_name	el tipo de la estructura (struct o class) que contiene al Slink.
link_name	el nombre del campo del enlace doble dentro de la estructura.