Serie ficheros virtuales


 

C Ficheros virtuales

 

 

 

C.2.2 Manual del usuario de la clase wFile.

 

C.2.2.1 Lista de métodos por orden alfabético

C.2.2.2 Lista de métodos por grupos funcionales


C.2.2.3 Detalle de métodos

  C.2.2.3.1 Estructura de soporte

 

  C.2.2.3.2 Métodos de gestión de objetos

   C.2.2.3.2.1 Creación de ficheros. wFile, NEW, NOW y RESIZE

   C.2.2.3.2.2 CRTLF. Creación de lógicos

   C.2.2.3.2.3 CLRF. Vaciado de datos

   C.2.2.3.2.4 ERASE. Eliminación completa

   C.2.2.3.2.5 CLOSE. Cierre de la aplicación

 

  C.2.2.3.3 Funciones de caché básico. Núcleo del sistema

   C.2.2.3.3.1 Grupo CHAIN (Recuperación de datos por clave)

   C.2.2.3.3.2 Grupo WRITE (Grabación de datos)

 

  C.2.2.3.4 Funciones derivadas directas

   C.2.2.3.4.1 Grupo UPDATE. Actualización de ítem por clave

   C.2.2.3.4.2 Grupo DELET. Eliminación de ítem por clave

  C.2.2.3.5 Funciones derivadas intrínsecamente del orden

   C.2.2.3.5.1 Grupo posicionamiento (SETLL...)

   C.2.2.3.5.2 Grupo lectura (READ...)

 

   C.2.2.3.5.3 Ejemplos de posicionamiento y lectura

   C.2.2.3.5.3.1 El posicionamiento SETLL y la lectura por clave igual READE

  C.2.2.3.5.3.2 El posicionamiento SETGT y la lectura por clave igual hacia atrás READPE

  C.2.2.3.5.3.3 El posicionamiento SETGTT y la lectura secuencial READ

  C.2.2.3.6 Extensiones de base de datos. CPY y DUP

  C.2.2.3.7 Persistencia de datos. RSTF y SAVF

  C.2.2.3.8 Grupo informativo y de control. INF, NAME y NID

 

  C.2.2.3.9 Grupo emulación pilas (LIFO)

   C.2.2.3.9.1 El programa de muestra PruebasWpila

   C.2.2.3.9.2 Creación de pilas. NEW y LIFO_NEW

   C.2.2.3.9.3 Aplicación de RSTF a una pila

   C.2.2.3.9.4 El desapilado. LIFO_READ

   C.2.2.3.9.5 El apilado. LIFO_WRITE

 

  C.2.2.3.10 Grupo emulación colas (FIFO)

   C.2.2.3.10.1 El programa de muestra PruebasWcola

   C.2.2.3.10.2 Creación de colas. NEW y FIFO_NEW

   C.2.2.3.10.3 Aplicación de RSTF a una cola

   C.2.2.3.10.4 El desencolado. FIFO_READ

   C.2.2.3.10.5 El encolado. FIFO_WRIT

 

                                                                                      ________

 

 

 

C.2.2.1 Lista de métodos por orden alfabético

 

long CHAIN(const void *vClav, void *vDato)

long CHAIN(void *vDato)

long CHAIN(const char *cName, const void *vClav, void *vDato)

long CHAIN(const char *cName, void *vDato)

 

short int CLOSE(void)

 

long CLRF(long *lNBAJp)

long CLRF()

long CLRF(const char *cLF, long *lNBAJp)

long CLRF(const char *cLF)

 

long CPY(const char *cORG, const char *cDES, short int iREP)

long CPY(const char *cORG, const char *cDES)

 

long CRTLF(const char *cLF, int iKPOS, int iKLEN)

long CRTLF(const char *cLF, const char *cName, int iKPOS, int iKLEN)

 

long DELET(const void *vClav)

long DELET(const char *cLF, const void *vClav)

 

long DUP(const char *cORG, const char *cDES)

 

short int ERASE(void)

short int ERASE(const char *cName)

 

long FIFO_NEW(const char *cName, long lDimD, long lMaxNreg)

long FIFO_NEW(const char *cName, long lDimD)

 

short int FIFO_READ(const char *cName, void *vDato, char cOpci)

short int FIFO_READ(const char *cName, void *vDato)

 

long FIFO_WRIT(const char *cName, const void *vDato)

 

long LIFO_NEW(const char *cName, long lDimD, long lMaxNreg)

long LIFO_NEW(const char *cName, long lDimD)

 

short int LIFO_READ(const char *cName, void *vDato, char cOpci)

short int LIFO_READ(const char *cName, void *vDato)

 

long LIFO_WRIT(const char *cName, const void *vDato)

 

short int INF(int *iDimCp, long *lDimDp, long *lNITEMp, long *lBAJASp, long *lNIDDp)

short int INF(const char *cLF, int *iDimCp, long *lDimDp, long *lNITEMp, long *lBAJASp, long *lNIDDp)

 

char *Name()

char *Name(const char *cName)

 

long NEW(const char *cName, int iDimC)

long NEW(const char *cName, int iDimC, long lDimD)

long NEW(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

long NID()

long NID(const char *cLF)

 

long NOW(const char *cName, int iDimC)

long NOW(const char *cName, int iDimC, long lDimD)

long NOW(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

short int READ(long lINDIp, void *vDato, void *vClav)

short int READ(long lINDIp, void *vDato)

short int READ(const char *cLF, long lINDIp, void *vDato, void *vClav)

short int READ(const char *cLF, long lINDIp, void *vDato)

 

long READE(const void *vCLVp, long lLong, void *vDato, void *vClav)

long READE(const void *vCLVp, long lLong, void *vDato)

long READE(const char *cLF, const void *vCLVp, long lLong, void *vDato, void *vClav)

long READE(const char *cLF, const void *vCLVp, long lLong, void *vDato)

 

long READPE(const void *vCLVp, long lLong, void *vDato, void *vClav)

long READPE(const void *vCLVp, long lLong, void *vDato)

long READPE(const char *cLF, const void *vCLVp, long lLong, void *vDato, void *vClav)

long READPE(const char *cLF, const void *vCLVp, long lLong, void *vDato)

 

short int REORGANIZE(long *lNBAJp)

short int REORGANIZE(void)

short int REORGANIZE(const char *cName, long *lNBAJp)

short int REORGANIZE(const char *cName)

 

long RESIZ(int iDimC, long lDimD, long lMaxNreg)

long RESIZ(int iDimC, long lDimD)

long RESIZ(long lMaxNreg)

long RESIZ(const char *cName, int iDimC, long lDimD, long lMaxNreg)

long RESIZ(const char *cName, int iDimC, long lDimD)

long RESIZ(const char *cName, long lMaxNreg)

long RESIZ(const char *cName, const char *cOpci, long lDimD, long lMaxNreg)

long RESIZ(const char *cName, const char *cOpci, long lDimD)

 

long RSTF(const char *cSAVF)

long RSTF_NAME(const char *cName)

 

long SAVF(const char *cSAVF)

long SAVF_NAME(const char *cName)

 

long SETEQ(const void *vCLVp, long lLong)

long SETEQ(const void *vCLVp)

 

long SETEQ(const char *cLF, const void *vCLVp, long lLong)

long SETEQ(const char *cLF, const void *vCLVp)

 

long SETGT(const void *vCLVp, long lLong)

long SETGT(const void *vCLVp)

 

long SETGT(const char *cLF, const void *vCLVp, long lLong)

long SETGT(const char *cLF, const void *vCLVp)

 

long SETGTT(const void *vCLVp, long lLong)

long SETGTT(const void *vCLVp)

 

long SETGTT(const char *cLF, const void *vCLVp, long lLong)

long SETGTT(const char *cLF, const void *vCLVp)

 

long SETLL(const void *vCLVp, long lLong)

long SETLL(const void *vCLVp)

 

long SETLL(const char *cLF, const void *vCLVp, long lLong)

long SETLL(const char *cLF, const void *vCLVp)

 

long VER(const void *vClav)

long VER(const char *cName, const void *vClav)

 

wFile(void)

wFile(long lDimD)

wFile(int iDimC, long lDimD)

wFile(int iDimC, long lDimD, long lMaxNreg)

wFile(const char *cName)

wFile(const char *cName, long lDimD)

wFile(const char *cName, int iDimC, long lDimD)

wFile(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

wFile(const char *cName, const char *cOpci, long lDimD, long lMaxNreg)

wFile(const char *cName, const char *cOpci, long lDimD)

 

long WRITE(const void *vClav, const void *vDato)

long WRITE(const void *vDato)

 

long WRITE(const char *cLF, const void *vClav, const void *vDato)

long WRITE(const char *cLF, const void *vDato)

 

long UPDATE(const void *vClav, const void *vDato)

long UPDATE(const void *vDato)

 

long UPDATE(const char *cLF, const void *vClav, const void *vDato)

long UPDATE(const char *cLF, const void *vDato)

 

                                                                                      ________


C.2.2.2 Lista de métodos por grupos funcionales

 

//--------------------------------------------------------------------------------------

// Funciones de gestión de objetos

//--------------------------------------------------------------------------------------

 

// Crear por constructores

 

wFile(void)

 

wFile(long lDimD)

wFile(int iDimC, long lDimD)

wFile(int iDimC, long lDimD, long lMaxNreg)

 

wFile(const char *cName)

wFile(const char *cName, long lDimD)

wFile(const char *cName, int iDimC, long lDimD)

wFile(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

wFile(const char *cName, const char *cOpci, long lDimD, long lMaxNreg)

wFile(const char *cName, const char *cOpci, long lDimD)

 

 

 

// Crear, añadiendo nuevos ficheros a la clase en curso

// Limpia datos previos si existieran

 

long NEW(const char *cName, int iDimC)

long NEW(const char *cName, int iDimC, long lDimD)

long NEW(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

 

 

// Crear, añadiendo si procede nuevos ficheros a la clase en curso y sin limpiar datos previos si existieran

 

long NOW(const char *cName, int iDimC)

long NOW(const char *cName, int iDimC, long lDimD)

long NOW(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

 

 

// Reconstructores completos de un ítem de clase

 

long RESIZ(int iDimC, long lDimD, long lMaxNreg)

long RESIZ(int iDimC, long lDimD)

 

long RESIZ(const char *cName, int iDimC, long lDimD, long lMaxNreg)

long RESIZ(const char *cName, int iDimC, long lDimD)

 

long RESIZ(const char *cName, const char *cOpci, long lDimD, long lMaxNreg)

long RESIZ(const char *cName, const char *cOpci, long lDimD)

 

 

 

// Reconstructores reducidos para cambiar exclusivamente el nº máximo de registros permitidos

 

long RESIZ(long lMaxNreg)

long RESIZ(const char *cName, long lMaxNreg)

 

 

 

// Creación de vías de acceso suplementarias

 

long CRTLF(const char *cLF, int iKPOS, int iKLEN)

long CRTLF(const char *cLF, const char *cName, int iKPOS, int iKLEN)

 

 

 

// Vaciado de datos

 

long CLRF(const char *cLF, long *lNBAJp)

long CLRF(const char *cLF)

 

 

 

// Eliminación completa

 

short int ERASE(void)

short int ERASE(const char *cName)

 

 

 

// Cierre total

 

short int CLOSE(void)

 

 

 

//--------------------------------------------------------------------------------------

// Funciones de caché básico. Núcleo del sistema

//--------------------------------------------------------------------------------------

 

 

// Grupo CHAIN

 

long CHAIN(const void *vClav, void *vDato)

long CHAIN(void *vDato)

 

long CHAIN(const char *cName, const void *vClav, void *vDato)

long CHAIN(const char *cName, void *vDato)

 

long VER(const void *vClav)

long VER(const char *cName, const void *vClav)

 

 

 

// Grupo WRITE

 

long WRITE(const void *vClav, const void *vDato)

long WRITE(const void *vDato)

 

long WRITE(const char *cLF, const void *vClav, const void *vDato)

long WRITE(const char *cLF, const void *vDato)

 

 

 

// Funciones derivadas directas

 

 

 

// Grupo UPDATE

 

long UPDATE(const void *vClav, const void *vDato)

long UPDATE(const void *vDato)

 

long UPDATE(const char *cLF, const void *vClav, const void *vDato)

long UPDATE(const char *cLF, const void *vDato)

 

 

 

// Funciones derivadas intrínsicamente del orden

 

 

// Grupo DELETE

 

long DELET(const void *vClav)

long DELET(const char *cLF, const void *vClav)

 

 

 

// Grupo Posicionamiento

 

long SETEQ(const void *vCLVp, long lLong)

long SETEQ(const void *vCLVp)

 

long SETEQ(const char *cLF, const void *vCLVp, long lLong)

long SETEQ(const char *cLF, const void *vCLVp)

 

 

long SETGT(const void *vCLVp, long lLong)

long SETGT(const void *vCLVp)

 

long SETGT(const char *cLF, const void *vCLVp, long lLong)

long SETGT(const char *cLF, const void *vCLVp)

 

 

long SETGTT(const void *vCLVp, long lLong)

long SETGTT(const void *vCLVp)

 

long SETGTT(const char *cLF, const void *vCLVp, long lLong)

long SETGTT(const char *cLF, const void *vCLVp)

 

 

long SETLL(const void *vCLVp, long lLong)

long SETLL(const void *vCLVp)

 

long SETLL(const char *cLF, const void *vCLVp, long lLong)

long SETLL(const char *cLF, const void *vCLVp)

 

 

 

 

// Grupo READ

 

short int READ(long lINDIp, void *vDato, void *vClav)

short int READ(long lINDIp, void *vDato)

 

short int READ(const char *cLF, long lINDIp, void *vDato, void *vClav)

short int READ(const char *cLF, long lINDIp, void *vDato)

 

 

long READE(const void *vCLVp, long lLong, void *vDato, void *vClav)

long READE(const void *vCLVp, long lLong, void *vDato)

 

long READE(const char *cLF, const void *vCLVp, long lLong, void *vDato, void *vClav)

long READE(const char *cLF, const void *vCLVp, long lLong, void *vDato)

 

 

long READPE(const void *vCLVp, long lLong, void *vDato, void *vClav)

long READPE(const void *vCLVp, long lLong, void *vDato)

 

long READPE(const char *cLF, const void *vCLVp, long lLong, void *vDato, void *vClav)

long READPE(const char *cLF, const void *vCLVp, long lLong, void *vDato)

 

 

 

 

//--------------------------------------------------------------------------------------

// Extensión de base de datos

//--------------------------------------------------------------------------------------

 

// Copia de datos

 

long CPY(const char *cORG, const char *cDES, short int iREP)

long CPY(const char *cORG, const char *cDES)

 

 

// Duplicacion de bases de datos virtuales

 

long DUP(const char *cORG, const char *cDES)

 

 

 

//--------------------------------------------------------------------------------------

// Persistencia de datos

//--------------------------------------------------------------------------------------

 

// Restauración desde fichero físico

 

long RSTF(const char *cSAVF)

long RSTF_NAME(const char *cName)

 

 

// Salvado a fichero físico

 

long SAVF(const char *cSAVF)

long SAVF_NAME(const char *cName)

 

 

 

//--------------------------------------------------------------------------------------

// Grupo informativo y de control

//--------------------------------------------------------------------------------------

 

short int INF(int *iDimCp, long *lDimDp, long *lNITEMp, long *lBAJASp, long *lNIDDp)

short int INF(const char *cLF, int *iDimCp, long *lDimDp, long *lNITEMp, long *lBAJASp, long *lNIDDp)

 

char *Name()

char *Name(const char *cName)

 

long NID()

long NID(const char *cLF)

 

 

 

//----------------------------------------------------------------------------------

// Grupos de emulación de pilas y colas

//--------------------------------------------------------------------------------------

 

// Grupo emulación pilas (LIFO)

 

long LIFO_NEW(const char *cName, long lDimD, long lMaxNreg)

long LIFO_NEW(const char *cName, long lDimD)

 

 

short int LIFO_READ(const char *cName, void *vDato, char cOpci)

short int LIFO_READ(const char *cName, void *vDato)

 

 

long LIFO_WRIT(const char *cName, const void *vDato)

 

 

 

// Grupo emulación colas (FIFO)

 

long FIFO_NEW(const char *cName, long lDimD, long lMaxNreg)

long FIFO_NEW(const char *cName, long lDimD)

 

 

short int FIFO_READ(const char *cName, void *vDato, char cOpci)

short int FIFO_READ(const char *cName, void *vDato)

 

 

long FIFO_WRIT(const char *cName, const void *vDato)

 

                                                                                      ________

 

C.2.2.3 Detalle de métodos

 

La lista resumida del epígrafe anterior se presenta ahora ampliada y comentada con ejemplos.

 

También puede acudirse a la lista de funciones de SRRCW donde se presentan otros ejemplos pues sus funciones se pueden extrapolar directamente.

 

Para este manual dedicado a los métodos de wFile nos apoyaremos en la serie de programas ejemplo PruebasWxxxxx, concretamente PruebasWfile para las pruebas de bases de datos ordinarias, PruebasWver para la prueba del grupo VER, PruebasWpila para las pruebas de pilas y PruebasWcola para las de colas.

 

Veamos ahora una muestra de PruebasWfile

 

 

 

Para muestras en Visual Basic.NET se utilizará el programa PruebasV, de interfaz

 

 

 

y que utiliza la clase vbFile, versión de vFile orientada a uso por cadenas.

 

                                                                                      ________


C.2.2.3.1 Estructura de soporte

 

Los ejemplos de ilustración del manual utilizan la siguiente definición de estructuras de soporte, compuesta de una subestructura de clave principal, una subestructura de clave alternativa y una subestructura de datos:

 

 

// Ds de clave principal del fichero de soporte de pruebas

 

struct sK // Estructura de claves de acceso a nodos (i,j)

{

 long li; // Indice i del nodo

 long lj; // Indice j del nodo

};

 

 

// Ds de clave alternativa del fichero “lógico” de soporte de pruebas

 

struct sK01 // Estructura de claves de acceso a nodos (j,i)

{

 long lj; // Indice j del nodo

 long li; // Indice i del nodo

};

 

 

// Ds de datos del fichero de soporte de pruebas

 

struct sD // Estructura de datos asociados

{

 long lk; // Valor del nodo

};

 

 

// Ds del fichero de soporte de pruebas

 

static struct sKD

{

 struct sK K;     // Clave principal

 struct sK01 K01; // Clave alternativa

 struct sD D;     // Datos

} KD; // Work paso de datos PrChain

 

 

 

Apoyándonos en esta colección de estructuras las instrucciones se van a ir presentando por grupos funcionales en los siguientes epígrafes

 

                                                                                      ________

 

 

C.2.2.3.2 Métodos de gestión de objetos


Se presentan a continuación las funciones wFile, NEW, NOW, RESIZE, CRTLF, CLRF, ERASE y CLOSE

 

 

                                                                                      ________

 

C.2.2.3.2.1 Creación de ficheros


Para crear un nuevo fichero disponemos de un amplio elenco de opciones, los constructores, los métodos NEW, NOW y los métodos RESIZE.

 

En primer lugar hay que distinguir entre los métodos aplicables a ficheros ordinarios y los aplicables a pilas y colas que veremos posteriormente.

 

Si no hay ninguna instancia nueva y se trata de un fichero normal, las posibilidades son o bien crear directamente por constructores, o bien crear temporalmente sin conocer los tamaños concretos al levantar el programa y recrear luego cuando se conozcan, para lo que se dispone de los siguientes métodos, de los que se señalan los principales:

 

 

// Crear por constructores

 

//

// Parámetros de entrada comunes de los constructores

//

//    iDimC: Dimensión claves del nuevo fichero

//    lDimD: Dimensión datos del nuevo fichero

// lMaxNreg: Nº Máximo de registros permitidos en el fichero

//

 

 

// Crear por constructores. Métodos de nombre automático. Para invocaciones únicas

 

wFile(void)

 

wFile(long lDimD)

wFile(int iDimC, long lDimD)

wFile(int iDimC, long lDimD, long lMaxNreg)

 

 

// Crear por constructores. Métodos de nombre explícito. Para invocaciones múltiples

 

wFile(const char *cName)

wFile(const char *cName, long lDimD)

wFile(const char *cName, int iDimC, long lDimD)

wFile(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

 

 

 

// Reconstructores completos de un ítem de clase

 

 

// Reconstructores sin nombre, para invocaciones únicas

 

long RESIZ(int iDimC, long lDimD, long lMaxNreg)

long RESIZ(int iDimC, long lDimD)

 

 

// Reconstructores con nombre, para invocaciones múltiples

 

long RESIZ(const char *cName, int iDimC, long lDimD, long lMaxNreg)

long RESIZ(const char *cName, int iDimC, long lDimD)

 

long RESIZ(const char *cName, const char *cOpci, long lDimD, long lMaxNreg)

long RESIZ(const char *cName, const char *cOpci, long lDimD)

 

 

 

 

Veamos un ejemplo concreto de aplicación, asociado al programa PruebasWfile, cuyos parámetros encontramos justo al lado del botón de restauración de datos de prueba:

 

 

 



 

Que responden al resultado de los sizeof  que se utilizan al crear el fichero virtual de pruebas:

 

. . .

 

public __gc class Form1 : public System::Windows::Forms::Form

{

 

 private: static wFile::wFile *wFILE = new wFile::wFile(sizeof(sK), sizeof(KD));

 

 . . .

 

 

 

En este ejemplo se utiliza una versión de nombre automático y se proporciona el tamaño de la clave y de los datos.

 

 

Una alternativa equivalente habría sido utilizar la siguiente combinación:

 

 

 . . .

 

 public __gc class Form1 : public System::Windows::Forms::Form

 {

 

  private: static wFile::wFile *wFILE = new wFile::wFile();

 

  . . .

 

  wFile->RESIZ(sizeof(sK), sizeof(KD));

 

  . . .

 

 

 

Indicar que la clase, en su variante vbFile, también puede utilizarse en Visual Basic.NET como en el ejemplo del programa PruebasV que sigue:

 

 . . .

 

 Dim PRUEBASV As New vbFile.vbFile("PRUEBASV", 10, 80)

 Dim PRUEBASVVER As New vbFile.vbFile("PRUEBASVVER", 80)

 Dim PRUEBASVPILA As New vbFile.vbFile("PRUEBASVPILA", "P", 80)

 Dim PRUEBASVCOLA As New vbFile.vbFile("PRUEBASVCOLA", "C", 80)

 

 . . .

 

 

En este caso se utilizan métodos con nombre porque en el mismo interfaz se utilizan múltiples invocaciones, a diferencia de la serie de PruebasWxxxx en donde en cada programa de la serie se utiliza una invocación de clase vFile única.

 

 

 

Si una vez creado el fichero se desea cambiar su número máximo de registros posible, se debe utilizar el método RESIZ en su variante específica:

 

 

 // Reconstructores reducidos para cambiar exclusivamente el nº máximo de registros permitidos

 

 long RESIZ(long lMaxNreg)

 long RESIZ(const char *cName, long lMaxNreg)

 

 

 

 

En una clase wFile se pueden añadir más ficheros utilizando los métodos NEW, que crea borrando registros previos si los hubiera, o NOW que se limita a crear si no existe el objeto previamente y cuya sintaxis es:

 

 

 

// Crear, añadiendo nuevos ficheros a la clase en curso. Limpia datos previos si existieran

 

long NEW(const char *cName, int iDimC)

long NEW(const char *cName, int iDimC, long lDimD)

long NEW(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

 

 

// Crear, añadiendo si procede nuevos ficheros a la clase en curso y sin limpiar datos previos si existieran

 

long NOW(const char *cName, int iDimC)

long NOW(const char *cName, int iDimC, long lDimD)

long NOW(const char *cName, int iDimC, long lDimD, long lMaxNreg)

 

 

 

Veamos ahora los métodos dedicados a pilas y colas

 

 

wFile(const char *cName, const char *cOpci, long lDimD, long lMaxNreg)

wFile(const char *cName, const char *cOpci, long lDimD)

 

 

 

Como en el ejemplo siguiente extraído del programa PruebasWpila

 

 

. . .

 

static const long lSize = 512; // Longtud *dft wFile's

 

. . .

 

public __gc class Form1 : public System::Windows::Forms::Form

{

 

 private: static wFile::wFile *wPILA = new wFile::wFile("WPILA", "P", lSize);

 

 . . .

 

                                                                                      ________

 

 

C.2.2.3.2.2 CRTLF. Creación de lógicos


Para la Creación de vías de acceso suplementarias se dispone de la familia de funciones CRTLF:

 

 

//--------------------------------------------------------------------------------------

//

// Métodos CRTLF

//

// Descripción Crean un lógico en base a un fichero físico previo

//

// Importante La clave del físico debe ocupar las 1ras.posiciones del registro

//

// Parámetros

// (entrada) cLF Nombre del fichero lógico a crear

//           cPF Nombre del fichero físico base (En las clase con nombre explícito)

// iKPOS Posición de comienzo de clave del LF en los datos del registro (Formato 1..N RPG)

// iKLEN Longitud de la clave del LF que se está creando

//

// Retorno

//  0 Error de proceso

// >0 NID del fichero en memoria

//

//--------------------------------------------------------------------------------------

long CRTLF(const char *cLF, int iKPOS, int iKLEN)

long CRTLF(const char *cLF, const char *cName, int iKPOS, int iKLEN)

 

 

 

Veamos un ejemplo de uso en PruebasWfile, al cargar el formulario:

 

. . .

 

private: System::Void Form1_Load(System::Object * sender, System::EventArgs * e)

{

 long lNID01 = 0; // Id.LF generado

 

 

 // Crea fichero lógico asociado ("WFILE01")

 

 cFile = wFILE->Name();

 lFile = SRRCAL_lFile(cFile, 01);

 

 lNID01 = wFILE->CRTLF(lFile, 1 + sizeof(KD.K), sizeof(KD.K01));

 

. . .

 

En este ejemplo se recupera el nombre del físico (sea p.e. FISICO) y se propone como nombre del lógico FISICO01, que se crea a continuación utilizando como vía de acceso alternativa la subestructura KD.K01

 

Este fichero lógico es el soporte del botón de reordenación, que permite pasar de los datos origen a los datos reordenados del cuadro de lista como se muestra en las imágenes:

 

 

Vista principal Vista reordenada

 

                                                                                      ________

 

 

C.2.2.3.2.3 CLRF. Vaciado de datos


//----------------------------------------------------------------------------------

// Método CLRF

//

// DESCRIPCION: Vacía los datos (CLRPFM) de un fichero

//

//

// PARAMETROS.: Todos los parámetros son opcionales

//

// (entrada)  cLF : Nombre de fichero, si se precisa

// (salida) lNBAJp: Nº bajas procesadas, si se desea

//

// RETORNO....:

//  0: O.K.

// >0: Error de proceso

//

//----------------------------------------------------------------------------------

 

long CLRF(long *lNBAJp)

long CLRF()

 

long CLRF(const char *cLF, long *lNBAJp)

long CLRF(const char *cLF)

 

 

Veamos el fragmento de código asociado al botón CLRF del programa ejemplo:

 

. . .

 

System::Void Clrf_Click(System::Object * sender, System::EventArgs * e)

{

 long lresul = 0; // Control de resultados

 

 

 // Proceso. Vacia wFILE

 

 lresul = wFILE->CLRF();

 

 

 // Presenta estadísticas

 

 Estadisticas_Click(sender, e);

 

 

 // Presenta sfl

 

 Presentar_Click(sender, e);

 

 return;

}

 

. . .

 

 

Vista con datos Vista tras aplicar CLRF

 

                                                                                      ________

 

 

C.2.2.3.2.4 ERASE. Eliminación completa


ERASE elimina un fichero por completo, liberando el espacio ocupado tanto por sus datos como por la propia definición del fichero.

 

//----------------------------------------------------------------------------------

// Método ERASE

//

// DESCRIPCION: Borra un fichero ("DLTF")

//

// PARAMETROS.:

//

// (entrada opcional) cName: Nombre del fichero solicitado

//

// Si no se indica se elimina el fichero único (se sobreentiende) asociado a la clase

//

// RETORNO....:

//  0: O.K.

// >0: Error de proceso

//

//----------------------------------------------------------------------------------

 

short int ERASE(void) // Elimina el fichero único asociado a la clase

short int ERASE(const char *cName) // Elimina el fichero indicado de la clase

 

                                                                                      ________

 

 

C.2.2.3.2.5 CLOSE. Cierre de la aplicación

 

Al cerrar se eliminan todos los ficheros y su soporte. Es un método reservado para el botón de cierre de una aplicación. Aunque halla varias clases, sólo precisa emitirse una vez.

 

CLOSE permite cerrar la aplicación liberando todo la memoria utilizada evitando así colapsos de asignación, tal y como se indicó en el capítulo de asignación y liberación de memoria.

 

 

//-----------------------------------------------------------------------------------

// Destructor efectivo: Interfaz a SRRCW_CLOSE

//-----------------------------------------------------------------------------------

 

short int CLOSE(void)

 

 

Así, nos lo encontramos al cerrar la aplicación de PruebasWfile, como sigue:

 

 

 

-Al pulsar el botón “Salir”

 

Salir_Click(System::Object * sender, System::EventArgs * e)

{

 short int er = 0; // Control de errores de invocación

 

 er = wFILE->CLOSE();

 

 exit(0);

 

 return;

}

 

 

-Al marcar la pestaña de cierre

 

Form1_Closing(System::Object * sender,System::ComponentModel::CancelEventArgs * e)

{

 short int er = 0; // Control de errores de invocación

 

 er = wFILE->CLOSE();


 

 return;

}

                                                                                      ________

 

 

C.2.2.3.3 Funciones de caché básico. Núcleo del sistema


                                                                                     ________


C.2.2.3.3.1 Grupo CHAIN (Recuperación de datos por clave)

 

//-----------------------------------------------------------------------------------

//

// Método CHAIN

//

// DESCRIPCION: Recupera un Ítem de Memoria por Clave

//

//

// PARAMETROS.: Formato completo

//

// (entrada) vClav: Clave del Ítem

// (salida ) vDato: Datos del Ítem

//

//

// PARAMETROS.: Formato compacto

//

// (I/O) vClav: Clave + datos del Ítem

//

//

// Además de las versiones con nombre para ficheros explícitos o para lógicos

//

// RETORNO....:

//  0: Error de Proceso (No encontrado, ...)

// >0: Índice en memoria-claves del Ítem encontrado

// (formato 1..N)

//

//----------------------------------------------------------------------------------

 

long CHAIN(const void *vClav, void *vDato)

long CHAIN(void *vDato)

 

long CHAIN(const char *cName, const void *vClav, void *vDato)

long CHAIN(const char *cName, void *vDato)

 

 

Gráficamente, en el programa PruebasWfile, al introducir la clave y pulsar “Chain” ...

 

 

 

 

 

se recuperan los datos asociados:

 

 

 

 

 

Un extracto de la codificación asociada al botón “CHAIN” es el siguiente:

 

 

System::Void Chain_Click(System::Object * sender, System::EventArgs * e)

{

 long lresul = 0; // Control de resultados

 String *sW; // Wk.Paso de string

 Int32 iW = 0; // Wk.Paso de nº(string)

 

 

 // Inicializa índices resultado

 

 IndicesResultado_Click(sender, e);

 

 

 

 // Inz campos de salida

 

 KiChain->Text = " ";

. . .

 

 

 

 // Pasa claves

 

 sW = KiWrite->Text;          // Pasa clave I a la variable auxiliar String sW

 KD.K.li = ALFACONV->s2l(sW); // Convierte sW a long utilizando la clase ALFACONV

 SRRCAL_lLexi(&KD.K.li);      // Transpone li para ordenación lexicográfica

 

. . . (Idem para clave J)

 

 

 

 // Utiliza el método CHAIN para acceder a los datos

 

 lresul = wFILE->CHAIN(&KD);

 

 

 

 // Pasa índice resultado

 

 iW = lresul;

 ResulChain->Text = iW.ToString();

 

 if (lresul <= 0) return;

 

 

 

 // Pasa claves y datos

 

 SRRCAL_lLexi(&KD.K.li);        // Transpone li para presentación ordinaria

 iW = KD.K.li;                  // Pasa long a Int32 para poder aplicar

 KiChain->Text = iW.ToString(); // el método de paso a String de la clave I

 

. . . (Idem para la clave J)

 

 iW = KD.D.lk;                 // Pasa el importe del dato a Int32 para poder

 DChain->Text = iW.ToString(); // aplicar el método de paso a String

 

 

 

 // Presenta estadísticas

 

 Estadisticas_Click(sender, e);

 

 

 // Presenta sfl

 

 Presentar_Click(sender, e);

 

 return;

}

 

 

 

Dentro del grupo CHAIN también se encuadran los métodos VER:

 

//----------------------------------------------------------------------------------

// Método VER

//

// Descripción: Determina la existencia de un ítem en memoria

//

// Función resumen simple de CHAIN + WRITE (Ítem)

//

// Supone una generación previa del fichero virtual de soporte con un constructor en donde se especifique que clave y datos coinciden

//

// Parámetros

// (entrada) vClav: Clave del ítem a verificar

//

// Además de la versión con nombre para ficheros explícitos

//

// Retorno

//  0: No preexistente

// >0: Índice en memoria-clave encontrado, formato 1..N

//----------------------------------------------------------------------------------

 

long VER(const void *vClav)

long VER(const char *cName, const void *vClav)

 

 

En el programa PruebasWfile está habilitado un botón que invoca al programa PruebasVer dedicado específicamente a éste método.

 

Así, se puede comprobar gráficamente que si se solicita un ítem preexistente, el método devuelve su posición en memoria:

 

 

 

 

Mientras que si se solicita un ítem nuevo, se devuelve 0 y se archiva para futuras consultas:

 

 

 

Este tratamiento gráfico puede hacerse porque la verificación emplea un fichero virtual de soporte y por tanto accesible para lecturas, salvados restauraciones, etc.

 

De hecho, las sentencias principales de PruebasVFile son

 

 

Creación del soporte:

 

. . .

 

static const long lSize = 512; // Longtud *dft wFile's

 

. . .

 

public __gc class Form1 : public System::Windows::Forms::Form

{

 

 

 private: static wFile::wFile *wVER = new wFile::wFile(lSize);

 

 . . .

 

 

 

Método VER:

 

 

System::Void VER_Click(System::Object * sender, System::EventArgs * e)

{

 long lresul = 0; // Control resultados

 String *sW; // Wk.Paso de string

 Int32 iW = 0; // Wk.Paso de nº(string)

 

 

 // Inicializa índices resultado

 

 IndicesResultado_Click(sender, e);

 

 

 // Pasa datos

 

 sW = Datos->Text;

 cName = sTOc(sW);

 

 

 // Evalúa item

 

 lresul = wVER->VER(cName);

 

 iW = lresul;

 ResulVer->Text = iW.ToString();

 

 

 // Presenta estadísticas

 

 Estadisticas_Click(sender, e);

 

 

 // Presenta sfl

 

 PresentarSfl_Click(sender, e);

 

 return;

}

                                                                                      ________

 

 

C.2.2.3.3.2 Grupo WRITE (Grabación de datos)

 

//-----------------------------------------------------------------

// Método WRITE

//

// DESCRIPCION: Salva un Item a memoria

//

//

// PARAMETROS Formato completo

//

// (entrada) vClav: Clave del Item

//           vDato: Datos del Item

//

//

// PARAMETROS Formato compacto

//

// (entrada) vDato: Clave + datos del ítem

//

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// RETORNO....:

//               0: Error de Proceso (Memoria out, ya existe...)

//               >0: Índice de Ítem-Clave Guardado Satisfactoriamente

//                  (Formato 1..N)

//-----------------------------------------------------------------

 

long WRITE(const void *vClav, const void *vDato)

long WRITE(const void *vDato)

 

long WRITE(const char *cLF, const void *vClav, const void *vDato)

long WRITE(const char *cLF, const void *vDato)

 

 

Gráficamente, en el programa PruebasWfile, al introducir la clave y los datos y pulsar “Write” ...

 

 

 

 

El nuevo ítem queda grabado:

 

 

 


 

Un extracto de la codificación asociada al botón “WRITE” es el siguiente:

 

System::Void Write_Click(System::Object * sender, System::EventArgs * e)

{

 long lresul = 0; // Control resultados

 String *sW;      // Wk.Paso de string

 Int32 iW = 0;    // Wk.Paso de nº(string)

 

 

 // Inicializa índices resultado

 

 IndicesResultado_Click(sender, e);

 

 

 // Pasa claves

 

 sW = KiWrite->Text;          // Pasa clave I a la variable auxiliar String sW

 KD.K.li = ALFACONV->s2l(sW); // Convierte sW a long utilizando la clase ALFACONV

 SRRCAL_lLexi(&KD.K.li);      // Transpone li para ordenación lexicográfica

 

 . . . (Idem para clave J)

 

 

 KD.K01.li = KD.K.li; // Pasa claves de la vía de acceso alternativa

 KD.K01.lj = KD.K.lj;

 

 

 // Pasa datos

 

 sW = DWrite->Text;

 KD.D.lk = ALFACONV->s2l(sW);

 

 

 // Graba item

 

 lresul = wFILE->WRITE(&KD);

 

 iW = lresul;

 ResulWrite->Text = iW.ToString();

 

 

 // Presenta estadísticas

 

 Estadisticas_Click(sender, e);

 

 

 // Presenta sfl

 

 Presentar_Click(sender, e);

 

 return;

}

                                                                                      ________

 


C.2.2.3.4 Funciones derivadas directas

 

                                                                                      ________

 

 

C.2.2.3.4.1 Grupo UPDATE. Actualización de ítem por clave


//-----------------------------------------------------------------

// Método UPDATE

//

// DESCRIPCION: Actualiza un Ítem en memoria

//

//

// PARAMETROS Formato completo

//

// (entrada) vClav: Clave del Ítem

//           vDato: Datos del Ítem

//

//

// PARAMETROS Formato compacto

//

// (entrada) vDato: clave + datos del ítem

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// RETORNO....:

//                0: Error de Proceso (Memoria out, ya existe...)

//               >0: Índice en memoria de la clave del ítem asociado

//

//-----------------------------------------------------------------

 

long UPDATE(const void *vClav, const void *vDato)

long UPDATE(const void *vDato)

 

long UPDATE(const char *cLF, const void *vClav, const void *vDato)

long UPDATE(const char *cLF, const void *vDato)

 

 

Gráficamente, en el programa PruebasWfile, al introducir la clave y los datos y pulsar “UPDATE” ...

 

 

 

El nuevo ítem queda actualizado:

 

 

 

 

Un extracto de la codificación asociada al botón “UPDATE” es el siguiente:

 

System::Void Update_Click(System::Object * sender, System::EventArgs * e)

{

 long lresul = 0; // Control resultados

 String *sW; // Wk.Paso de string

 Int32 iW = 0; // Wk.Paso de nº(string)

 

 

 // Inicializa índices resultado

 

 IndicesResultado_Click(sender, e);

 

 

 // Pasa claves

 

 sW = KiWrite->Text;          // Pasa clave I a la variable auxiliar String sW

 KD.K.li = ALFACONV->s2l(sW); // Convierte sW a long utilizando la clase ALFACONV

 SRRCAL_lLexi(&KD.K.li);      // Transpone li para ordenación lexicográfica

 

 . . . (Idem para clave J)

 

 

 // Pasa datos

 

 sW = DWrite->Text;

 KD.D.lk = ALFACONV->s2l(sW);

 

 

 // Actualiza item

 

 lresul = wFILE->UPDATE(&KD);

 

 iW = lresul;

 ResulUpdate->Text = iW.ToString();

 

 

 // Presenta estadísticas

 

 Estadisticas_Click(sender, e);

 

 

 // Presenta sfl

 

 Presentar_Click(sender, e);

 

 return;

}

                                                                                      ________

 

 

C.2.2.3.4.2 Grupo DELET. Eliminación de ítem por clave

 

//----------------------------------------------------------------------------------

// Método DELET

//

// Descripción Elimina un ítem de memoria

// Interfaz a SRRCW_DELETE

//

// (Nota: Para eliminar un ítem de clase, utilizar el método ERASE)

//

// Parámetros

// (entrada) vClav Clave del ítem

//

// Además de las versiones con nombre para ficheros explícitos o para lógicos

//

//

// Retorno

//         0 Error de proceso

//         >0 Posición en memoria del ítem suprimido

//

//----------------------------------------------------------------------------------

 

long DELET(const void *vClav)

long DELET(const char *cLF, const void *vClav)

 

 

Gráficamente, en el programa PruebasWfile, al introducir la clave y pulsar “DELET” ...

 

 

 

El ítem queda eliminado:

 

 

                                                                                      ________

 

 

C.2.2.3.5 Funciones derivadas intrínsecamente del orden

 

Estas funciones son muy importantes para los desarrollos algorítmicos pues permiten establecer bucles entre rangos de clave.

 

Las funciones se dividen en un grupo de posicionamiento y otro de lectura y su uso habitual consistirá precisamente en emitir un posicionamiento seguido de un ciclo de lectura, que se detendrá por fin de fichero o agotamiento de rango.

 

Ahora se presentarán los prototipos de los dos grupos, que se seguirá de ejemplos del ciclo posición-lectura.

 

                                                                                      ________

 

 

C.2.2.3.5.1 Grupo posicionamiento (SETLL...)


//-----------------------------------------------------------------------------------

// Método SETEQ

//

// Descripción: Determina la existencia en memoria de un ítem por clave igual, dejando a vFile preparado para responder a READE, etc.

//

//

// Parámetros Formato completo

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//           lLong: Longitud de clave significativa que se toma

//

//

// Parámetros Formato compacto

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// Retorno

//  0: Error de proceso (No encontrado...)

// >0: Índice en memoria-clave del ítem encontrado, en formato 1..N

//----------------------------------------------------------------------------------

long SETEQ(const void *vCLVp, long lLong)

long SETEQ(const void *vCLVp)

 

long SETEQ(const char *cLF, const void *vCLVp, long lLong)

long SETEQ(const char *cLF, const void *vCLVp)

 

 

//-----------------------------------------------------------------------------------

// Método SETGT

//

// Descripción: Sitúa en el índice de memoria-clave + próximo superior, dejando a vFile preparado para responder a READPE, etc.

//

// Está pensado para seleccionar un subgrupo de ítems y recorrerlo de fin a principio, por ello devuelve la posición final del grupo. Si

// se desea dejar situado para leer el siguiente elemento, úsese SEGTT

//

//

// Parámetros Formato completo

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//           lLong: Longitud de clave significativa que se toma

//

//

// Parámetros Formato compacto

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// Retorno

//  0: Error de proceso (No encontrado...)

// >0: Índice en memoria-clave + próximo inferior (+1), formato 1..N

//-----------------------------------------------------------------------------------

long SETGT(const void *vCLVp, long lLong)

long SETGT(const void *vCLVp)

 

long SETGT(const char *cLF, const void *vCLVp, long lLong)

long SETGT(const char *cLF, const void *vCLVp)

 

 

//-----------------------------------------------------------------------------------

// Método SETGTT

//

// Descripción: Sitúa en el índice de memoria-clave + próximo superior, dejando a SRRCW preparado para responder a READE, etc.

//

// La rutina deja situado el índice de lectura en el elemento siguiente al último que hubiera de clave igual a la indicada. Si por el

// contrario se desea seleccionar un subgrupo de ítems y recorrerlo de fin a principio, utilicese SETGT que, precisamente con esa

// intención, deja situado el índice al final de un grupo

//

// Parámetros Formato completo

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//           lLong: Longitud de clave significativa que se toma

//

//

// Parámetros Formato compacto

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// Retorno

//  0: Error de proceso (No encontrado...)

// >0: Índice en memoria-clave + próximo inferior (+1), formato 1..N

//-----------------------------------------------------------------------------------

long SETGTT(const void *vCLVp, long lLong)

long SETGTT(const void *vCLVp)

 

long SETGTT(const char *cLF, const void *vCLVp, long lLong)

long SETGTT(const char *cLF, const void *vCLVp)

 

 

//----------------------------------------------------------------------------------

// Método SETLL

//

// Descripción: Sitúa en el índice de memoria-clave + próximo inferior (+ 1) o en el índice exacto del ítem, dejando a vFile preparado

//              para responder a READE, etc.

//

//

// Parámetros Formato completo

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//           lLong: Longitud de clave significativa que se toma

//

//

// Parámetros Formato compacto

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// Retorno

//  0: Error de proceso (No encontrado...)

// >0: Índice en memoria-clave + próximo inferior (+1), formato 1..N

//-----------------------------------------------------------------------------------

 

long SETLL(const void *vCLVp, long lLong)

long SETLL(const void *vCLVp)

 

long SETLL(const char *cLF, const void *vCLVp, long lLong)

long SETLL(const char *cLF, const void *vCLVp)

 

                                                                                      ________

 

 

C.2.2.3.5.2 Grupo lectura (READ...)

 

//-----------------------------------------------------------------

// Método READ

//

// DESCRIPCION: Recupera un Ítem de Memoria Secuencialmente, como los elementos están ordenados por clave, una

// lectura secuencial devuelve los ítems ordenados.

//

//

// PARAMETROS.: Formato completo

//

// (entrada) iINDIp: Índice secuencial recuperación (IMPORTANTE: formato 1..N)

// (salida ) *vDato: Datos del Item

//           *vClav: Clave del Item

//

//

// PARAMETROS.: Formato compacto

//

// (entrada) iINDIp: Índice secuencial recuperación (IMPORTANTE: formato 1..N RPG)

// (salida ) *vDato: Datos del Ítem

//

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// RETORNO....:

// 0: Item leído satisfactoriamente

// 1: Error de Proceso (No encontrado(EOF), ...)

//

//-----------------------------------------------------------------

short int READ(long lINDIp, void *vDato, void *vClav)

short int READ(long lINDIp, void *vDato)

 

short int READ(const char *cLF, long lINDIp, void *vDato, void *vClav)

short int READ(const char *cLF, long lINDIp, void *vDato)

 

 

//-----------------------------------------------------------------------------------

// Método READE

//

// Descripción: Recupera+ un ítem de memoria, manteniendo clave igual

//

//

// Parámetros Formato completo

//

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//           lLong: Longitud de clave significativa que se toma

// (salida) *vDato: Datos del ítem

//          *vClav: Valor de clave completo asociado

//

//

// Parámetros Formato compacto

//

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//           lLong: Longitud de clave significativa que se toma

// (salida) *vDato: Datos del ítem

//

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// Retorno

//         0: Error de proceso (No encontrado...)

//         >0: Índice en memoria-clave de ítem encontrado + 1, formato 1..N, posición de próxima lectura, se archiva en la variable

//             global lINDI/W para uso interno posterior en +READE, etc.

//

// Importante: Si se desean ciclos de READE y READPE NO OLVIDAR EMITIR entre cada uno un reposicionado para cambiar

//             la orientación interna

//

//-----------------------------------------------------------------------------------

long READE(const void *vCLVp, long lLong, void *vDato, void *vClav)

long READE(const void *vCLVp, long lLong, void *vDato)

 

long READE(const char *cLF, const void *vCLVp, long lLong, void *vDato, void *vClav)

long READE(const char *cLF, const void *vCLVp, long lLong, void *vDato)

 

 

//-----------------------------------------------------------------------------------

// Método READPE

//

// Descripción: Recupera- un ítem de memoria, manteniendo clave igual

//

//

// Parámetros Formato completo

//

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//           lLong: Longitud de clave significativa que se toma

// (salida) *vDato: Datos del ítem

//          *vClav: Valor de clave completo asociado

//

//

// Parámetros Formato compacto

//

// (entrada) vCLVp: Clave (parcial) del ítem a situar

//           lLong: Longitud de clave significativa que se toma

// (salida) *vDato: Datos del ítem

//

//

// Además de las versiones con nombre, para ficheros explícitos o lógicos

//

//

// Retorno

//           -1: Error de proceso (No encontrado...)

//          >=0: Índice en memoria-clave de ítem encontrado - 1, formato 1..N, posición de próxima lectura, se archiva en la variable

//               global lINDI/W para uso interno posterior en +READPE, etc.

//

// Importante: Si se desean ciclos de READE y READPE NO OLVIDAR EMITIR entre cada uno un reposicionado para

//             cambiar la orientación interna

//

//-----------------------------------------------------------------------------------

long READPE(const void *vCLVp, long lLong, void *vDato, void *vClav)

long READPE(const void *vCLVp, long lLong, void *vDato)

 

long READPE(const char *cLF, const void *vCLVp, long lLong, void *vDato, void *vClav)

long READPE(const char *cLF, const void *vCLVp, long lLong, void *vDato)

 

 

                                                                                      ________

 

 

C.2.2.3.5.3 Ejemplos de posicionamiento y lectura

 

                                                                                      ________


C.2.2.3.5.3.1 El posicionamiento SETLL y la lectura por clave igual READE


Multitud de algoritmos precisan de procedimientos que constan de un posicionado por clave y un ciclo de lectura por clave, algo que gráficamente podemos ver a continuación:

 

 

 

 

Las instrucciones concretas de este ejemplo serían:

 

 

Posicionamiento

 

. . .

 

// Pasa claves

 

sW = KiWrite->Text;

KD.K.li = ALFACONV->s2l(sW);

SRRCAL_lLexi(&KD.K.li);

 

sW = KjWrite->Text;

KD.K.lj = ALFACONV->s2l(sW);

SRRCAL_lLexi(&KD.K.lj);

 

 

// Situa ítem

 

lresul = wFILE->SETLL(&KD);

 

lNRead_PF = lresul;

iW = lresul;

NRead_PF->Text = iW.ToString();

 

 

. . .

 

 

Lectura

 

 

. . .

 

 

// Pasa clave

 

sW = KiWrite->Text;

li = ALFACONV->s2l(sW);

SRRCAL_lLexi(&li);

 

 

// Lee ítem

 

lresul = wFILE->READE(&li, sizeof(long), &KD);

if (lresul <= 0) [ break ];

 

 

// Pasa resultados

 

SRRCAL_lLexi(&KD.K.li);

iW = KD.K.li;

KiChain->Text = iW.ToString();

 

. . .

 

                                                                                      ________

 

 

Este ejemplo ficticio sólo consiste en un posicionamiento y una lectura, en situaciones reales el READE estaría inmerso en un bucle que se rompería al agotar la lectura por clave igual. Se han presentado en el libro diversos casos de este tipo de tratamiento referidos al uso directo de SRRCW, que se pueden extrapolar directamente al uso bajo wFile y que en esencia consistirían en implementaciones tipo:

 

 

// Situa ítem

 

lresul = wFILE->SETLL(&KD);

 

. . .

// Ciclo de lectura

 

for (;;)

{

 . . .

 

 

 lresul = wFILE->READE(&li, sizeof(long), &KD);

 if (lresul <= 0) break;

 

 . . .

}

 

                                                                                      ________

 

 

 

C.2.2.3.5.3.2 El posicionamiento SETGT y la lectura por clave igual hacia atrás READPE

 

 

En otros casos, la situación exige situarse al final de un grupo y leerlo hacia atrás por clave, lo que gráficamente se muestra ahora:

 

 

 

 

 

Y  las instrucciones asociadas serían:

 

. . .

 

lresul = wFILE->SETGT(&li, sizeof(long));

 

. . .

 

 

lresul = wFILE->READPE(&li, sizeof(long), &KD);

 

if (lresul < 0) [break];

else

{

 // Pasa resultados

 

 SRRCAL_lLexi(&KD.K.li);

 iW = KD.K.li;

 KiChain->Text = iW.ToString();

 

. . .

 

siendo el resto como en el caso del SETLL y el READE.

 

Es importante señalar que el control de parada es lresul < 0 en vez de <= 0 como en el caso del READE pues la variable de salida siempre se refiere al índice que se emplearía en la lectura siguiente a la actual.

 

                                                                                      ________

 

 

C.2.2.3.5.3.3 El posicionamiento SETGTT y la lectura secuencial READ

 

 

También es habitual encontrarse en situaciones en donde es necesario situarse después de un grupo y a continuación leer el fichero hasta su agotamiento, lo que gráficamente se muestra ahora:

 

 

 

 

 

Cuyas instrucciones asociadas serían:

 

 . . .

 

 

 // Situa

 

 lresul = wFILE->SETGTT(&li, sizeof(long));

 

 lNRead_PF = lresul;

 

 . . .

 

 

 // Lee ítem

 

 er = wFILE->READ(lNRead_PF, &KD);

 if (er) [break];

 else

 {

  // Pasa resultados

 

  SRRCAL_lLexi(&KD.K.li);

  iW = KD.K.li;

  KiChain->Text = iW.ToString();

 

 . . .

 

Siendo el resto como en el caso del SETLL y el READE.

 

 

Un importante caso particular es la lectura secuencial completa de un fichero, que se implementaría como sigue:

 

 . . .

 for(i=1;;++i)

 {

  er = wFILE->READ(i, &KD)

  if (er) break;

  . . .

 }

                                                                                      ________

 

 

 

C.2.2.3.6 Extensiones de base de datos. CPY y DUP

 

//------------------------------------------------------------------------------------

//

// Función: CPY

//

// Descripción: Copia de registros. Deben proporcionarse nombres de ficheros "físicos"

//              base, aunque el proceso duplicará las operaciones a la BD relacionada

//

// Parámetros:

// (entrada) cORG: Nombre del fichero físico origen

//           cDES: Nombre del fichero físico destino

//           iREP: 0/1 Borrar destino (*dft 1)

//

// Retorno:

// >=0: Contador de registros copiados

//  <0: Error de proceso

//-----------------------------------------------------------------------------------

long CPY(const char *cORG, const char *cDES, short int iREP)

long CPY(const char *cORG, const char *cDES)

 

 

//-----------------------------------------------------------------------------------

//

// Función: DUP

//

// Descripción: Duplica una base de datos virtual

//

// Parámetros:

// (entrada) cORG: Nombre del fichero origen

//           cDES: Nombre del fichero destino

//

// Retorno:

//  0: Error de proceso

// >0: NID de cDES

//

//-----------------------------------------------------------------------------------

long DUP(const char *cORG, const char *cDES)

long DUP(const char *cORG, const char *cDES)

 

                                                                                      ________

 

 

C.2.2.3.7 Persistencia de datos. RSTF y SAVF


//-----------------------------------------------------------------------------------

//

// Función: RSTF

//

// Descripción: Restaura salva de registros desde soporte físico cSAVF.DAT

//

// Parámetros:

// (entrada) cSAVF: Nombre del fichero origen

//

// Además de la versión con nombre de fichero explícito

//

// Retorno:

//               >=0: Contador de registros copiados

//               <0: Error de proceso

//

//-----------------------------------------------------------------------------------

long RSTF(const char *cSAVF)

 

long RSTF_NAME(const char *cName)

 

//-----------------------------------------------------------------------------------

//

// Función: SAVF

//

// Descripción: Salva registros a soporte físico cSAVF.DAT

//

// Parámetros:

// (entrada) cSAVF: Nombre del fichero físico destino

//

// Además de la versión con nombre de fichero explícito

//

// Retorno:

//               >=0: Contador de registros copiados

//                <0: Error de proceso

//

//------------------------------------------------------------------------------------

long SAVF(const char *cSAVF)

 

long SAVF_NAME(const char *cName)

 

 

 

Gráficamente, el resultado de aplicar RSTF se vería como sigue:

 

 

 

 

 

Con las instrucciones asociadas siguientes:

 

 

RSTF - Restauración

 

System::Void Rstf_Click(System::Object * sender, System::EventArgs * e)

{

 Int32 iW = 0; // Wk.Paso de resultados(string)

 

 iW = wFILE->RSTF("WFILE");

 

 Ncopy->Text = iW.ToString();

 

 . . .

 

 

 SAVF - Salvado

 

System::Void SAVF_Click(System::Object * sender, System::EventArgs * e)

{

 Int32 iW = 0; // Wk.Paso de resultados(string)

 

 iW = wFILE->SAVF("WFILE");

 

 Ncopy->Text = iW.ToString();

 

 return;

}

 

                                                                                      ________

 

 

C.2.2.3.8 Grupo informativo y de control. INF, NAME y NID

 

//----------------------------------------------------------------------------------

// Método INF

//

// DESCRIPCION: Recupera información estadística de un fichero

//

// PARAMETROS.:

// (entrada)  cLF : Nombre de fichero solicitado (En versiones con nombre)

// (salida ) iDIMC: Tamaño clave

//           lDimD: Tamaño datos

//          lNITEM: Nºde items archivados (, de los que)

//          lBAJAS: (es el)Nºde items que son baja (y )

//          lNIDD : (es el)Nºde items que aún pueden agregarse

//

// Además de la versión para lógicos (o ficheros con nombre asignado manualmente), que incluye el nombre de éste

//

//

// RETORNO....:

//               0: Información recuperada satisfactoriamente

//               1: Error de Proceso (No encontrado)

//

//----------------------------------------------------------------------------------

short int INF(int *iDimCp, long *lDimDp, long *lNITEMp, long *lBAJASp, long *lNIDDp)

short int INF(const char *cLF, int *iDimCp, long *lDimDp, long *lNITEMp, long *lBAJASp, long *lNIDDp)

 

 

 

Este método es el que alimenta el cuadro de estadísticas del programa ejemplo, una de cuyas imágenes retomamos aquí para ilustración:

 

 

 

 

La instrucción se invoca como sigue a continuación:

 

 

System::Void Estadisticas_Click(System::Object * sender, System::EventArgs * e)

{

 short int er = 0; // Control de errores

 Int32 iW = 0; // Wk.Paso de nº(string)

 

 er = wFILE->INF(&iDimC, &lDimD, &lNitems, &lNBajas, &lNidd);

 

 iW = iDimC;

 DimC->Text = iW.ToString();

 

 iW = lDimD;

 DimD->Text = iW.ToString();

 

 iW = lNitems;

 Nitems->Text = iW.ToString();

 

 iW = lNBajas;

 Bajas->Text = iW.ToString();

 

 iW = lNitems - lNBajas;

 Neto->Text = iW.ToString();

 

 return;

}

 

 

 

//----------------------------------------------------------------------------------

//

// Método Name

//

// Descripción: Recupera el Name asociado al fichero en memoria

//

//----------------------------------------------------------------------------------

char *Name()

char *Name(const char *cName)

 

 

 

//----------------------------------------------------------------------------------

//

// Método NID

//

// Descripción: Recupera el NID asociado al fichero en memoria

//

// Además de la versión para lógicos (o ficheros con nombre asignado manualmente), que incluye el nombre de éste

//

// Retorno

//           0: Error de proceso

//         >0: NID solicitado

//

//-----------------------------------------------------------------------------------

long NID()

long NID(const char *cLF)

 

                                                                                      ________

 

 

 

C.2.2.3.9 Grupo emulación pilas (LIFO)



                                                                                      ________

 

 

C.2.2.3.9.1 El programa de muestra PruebasWpila

 

Para este grupo PruebasWfile dispone de un botón que invoca un programa dedicado en exclusiva a mostrar el funcionamiento de las pilas.

 

El programa es PruebasWpila cuya imagen es

 

 

 



                                                                                      ________

 

 

 

C.2.2.3.9.2 Creación de pilas. NEW y LIFO_NEW

 

Para crear pilas o colas, se dispone bien de los métodos NEW

 

wFile(const char *cName, const char *cOpci, long lDimD, long lMaxNreg)

wFile(const char *cName, const char *cOpci, long lDimD)

 

 

 

Como en el ejemplo siguiente extraído precisamente del programa PruebasWpila

 

 

 . . .

 

 static const long lSize = 512; // Longtud *dft wFile's

 

 . . .

 

 public __gc class Form1 : public System::Windows::Forms::Form

 {

  private: static wFile::wFile *wPILA = new wFile::wFile("WPILA", "P", lSize);

 

 . . .

 

Que se invoca al cargar el formulario del programa, o bien de los métodos generadores adicionales para pilas, que permiten añadir ficheros adicionales, de tipo pila, a una clase ya existente:

 

long LIFO_NEW(const char *cName, long lDimD, long lMaxNreg)

long LIFO_NEW(const char *cName, long lDimD)

 

                                                                                      ________

 

 

C.2.2.3.9.3 Aplicación de RSTF a una pila


Para las pilas y colas se pueden emitir los métodos vistos, como por ejemplo el RSTF como se ilustra en la imagen

 

 

 

 

Y que se implementa en el botón RSTF como sigue

 

. . .

 

// Restaura datos

 

iW = wPILA->RSTF_NAME("WPILA");

 

Ncopy->Text = iW.ToString();

. . .

 

                                                                                      ________

 

 

 

C.2.2.3.9.4 El desapilado. LIFO_READ

 

 

En cuanto a los métodos LIFO específicos, tenemos el desapilado, que lee el último ítem grabado (ya que como clave se emplea un estampillado inverso)

 

//---------------------------------------------------------------------------------

//

// Método LIFO_READ

//

// Descripción Lee un ítem de la pila

//

//

// Parámetros Formato completo

//

// (entrada) cName Nombre de la pila

// (salida)  vDato Datos del ítem

// (entrada) cOpci Opción 0/1 borrar elemento leído (*dft=1)

//

//

// Parámetros Formato compacto

//

// (entrada) cName Nombre de la pila

// (salida)  vDato Datos del ítem

//

// Retorno

//         0 OK

//         >0 Error de proceso

//---------------------------------------------------------------------------------

short int LIFO_READ(const char *cName, void *vDato, char cOpci)

short int LIFO_READ(const char *cName, void *vDato)

 

 

Que podemos ver gráficamente a continuación

 

 

 

Y que en PruebasWpila se implementa como

 

 

 . . .

 

 // Desapila item

 

 lresul = wPILA->LIFO_READ("WPILA", cName);

 

 iW = lresul;

 Resultado->Text = iW.ToString();

 

 . . .

                                                                                      ________

 

 

C.2.2.3.9.5 El apilado. LIFO_WRITE


La operación contraria, el apilado, es

 

//---------------------------------------------------------------------------------

//

// Método LIFO_WRIT

//

// Descripción Guarda un ítem en la pila

//

// Parámetros

// (entrada) cName Nombre de la pila

// (entrada) vDato Datos a guardar

//

// Retorno

//         0 Error de proceso

//         >0 Índice del ítem guardado

//

//-----------------------------------------------------------------------------------

long LIFO_WRIT(const char *cName, const void *vDato)

 

 

Que vemos gráficamente en la siguiente secuencia

 

 

 

 

Utilizando las instrucciones

 

 System::Void Apilar_Click(System::Object * sender, System::EventArgs * e)

 {

  long lresul = 0; // Control resultados

  String *sW; // Wk.Paso de string

 

  . . .

 

  // Pasa datos


  sW = Entrada->Text;

  cName = ALFACONV->sTOc(sW);

 

 

  // Apila item

 

  lresul = wPILA->LIFO_WRIT("WPILA", cName);

 

  . . .


                                                                                      ________



C.2.2.3.10 Grupo emulación colas (FIFO)

 

                                                                                      ________

 

 

C.2.2.3.10.1 El programa de muestra PruebasWcola


Al igual que en las pilas, para este grupo PruebasWfile dispone de un botón que llama a un programa que muestra el funcionamiento de las colas. El programa es PruebasWcola cuya imagen es

 

 

                                                                                      ________

 

 

C.2.2.3.10.2 Creación de colas. NEW y FIFO_NEW


Como se vio en el epígrafe para pilas anterior, para crear pilas o colas, se dispone bien de los métodos NEW

 

wFile(const char *cName, const char *cOpci, long lDimD, long lMaxNreg)

wFile(const char *cName, const char *cOpci, long lDimD)

 

 

 

Como en el ejemplo siguiente extraído del programa PruebasWcola

 

 

 . . .

 

 static const long lSize = 512; // Longitud *dft wFile's

 

 . . .

 

 public __gc class Form1 : public System::Windows::Forms::Form

 {

  private: static wFile::wFile *wCOLA = new wFile::wFile("WCOLA", "C", lSize);

 

 . . .

 

Que se invoca al cargar el formulario del programa, o bien de los métodos generadores adicionales para colas, que permiten añadir ficheros adicionales, de tipo cola, a una clase ya existente:

 

long FIFO_NEW(const char *cName, long lDimD, long lMaxNreg)

long FIFO_NEW(const char *cName, long lDimD)

 

                                                                                      ________

 

 

C.2.2.3.10.3 Aplicación de RSTF a una cola


También aquí se puede emitir RSTF como se ilustra en la imagen

 

 

 

Al pulsar el botón “RSTF” y que ejecuta la instrucción

 

 . . .

 

 iW = wCOLA->RSTF_NAME("WCOLA");

 

 Ncopy->Text = iW.ToString();

 

 . . .

                                                                                      ________

 

 

C.2.2.3.10.4 El desencolado. FIFO_READ

 

En cuanto a los métodos FIFO específicos, tenemos el desencolado, que lee el primer ítem grabado (ya que como clave se emplea un estampillado directo)

 

//----------------------------------------------------------------------------------

//

// Método FIFO_READ

//

// Descripción Lee un ítem de la cola

//

//

// Parámetros Formato completo

//

// (salida)  vDato Datos del ítem

// (entrada) cOpci Opción 0/1 borrar elemento leído (*dft=1)

//

//

// Parámetros Formato compacto

//

// (entrada) cName Nombre de la cola

// (salida)  vDato Datos del ítem

//

// Retorno

//           0 OK

//         >0 Error de proceso

//-----------------------------------------------------------------------------------

short int FIFO_READ(const char *cName, void *vDato, char cOpci)

short int FIFO_READ(const char *cName, void *vDato)

 

 

Que podemos ver gráficamente a continuación

 

 

 

Y que en PruebasWcola se implementa como

 

 

 . . .

 

 // Desencola item

 

 lresul = wCOLA->FIFO_READ("WCOLA", cName);

 

 iW = lresul;

 Resultado->Text = iW.ToString();

 

 . . .

 

                                                                                      ________

 

 

C.2.2.3.10.5 El encolado. FIFO_WRIT


La operación contraria, el encolado, se ejecuta con

 

//----------------------------------------------------------------------------------

// Método FIFO_WRIT

//

// Descripción Guarda un ítem en la cola

//

// Parámetros

// (entrada) cName Nombre de la cola

// (entrada) vDato Datos a guardar

//

// Retorno

//          0 Error de proceso

//         >0 Índice del ítem guardado

//

//-----------------------------------------------------------------------------------

long FIFO_WRIT(const char *cName, const void *vDato)

 

 

Que vemos gráficamente en la siguiente secuencia

 

 

 

Donde se utilizan las instrucciones

 

 System::Void Encolar_Click(System::Object * sender, System::EventArgs * e)

 {

  long lresul = 0; // Control resultados

  String *sW; // Wk.Paso de string

 

  . . .

 

  // Pasa datos

 

  sW = Entrada->Text;

  cName = ALFACONV->sTOc(sW);

 

 

  // Apila item

 

  lresul = wCOLA->FIFO_WRIT("WCOLA", cName);

 

  . . .

 

                                                                                      ________