Serie ficheros virtuales



C Ficheros virtuales

 

 

 

 

C.2.3 Manual del usuario de la clase vbFile

 

 

C.2.3.1 Lista de procedimientos por orden alfabético

 

C.2.3.2 Lista de procedimientos por grupos funcionales

 

 

C.2.3.3 Detalle de procedimientos (Por grupos funcionales)

 

 C.2.3.3.1 Funciones de gestión de objetos

 

  C.2.3.3.1.1 Creación de ficheros. vbFile, NEW, NOW y RESIZE

 

  C.2.3.3.1.2 CRTLF. Creación de lógicos (Vías de acceso suplementarias)

 

  C.2.3.3.1.3 CLRF. Vaciado de datos

 

  C.2.3.3.1.4 ERASE. Eliminación completa de un archivo o una base de datos

 

  C.2.3.3.1.5 CLOSE. Cierre de la aplicación

 

 

 

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

 

 C.2.3.3.2.1 Grupo CHAIN (Recuperación de datos por clave). CHAIN y VER

 

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

 



C.2.3.3.3 Funciones derivadas directas

 

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

 

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

 



 

C.2.3.3.4 Funciones derivadas intrínsecamente del orden

 

 C.2.3.3.4.1 Grupo posicionamiento (SETLL...)

 

 C.2.3.3.4.2 Grupo lectura (READ...)

 

 

 

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

 

C.2.3.3.6 Persistencia de datos. RSTF y SAVF

 

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

 

 

C.2.3.3.8 Pilas y colas

 

 C.2.3.3.8.1 Grupo emulación pilas (LIFO)

 

 C.2.3.3.8.2 Grupo emulación colas (FIFO)


                                                    _________

 

 

 

C.2.3.1 Lista de procedimientos por orden alfabético

 

long CHAIN(String *sClav, String *sDato)

long CHAIN(String *sDato)

long CHAIN(String *sLF, String *sClav, String *sDato)

 

String *CHAIND(String *sClav)

String *CHAINLFD(String *sLF, String *sClav)

 

short int CLOSE(void)

 

long CLRF(long *lNBAJp)

long CLRF()

 

long CLRF(String *sLF, long *lNBAJp)

long CLRF(String *sLF)

 

long CPY(String *sORG, String *sDES, short int iREP)

long CPY(String *sORG, String *sDES)

 

long CRTLF(String *sLF, int iKPOS, int iKLEN)

long CRTLF(String *sLF, String *sFILE, int iKPOS, int iKLEN)

 

long DELET(String *sClav)

long DELET(String *sLF, String *sClav)

 

long DUP(String *sORG, String *sDES)

 

short int ERASE(void)

short int ERASE(String *sName)

 

long FIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long FIFO_NEW(String *sName, long lDimD)

 

String *FIFO_READ(String *sFILE, String *sOpci)

String *FIFO_READ(String *sFILE)

 

long FIFO_WRIT(String *sFILE, String *sDato)

 

int INF_DimC(void)

int INF_DimC(String *sLF)

long INF_DimD(void)

long INF_DimD(String *sLF)

long INF_NITEM(void)

long INF_NITEM(String *sLF)

long INF_BAJAS(void)

long INF_BAJAS(String *sLF)

long INF_NETO(void)

long INF_NETO(String *sLF)

long INF_NIDD(void)

long INF_NIDD(String *sLF)

 

long LIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long LIFO_NEW(String *sName, long lDimD)

 

String *LIFO_READ(String *sFILE, String *sOpci)

String *LIFO_READ(String *sFILE)

 

long LIFO_WRIT(String *sFILE, String *sDato)

 

String *Name()

String *Name(String *sFILE)

 

long NEW(String *sName, int iDimC)

long NEW(String *sName, int iDimC, long lDimD)

long NEW(String *sName, int iDimC, long lDimD, long lMaxNreg)

 

long NID()

long NID(String *sLF)

 

long NOW(String *sName, int iDimC)

long NOW(String *sName, int iDimC, long lDimD)

long NOW(String *sName, int iDimC, long lDimD, long lMaxNreg)

 

short int READ(long lINDIp, String *sDato, String *sClav)

short int READ(long lINDIp, String *sDato)

short int READ(String *sLF, long lINDIp, String *sDato, String *sClav)

short int READ(String *sLF, long lINDIp, String *sDato)

 

String *READD(long lINDIp) // Read de datos

String *READK(long lINDIp) // Read de claves

String *READLFD(String *sLF, long lINDIp) // Read de datos para LF

String *READLFK(String *sLF, long lINDIp) // Read de claves para LF

 

long READE(String *sCLVp, long lLong, String *sDato, String *sClav)

long READE(String *sCLVp, long lLong, String *sDato)

 

long READE(String *sLF, String *sCLVp, long lLong, String *sDato, String *sClav)

long READE(String *sLF, String *sCLVp, long lLong, String *sDato)

 

String *READED(String *sCLVp, long lLong)

String *READEK(String *sCLVp, long lLong)

 

String *READELFD(String *sLF, String *sCLVp, long lLong)

String *READELFK(String *sLF, String *sCLVp, long lLong)

 

long READPE(String *sCLVp, long lLong, String *sDato, String *sClav)

long READPE(String *sCLVp, long lLong, String *sDato)

 

long READPE(String *sLF, String *sCLVp, long lLong, String *sDato, String *sClav)

long READPE(String *sLF, String *sCLVp, long lLong, String *sDato)

 

String *READPED(String *sCLVp, long lLong)

String *READPEK(String *sCLVp, long lLong)

 

String *READPELFD(String *sLF, String *sCLVp, long lLong)

String *READPELFK(String *sLF, String *sCLVp, long lLong)

 

short int REORGANIZE(void)

short int REORGANIZE(String *sFILE)

 

long RESIZ(String *sFILE, int iDimC, long lDimD, long lMaxNreg)

long RESIZ(String *sFILE, int iDimC, long lDimD)

long RESIZ(String *sFILE, long lMaxNreg)

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

long RESIZ(int iDimC, long lDimD)

long RESIZ(long lMaxNreg)

long RESIZ(String *sFILE, String *sOpci, long lDimD, long lMaxNreg)

long RESIZ(String *sFILE, String *sOpci, long lDimD)

 

long RSTF(String *sSAVF)

long RSTF_NAME(String *sFILE)

 

long SAVF(String *sSAVF)

long SAVF_NAME(String *sFILE)

 

long SETEQ(String *sCLVp, long lLong)

long SETEQ(String *sCLVp)

long SETEQ(String *sLF, String *sCLVp, long lLong)

long SETEQ(String *sLF, String *sCLVp)

 

long SETGT(String *sCLVp, long lLong)

long SETGT(String *sCLVp)

long SETGT(String *sLF, String *sCLVp, long lLong)

long SETGT(String *sLF, String *sCLVp)

 

long SETGTT(String *sCLVp, long lLong)

long SETGTT(String *sCLVp)

long SETGTT(String *sLF, String *sCLVp, long lLong)

long SETGTT(String *sLF, String *sCLVp)

 

long SETLL(String *sCLVp, long lLong)

long SETLL(String *sCLVp)

long SETLL(String *sLF, String *sCLVp, long lLong)

long SETLL(String *sLF, String *sCLVp)

 

vbFile(void)

vbFile(long lDimD)

vbFile(int iDimC, long lDimD)

vbFile(int iDimC, long lDimD, long lMaxNreg)

vbFile(String *sFILE)

vbFile(String *sFILE, long lDimD)

vbFile(String *sFILE, int iDimC, long lDimD)

vbFile(String *sFILE, int iDimC, long lDimD, long lMaxNreg)

vbFile(String *sFILE, String *sOpci, long lDimD, long lMaxNreg)

vbFile(String *sFILE, String *sOpci, long lDimD)

 

long VER(String *sClav)

long VER(String *sFILE, String *sClav)

 

long WRITE(String *sClav, String *sDato)

long WRITE(String *sDato)

long WRITE(String *sLF, String *sClav, String *sDato)

long WRITELF(String *sLF, String *sDato)

 

long UPDATE(String *sClav, String *sDato)

long UPDATE(String *sDato)

long UPDATE(String *sLF, String *sClav, String *sDato)

long UPDATELF(String *sLF, String *sDato)

 

                                                    _________

 

 

C.2.3.2 Lista de procedimientos por grupos funcionales

 

 

Funciones de gestión de objetos

 

 

// Constructores

 

vbFile(void)

vbFile(long lDimD)

vbFile(int iDimC, long lDimD)

vbFile(int iDimC, long lDimD, long lMaxNreg)

 

 

// Versiones con nombre

 

vbFile(String *sFILE)

vbFile(String *sFILE, long lDimD)

vbFile(String *sFILE, int iDimC, long lDimD)

vbFile(String *sFILE, int iDimC, long lDimD, long lMaxNreg)

 

 

// Destructor nominal y efectivo

 

vbFile::~vbFile()

short int CLOSE(void)

 

 

// Reconstructores interfaz a (SRRCW_ERASE + SRRCW_NEW)

 

long RESIZ(String *sFILE, int iDimC, long lDimD, long lMaxNreg)

long RESIZ(String *sFILE, int iDimC, long lDimD)

 

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

long RESIZ(int iDimC, long lDimD)

 

 

// Interfaz no reconstructor, se limita a cambiar el tamaño máximo de registros

 

long RESIZ(String *sFILE, long lMaxNreg)

long RESIZ(long lMaxNreg)

 

 

 

// Agregadores. Permiten añadir ficheros adicionales a una clase

 

// Agradores NEW. Si los ficheros no existe los crean, si ya existen los limpian

 

long NEW(String *sName, int iDimC)

long NEW(String *sName, int iDimC, long lDimD)

long NEW(String *sName, int iDimC, long lDimD, long lMaxNreg)

 

long LIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long LIFO_NEW(String *sName, long lDimD)

 

long FIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long FIFO_NEW(String *sName, long lDimD)

 

 

// Agregadores Now. Son condicionales, solo agregan ficheros nuevos

 

long NOW(String *sName, int iDimC)

long NOW(String *sName, int iDimC, long lDimD)

long NOW(String *sName, int iDimC, long lDimD, long lMaxNreg)

 

 

// REORGANIZE: Reorganiza un vbFile suprimiendo físicamente los elementos borrados

 

short int REORGANIZE(void)

short int REORGANIZE(String *sFILE)

 

 

 

Creación de lógicos (Vías de acceso suplementarias)

 

long CRTLF(String *sLF, int iKPOS, int iKLEN)

long CRTLF(String *sLF, String *sFILE, int iKPOS, int iKLEN)

 

 

 

Vaciado de datos

 

long CLRF(long *lNBAJp)

long CLRF()

long CLRF(String *sLF, long *lNBAJp)

long CLRF(String *sLF)

 

 

 

Eliminación completa de un archivo o una base de datos

 

short int ERASE(void)

short int ERASE(String *sName)

 

 

 

Cierre de la aplicación

 

short int CLOSE(void)

 

 

 

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

 

Recuperación de datos por clave

 

long CHAIN(String *sClav, String *sDato)

long CHAIN(String *sDato)

long CHAIN(String *sLF, String *sClav, String *sDato)

 

String *CHAIND(String *sClav)

String *CHAINLFD(String *sLF, String *sClav)

 

 

long VER(String *sClav)

long VER(String *sFILE, String *sClav)

 

 

 

Grabación de datos

 

long WRITE(String *sClav, String *sDato)

long WRITE(String *sDato)

long WRITE(String *sLF, String *sClav, String *sDato)

 

long WRITELF(String *sLF, String *sDato)

 

 

 

 

Actualización de ítem por clave

 

long UPDATE(String *sClav, String *sDato)

long UPDATE(String *sDato)

long UPDATE(String *sLF, String *sClav, String *sDato)

 

long UPDATELF(String *sLF, String *sDato)

 

 

 

Eliminación de ítem por clave

 

long DELET(String *sClav)

long DELET(String *sLF, String *sClav)

 

 

 

Posicionamiento (SETLL..)

 

long SETEQ(String *sCLVp, long lLong)

long SETEQ(String *sCLVp)

long SETEQ(String *sLF, String *sCLVp, long lLong)

long SETEQ(String *sLF, String *sCLVp)

 

long SETGT(String *sCLVp, long lLong)

long SETGT(String *sCLVp)

long SETGT(String *sLF, String *sCLVp, long lLong)

long SETGT(String *sLF, String *sCLVp)

 

long SETGTT(String *sCLVp, long lLong)

long SETGTT(String *sCLVp)

long SETGTT(String *sLF, String *sCLVp, long lLong)

long SETGTT(String *sLF, String *sCLVp)

 

long SETLL(String *sCLVp, long lLong)

long SETLL(String *sCLVp)

long SETLL(String *sLF, String *sCLVp, long lLong)

long SETLL(String *sLF, String *sCLVp)

 

 

 

Lectura (READ..)

 

short int READ(long lINDIp, String *sDato, String *sClav)

short int READ(long lINDIp, String *sDato)

short int READ(String *sLF, long lINDIp, String *sDato, String *sClav)

short int READ(String *sLF, long lINDIp, String *sDato)

 

String *READD(long lINDIp) // Read de datos

String *READK(long lINDIp) // Read de claves

String *READLFD(String *sLF, long lINDIp) // Read de datos para LF

String *READLFK(String *sLF, long lINDIp) // Read de claves para LF

 

 

long READE(String *sCLVp, long lLong, String *sDato, String *sClav)

long READE(String *sCLVp, long lLong, String *sDato)

 

long READE(String *sLF, String *sCLVp, long lLong, String *sDato, String *sClav)

long READE(String *sLF, String *sCLVp, long lLong, String *sDato)

 

String *READED(String *sCLVp, long lLong)

String *READEK(String *sCLVp, long lLong)

 

String *READELFD(String *sLF, String *sCLVp, long lLong)

String *READELFK(String *sLF, String *sCLVp, long lLong)

 

 

long READPE(String *sCLVp, long lLong, String *sDato, String *sClav)

long READPE(String *sCLVp, long lLong, String *sDato)

 

long READPE(String *sLF, String *sCLVp, long lLong, String *sDato, String *sClav)

long READPE(String *sLF, String *sCLVp, long lLong, String *sDato)

 

String *READPED(String *sCLVp, long lLong)

String *READPEK(String *sCLVp, long lLong)

 

String *READPELFD(String *sLF, String *sCLVp, long lLong)

String *READPELFK(String *sLF, String *sCLVp, long lLong)

 

 

 

Extensiones de base de datos. CPY y DUP

 

long CPY(String *sORG, String *sDES, short int iREP)

long CPY(String *sORG, String *sDES)

 

long DUP(String *sORG, String *sDES)

 

 

 

Persistencia de datos. RSTF y SAVF

 

long RSTF(String *sSAVF)

long RSTF_NAME(String *sFILE)

 

 

long SAVF(String *sSAVF)

long SAVF_NAME(String *sFILE)

 

 

 

 

Grupo informativo y de control. INF, NAME y NID

 

int INF_DimC(void)

int INF_DimC(String *sLF)

long INF_DimD(void)

long INF_DimD(String *sLF)

long INF_NITEM(void)

long INF_NITEM(String *sLF)

long INF_BAJAS(void)

long INF_BAJAS(String *sLF)

long INF_NETO(void)

long INF_NETO(String *sLF)

long INF_NIDD(void)

long INF_NIDD(String *sLF)

 

 

long NID()

long NID(String *sLF)

 

 

String *Name()

String *Name(String *sFILE)

 

 

 

Pilas y colas

 

// Constructores para pilas y colas s/ sOpci: C=Cola P=Pila

 

vbFile(String *sFILE, String *sOpci, long lDimD, long lMaxNreg)

vbFile(String *sFILE, String *sOpci, long lDimD)

 

 

// Reconstructores interfaz a SRRCW_FIFO_NEW (colas), SRRCW_LIFO_NEW (pilas) s/ sOpci

 

long RESIZ(String *sFILE, String *sOpci, long lDimD, long lMaxNreg)

long RESIZ(String *sFILE, String *sOpci, long lDimD)

 

 

 

Métodos específicos para pilas (LIFO)

 

long LIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long LIFO_NEW(String *sName, long lDimD)

 

String *LIFO_READ(String *sFILE, String *sOpci)

String *LIFO_READ(String *sFILE)

 

long LIFO_WRIT(String *sFILE, String *sDato)

 

 

 

 

Métodos específicos para colas (FIFO)

 

long FIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long FIFO_NEW(String *sName, long lDimD)

 

String *FIFO_READ(String *sFILE, String *sOpci)

String *FIFO_READ(String *sFILE)

 

long FIFO_WRIT(String *sFILE, String *sDato)

 

                                                    _________ 

 

 

C.2.3.3 Detalle de procedimientos (Por grupos funcionales)

 

Para describirlos se utilizará el programa PruebasV como interfaz de vBFile del que vemos ahora una imagen de muestra

 

 

 

Los datos de partida (restaurados con el botón RSTF [Método que se presenta más adelante]) son

 

 Clave 11  Datos  11

22         22

33         330

 

 

No hay un desarrollo tan completo como en PruebasWfile, pero aquellos ejemplos pueden extrapolarse donde los de PruebasV no alcancen

 

                                                    _________

 

C.2.3.3.1 Funciones de gestión de objetos

 

 

C.2.3.3.1.1 Creación de ficheros. vbFile, NEW, NOW y RESIZE

 

 

// Constructores

 

vbFile(void)

vbFile(long lDimD)

vbFile(int iDimC, long lDimD)

vbFile(int iDimC, long lDimD, long lMaxNreg)

 

 

// Versiones con nombre

 

vbFile(String *sFILE)

vbFile(String *sFILE, long lDimD)

vbFile(String *sFILE, int iDimC, long lDimD)

vbFile(String *sFILE, int iDimC, long lDimD, long lMaxNreg)

 

 

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

// Constructores para pilas y colas

// sOpci C=Cola P=Pila

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

 

vbFile(String *sFILE, String *sOpci, long lDimD, long lMaxNreg)

vbFile(String *sFILE, String *sOpci, long lDimD)

 

 

 

Veamos ahora ejemplos de codificación de constructores tomados de la cabecera de PruebasV:

 

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)

 

 

 

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

// Destructor nominal

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

vbFile::~vbFile()

 

 

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

// Destructor efectivo

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

short int CLOSE(void)

 

 

En PruebasV se incluye en la codificación de cierre de la aplicación:

 


 

Private Sub Form1_CLose(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Closed

 

Dim er As Short

 

er = PRUEBASV.CLOSE()

 

End Sub

 

 

 

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

// Reconstructores interfaz a (SRRCW_ERASE + SRRCW_NEW)

//

// -para ejecutar justo antes de operar asignando parámetros definitivos de la clase, construida "virtualmente" antes-

//

// ó a SRRCW_RESIZE para aumentar tamaño

//

// Mismos parámetros que NEW y con su mismo sentido para la instancia definitiva/operativa de la clase

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

 

// Versiones con nombre explícito

 

long RESIZ(String *sFILE, int iDimC, long lDimD, long lMaxNreg)

long RESIZ(String *sFILE, int iDimC, long lDimD)

 

 

// Interfaz no reconstructor, se limita a cambiar el tamaño máximo de registros

 

long RESIZ(String *sFILE, long lMaxNreg)

 

 

// Versiones con nombre automático

 

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

long RESIZ(int iDimC, long lDimD)

 

 

// Interfaz no reconstructor, se limita a cambiar el tamaño máximo de registros

 

long RESIZ(long lMaxNreg)

 

 

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

// Reconstructores interfaz a SRRCW_FIFO_NEW (colas), SRRCW_LIFO_NEW (pilas)

// sOpci C=Cola P=Pila

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

 

long RESIZ(String *sFILE, String *sOpci, long lDimD, long lMaxNreg)

long RESIZ(String *sFILE, String *sOpci, long lDimD)

 

 

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

// Agregadores. Permiten añadir ficheros adicionales a una clase

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

 

// Agradores NEW. Si los ficheros no existen los crean, si ya existen los limpian

 

long NEW(String *sName, int iDimC)

long NEW(String *sName, int iDimC, long lDimD)

long NEW(String *sName, int iDimC, long lDimD, long lMaxNreg)

 

long LIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long LIFO_NEW(String *sName, long lDimD)

 

long FIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long FIFO_NEW(String *sName, long lDimD)

 

 

// Agregadores Now. Son condicionales, sólo agregan ficheros nuevos

 

long NOW(String *sName, int iDimC)

long NOW(String *sName, int iDimC, long lDimD)

long NOW(String *sName, int iDimC, long lDimD, long lMaxNreg)

 

 

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

// Método REORGANIZE

//

// DESCRIPCION: Reorganiza vFile suprimiendo físicamente los elementos borrados

//

//

// PARAMETROS.: sFILE nombre de fichero explícito a reorganizar

//              (void) nombre automático

//

// RETORNO....:

//               0: O.K.

//               >0: Error de proceso

//

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

short int REORGANIZE(void)

short int REORGANIZE(String *sFILE)

 

 

El ejemplo implementado en PruebasV es:

 

Private Sub REORGANIZE_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles REORGANIZE.Click

 

Dim er As Short

 

. . .

 

 

' Reorganiza, depurando bajas

 

er = PRUEBASV.REORGANIZE("PRUEBASV")

 

. . .

 

 

                                                    _________


 

C.2.3.3.1.2 CRTLF. Creación de lógicos (Vías de acceso suplementarias)

 

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

//

// Método CRTLF

//

// Descripción: Crea una vía de acceso alternativa sobre el vFile

//

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

//

// Parámetros

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

//         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(String *sLF, int iKPOS, int iKLEN)

 

 

// Versión con nombre explícito de fichero base

 

long CRTLF(String *sLF, String *sFILE, int iKPOS, int iKLEN)

 

 

No se ha implementado en PruebasV pero puede extrapolarse del uso en wFile

 

                                                    _________

 

C.2.3.3.1.3 CLRF. Vaciado de datos

 

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

// Método CLRF

//

// DESCRIPCION: CLRPFM de un fichero

//

//

// PARAMETROS.: Formato completo

//

// (salida) lNBAJp: Nº bajas procesadas

//

//

// PARAMETROS.: Formato compacto: void

//

//

// Además de las versiones con nombre

//

//

// RETORNO....:

//                0: O.K.

//               >0: Error de proceso

//

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

 

long CLRF(long *lNBAJp)

long CLRF()

long CLRF(String *sLF, long *lNBAJp)

long CLRF(String *sLF)

 

 

En nuestro programa ejemplo CLRF se usa como sigue:

 

Private Sub CLRF_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles CLRF.Click

 

Dim lresul As Integer ' Índice resultado

 

. . .

 

 

' Limpia fichero (CLRPFM)

 

lresul = PRUEBASV.CLRF("PRUEBASV")

 

. . .

                                                    _________

 

 

C.2.3.3.1.4 ERASE. Eliminación completa de un archivo o una base de datos

 

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

// Función ERASE

//

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

//

// PARAMETROS.:

//

// (entrada) cName: Nombre del fichero solicitado

//

//

// RETORNO....:

//               0: O.K.

//               >0: Error de proceso

//

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

short int ERASE(void)

short int ERASE(String *sName)

 

                                                    _________

 

 

C.2.3.3.1.5 CLOSE. Cierre de la aplicación

 

short int CLOSE(void)

 

 

Que se utiliza en el botón de salida manual de PruebasV como sigue:

 

 

Private Sub Salir_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Salir.Click

 

Dim er As Short

 

er = PRUEBASV.CLOSE()

 

End

 

End Sub

                                                    _________



 

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

 

                                                    _________

 

C.2.3.3.2.1 Grupo CHAIN (Recuperación de datos por clave). CHAIN y VER

 

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

// Método CHAIN

//

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

//

//

// PARAMETROS.: Formato completo

//

// (entrada) sClav: Clave del Ítem

// (salida ) sDato: Datos del Ítem

//

//

// PARAMETROS.: Formato compacto

//

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

//

//

// Además de las versiones con nombre

//

//

// RETORNO....:

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

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

//                  (formato 1..N)

//

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

long CHAIN(String *sClav, String *sDato)

long CHAIN(String *sDato)

long CHAIN(String *sLF, String *sClav, String *sDato)

 

 

// Funciones tipo "get"

 

String *CHAIND(String *sClav)

 

String *CHAINLFD(String *sLF, String *sClav)

 

 

 

Que vemos utilizar ahora en PruebasV:

 

 

Si introducimos la clave ‘33’ y pulsamos el botón CHAIN

 

 

 

Se recuperan los datos asociados (‘330’)

 

 

 

Y esto se implementa como:

 

Private Sub CHAIN_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles CHAIN.Click

 

Dim lresul As Integer ' Indice resultado del write

Dim KinW As String    ' Paso de clave

Dim DoutW As String   ' Paso de datos

Dim i As Integer      ' Iterador

Dim lKin As Integer   ' Longitud de clave recibida

 

. . .

 

 

' Completa clave

 

lKin = Len(Kin.Text)

KinW = Kin.Text

 

For i = lKin To lDimC

 

KinW = KinW + " "

 

Next

 

 

' Recupera índice ítem

 

lresul = PRUEBASV.CHAIN("PRUEBASV", KinW, DoutW)

 

Nchain.Text = lresul.ToString

 

 

' Recupera ítem

 

If lresul > 0 Then

DoutW = PRUEBASV.CHAINLFD("PRUEBASV", KinW)

Kout.Text = KinW

Dout.Text = DoutW

End If

 

 

. . .

                                                    _________

 

 

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

// Método VER

//

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

//

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

//

// Supone una generación previa del fichero virtual de soporte

//

// Parámetros

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

//

//

// Además de las versiones con nombre

//

//

// Retorno

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

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

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

long VER(String *sClav)

 

long VER(String *sFILE, String *sClav)

 

 

Que se implementa en PruebasV como

 

 

Private Sub VER_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles VER.Click

 

Dim lresul As Integer ' Indice resultado

Dim KverW As String   ' Paso de clave

Dim i As Integer      ' Iterador

Dim lKver As Integer  ' Longitud de clave recibida

 

 

' Completa clave rellenando blancos de cola

 

lKver = Len(Kver.Text)

KverW = Kver.Text

 

For i = lKver To lDimC

 

KverW = KverW + " "

 

Next

 

 

' Ve item

 

lresul = PRUEBASVVER.VER("PRUEBASVVER", KverW)

 

Nver.Text = lresul.ToString

 

 

. . .

 

                                                    _________

 

 

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

 

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

// Método WRITE

//

// DESCRIPCION: Salva un Ítem a 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

//

//

// RETORNO....:

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

// >0: Índice de Ítem-Clave Guardado Satisfactoriamente (Formato 1..N)

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

long WRITE(String *sClav, String *sDato)

long WRITE(String *sDato)

long WRITE(String *sLF, String *sClav, String *sDato)

 

long WRITELF(String *sLF, String *sDato)

 

 

Que presentamos en el ejemplo

 

 

 

 

Y que se ha implementado en PruebasV así:

 

 

Private Sub WRITE_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles WRITE.Click

 

Dim lresul As Integer ' Indice resultado del write

Dim KinW As String    ' Paso de clave

Dim DinW As String    ' Paso de datos

Dim i As Integer      ' Iterador

Dim lKin As Integer   ' Longitud de clave recibida

Dim lDin As Integer   ' Longitud de datos recibida

 

. . .

 

 

' Completa clave de acceso rellenando blancos de cola

 

lKin = Len(Kin.Text)

KinW = Kin.Text

 

For i = lKin To lDimC

 

KinW = KinW + " "

 

Next

 

 

' Completa datos a grabar rellenando blancos de cola

 

lDin = Len(Din.Text)

DinW = Din.Text

 

For i = lDin To lDimD

 

DinW = DinW + " "

 

Next

 

 

' Graba item

 

lresul = PRUEBASV.WRITE("PRUEBASV", KinW, DinW)

 

Nwrite.Text = lresul.ToString

 

 

. . .

 

                                                    _________

 

 

C.2.3.3.3 Funciones derivadas directas

 

                                                    _________

 

 

C.2.3.3.3.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

//

//

// RETORNO....:

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

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

//

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

long UPDATE(String *sClav, String *sDato)

long UPDATE(String *sDato)

long UPDATE(String *sLF, String *sClav, String *sDato)

 

long UPDATELF(String *sLF, String *sDato)

 

 

 

Que podemos ver gráficamente en la secuencia siguiente:

 

 

 

Si accedemos a la posición clave ‘33’ nos encontramos con el contenido ‘330’

 

 

 

Que podemos actualizar a ‘33’ con el botón UPDATE

 

 

 

Y que podemos verificar volviendo a acceder con la clave

 

 

 

Y que se implementa en PruebasV como:

 

Private Sub UPDATE_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles UPDATE.Click

 

Dim lresul As Integer ' Indice resultado

Dim KinW As String    ' Paso de clave

Dim DinW As String    ' Paso de datos

Dim i As Integer      ' Iterador

Dim lKin As Integer   ' Longitud de clave recibida

Dim lDin As Integer   ' Longitud de datos recibida

 

. . .

 

 

' Completa clave rellenando blancos de cola

 

lKin = Len(Kin.Text)

KinW = Kin.Text

 

For i = lKin To lDimC

 

KinW = KinW + " "

 

Next

 

 

' Completa datos rellenando blancos de cola

 

lDin = Len(Din.Text)

DinW = Din.Text

 

For i = lDin To lDimD

 

DinW = DinW + " "

 

Next

 

 

' Actualiza ítem

 

lresul = PRUEBASV.UPDATE("PRUEBASV", KinW, DinW)

 

Nupdate.Text = lresul.ToString

 

 

. . .

                                                    _________

 

 

 

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

 

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

// Método DELET

//

// Descripción: Elimina un ítem de memoria (No confundir con un DELETE de la clase)

//

// Parámetros

// (entrada) sClav Clave del ítem

//

// Además de la versión con nombre

//

//

// Retorno

//          0 Error de proceso

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

//

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

long DELET(String *sClav)

long DELET(String *sLF, String *sClav)

 

 

Que podemos ver como:

 

 

 

Y que es implementado en PruebasV como:

 

Private Sub DELET_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles DELET.Click

 

Dim lresul As Integer ' Indice resultado

Dim KinW As String    ' Paso de clave

Dim i As Integer      ' Iterador

Dim lKin As Integer   ' Longitud de clave recibida

 

. . .

 

 

' Completa clave de acceso rellenando blancos de cola

 

lKin = Len(Kin.Text)

KinW = Kin.Text

 

For i = lKin To lDimC

 

KinW = KinW + " "

 

Next

 

 

' Elimina item

 

lresul = PRUEBASV.DELET("PRUEBASV", KinW)

 

Ndelete.Text = lresul.ToString

 

 

. . .

                                                    _________

 

 

C.2.3.3.4 Funciones derivadas intrínsecamente del orden

 

                                                    _________

 

C.2.3.3.4.1 Grupo posicionamiento (SETLL..)

 

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

// Método SETEQ

//

// Descripción: Determina la existencia en memoria de un item 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 siginificativa que se toma

//

//

// Parámetros Formato compacto

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

//

//

// Además de las versiones con nombre

//

//

// Retorno

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

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

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

long SETEQ(String *sCLVp, long lLong)

long SETEQ(String *sCLVp)

long SETEQ(String *sLF, String *sCLVp, long lLong)

long SETEQ(String *sLF, String *sCLVp)

 

 

 

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

// 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

//

//

// Retorno

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

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

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

long SETGT(String *sCLVp, long lLong)

long SETGT(String *sCLVp)

long SETGT(String *sLF, String *sCLVp, long lLong)

long SETGT(String *sLF, String *sCLVp)

 

 

Que vemos implementada en el programa PruebasV como:

 

Private Sub SETGT_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SETGT.Click

 

Dim lresul As Integer ' Índice resultado

Dim KinW As String    ' Paso de clave de posición

Dim KinWW As String   ' Extractor auxiliar de 1 posición a efectos didácticos

Dim lKin As Integer   ' Longitud de la clave leída

 

. . .

 

 

' Pasa clave (Limitada a 1 posición para esta muestra ejemplo)

 

lKin = 1

KinWW = Kin.Text

KinW = KinWW.Substring(0, 1)

 

 

' Situa en item

 

lresul = PRUEBASV.SETGT("PRUEBASV", KinW, lKin)

 

 

' Estadísticas

 

lNreg = lresul - 1

Estadisticas_Click(sender, e)

 

End Sub

 

                                                    _________

 

 

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

// Método SETGTT

//

// Descripción: Sitúa en el índice de memoria-clave + próximo superior, dejando a vFile 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, utilícese 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

//

//

// Retorno

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

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

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

long SETGTT(String *sCLVp, long lLong)

long SETGTT(String *sCLVp)

long SETGTT(String *sLF, String *sCLVp, long lLong)

long SETGTT(String *sLF, String *sCLVp)

 

 

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

// 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

//

//

// Retorno

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

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

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

long SETLL(String *sCLVp, long lLong)

long SETLL(String *sCLVp)

long SETLL(String *sLF, String *sCLVp, long lLong)

long SETLL(String *sLF, String *sCLVp)

 

 

Si nos posicionamos en el programa ejemplo introduciendo el valor parcial de clave 2 y

 

 

 

A continuación pulsamos el botón SETLL

 

 

El programa responde situándose en la posición 2 del fichero quedando preparado para responder a peticiones de lectura o de lectura por igual.

 

 

Que se implementa en el programa como:

 

 

Private Sub SETLL_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SETLL.Click

 

Dim lresul As Integer ' Índice resultado

Dim KinW As String    ' Paso de clave de posicionado

Dim i As Integer      ' Iterador

Dim lKin As Integer   ' Dimensión de la clave leída

 

. . .

 

 

' Completa clave rellenado blancos de cola

 

lKin = Len(Kin.Text)

KinW = Kin.Text

 

For i = lKin To lDimC

 

KinW = KinW + " "

 

Next

 

 

' Sitúa en ítem

 

lresul = PRUEBASV.SETLL("PRUEBASV", KinW)

 

. . .

 

                                                    _________

 

 

C.2.3.3.4.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 RPG)

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

//           *vClav: Clave del Ítem

//

//

// 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

//

//

// RETORNO....:

//               0: Item leído satisfactoriamente

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

//

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

short int READ(long lINDIp, String *sDato, String *sClav)

short int READ(long lINDIp, String *sDato)

short int READ(String *sLF, long lINDIp, String *sDato, String *sClav)

short int READ(String *sLF, long lINDIp, String *sDato)

 

 

// Versiones para Visual Basic, al estilo de funciones get

 

String *READD(long lINDIp) // Read de datos

String *READK(long lINDIp) // Read de claves

String *READLFD(String *sLF, long lINDIp) // Read de datos para LF

String *READLFK(String *sLF, long lINDIp) // Read de claves para LF

 

 

 

En el programa ejemplo, si después de restaurar pulsamos el botón READ

 

 

El programa responde con los datos de la primera posición e indica el siguiente registro a leer (El nº 2 en este caso)

 

 

La implementación asociada es:

 

Private Sub READ_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles READ.Click

 

Dim er As Short ' Control de errores

Dim D As String ' Variable dummy lectura

 

 

' Inz

 

Kout.Text = " "

Dout.Text = " "

lNreg = lNreg + 1

 

 

' Lee ítem lNreg

 

er = PRUEBASV.READ("PRUEBASV", lNreg, D)

 

If er > 0 Then

 lNreg = 0

Else

 Kout.Text = PRUEBASV.READLFK("PRUEBASV", lNreg)

 Dout.Text = PRUEBASV.READLFD("PRUEBASV", lNreg)

End If

 

 

. . .

 

                                                    _________

 

 

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

// 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

//

//

// 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 consecutivos de READE y READPE NO OLVIDAR EMITIR entre cada uno un reposicionado para cambiar la

//             orientación interna

//

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

long READE(String *sCLVp, long lLong, String *sDato, String *sClav)

long READE(String *sCLVp, long lLong, String *sDato)

 

long READE(String *sLF, String *sCLVp, long lLong, String *sDato, String *sClav)

long READE(String *sLF, String *sCLVp, long lLong, String *sDato)

 

 

// Versiones para Visual Basic, al estilo de funciones get

 

String *READED(String *sCLVp, long lLong)

String *READEK(String *sCLVp, long lLong)

 

String *READELFD(String *sLF, String *sCLVp, long lLong)

String *READELFK(String *sLF, String *sCLVp, long lLong)

 

 

Si tras el ejemplo del SETLL solicitamos un READE por la clave parcial 2

 

 

El programa responde con los datos asociados del siguiente registro.

 

 

Si bien se habría obtenido la misma respuesta con un READ simple, la diferencia estriba en que si se emite un nuevo READE, como se agotan los datos de la misma clave, se responde con fin de fichero

 

 

Con el READ se leerían el resto de datos hasta el agotamiento del fichero

 

 

La implementación correspondiente sigue a continuación

 

Private Sub READE_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles READE.Click

 

Dim lresul As Integer   'Indice resultado

Dim KinW As String      'Clave parcial reade

Dim KinWW As String     'Paso de KinW

Dim DoutW As String     'Dummy reade

Dim lKin As Integer = 1 'Longitud parcial clv

 

. . .

 

 

' Pasa clave

 

KinWW = Kin.Text

KinW = KinWW.Substring(0, lKin)

 

 

' Recupera ítem

 

lresul = PRUEBASV.READE("PRUEBASV", KinW, lKin, DoutW)

 

If lresul > 0 Then

 Kout.Text = PRUEBASV.READLFK("PRUEBASV", lresul - 1)

 Dout.Text = PRUEBASV.READLFD("PRUEBASV", lresul - 1)

End If

 

. . .

                                                    _________

 

 

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

// 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

//

//

// 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 consecutivos de READE y READPE, NO OLVIDAR EMITIR entre cada uno un reposicionado para cambiar la

//             orientación interna

//

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

long READPE(String *sCLVp, long lLong, String *sDato, String *sClav)

long READPE(String *sCLVp, long lLong, String *sDato)

 

long READPE(String *sLF, String *sCLVp, long lLong, String *sDato, String *sClav)

long READPE(String *sLF, String *sCLVp, long lLong, String *sDato)

 

 

// Versiones para Visual Basic, al estilo de funciones get

 

String *READPED(String *sCLVp, long lLong)

String *READPEK(String *sCLVp, long lLong)

 

String *READPELFD(String *sLF, String *sCLVp, long lLong)

String *READPELFK(String *sLF, String *sCLVp, long lLong)

 

 

En PruebasV se implementa así:

 

Private Sub READPE_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles READPE.Click

 

Dim lresul As Integer   'Indice resultado

Dim KinW As String      'Clave parcial readpe

Dim KinWW As String     'Paso de KinW desde campo de entrada

Dim DoutW As String     'Dummy reade

Dim lKin As Integer = 1 'Longitud parcial clv

 

. . .

 

 

' Pasa clave

 

KinWW = Kin.Text

KinW = KinWW.Substring(0, lKin)

 

 

' Recupera item

 

lresul = PRUEBASV.READPE("PRUEBASV", KinW, lKin, DoutW)

 

If lresul >= 0 Then

 Kout.Text = PRUEBASV.READLFK("PRUEBASV", lresul + 1)

 Dout.Text = PRUEBASV.READLFD("PRUEBASV", lresul + 1)

End If

 

End Sub

 

                                                    _________

 

 

C.2.3.3.5 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) sORG: Nombre del fichero físico origen

//           sDES: 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(String *sORG, String *sDES, short int iREP)

long CPY(String *sORG, String *sDES)

 

 

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

//

// Función: DUP

//

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

//

// Parámetros:

// (entrada) sORG: Nombre del fichero origen

//           sDES: Nombre del fichero destino

//

// Retorno:

//          0: Error de proceso

//         >0: NID de cDES

//

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

long DUP(String *sORG, String *sDES)

 

                                                    _________

 

 

C.2.3.3.6 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

//

// Retorno:

//         >=0: Contador de registros copiados

//          <0: Error de proceso

//

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

long RSTF(String *sSAVF)

 

 

// Versión con nombre explícito

 

long RSTF_NAME(String *sFILE)

 

 

 

El ejemplo de PruebasV es:

 

 

 

El botón RSTF permite restaurar los datos de partida:

 

 Clave 11  Datos  11

22                  22

33                  330

 

 

Y se implementa como:

 

Private Sub RSTF_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles RSTF.Click

 

Dim lresul As Integer ' Indice resultado

 

lresul = PRUEBASV.RSTF_NAME("PRUEBASV")

 

Ncpy.Text = lresul.ToString

 

 

' Estadísticas

 

Estadisticas_Click(sender, e)

 

End Sub

 

                                                    _________

 

 

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

//

// Función: SAVF

//

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

//

// Parámetros:

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

//

// Retorno:

//               >=0: Contador de registros copiados

//               <0: Error de proceso

//

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

long SAVF(String *sSAVF)

 

 

// Versión con nombre explícito

 

long SAVF_NAME(String *sFILE)

 

 

 

Que vemos utilizar en el programa ejemplo a continuación:

 

 

Private Sub SAVF_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SAVF.Click

 

Dim lresul As Integer ' Indice resultado

 

lresul = PRUEBASV.SAVF_NAME("PRUEBASV")

 

Ncpy.Text = lresul.ToString

 

End Sub

 

                                                    _________

 

 

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

 

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

// Métodos INF

//

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

//

// PARAMETROS.:

// (salida ) iDIMC: Tamaño clave

//           lDimD: Tamaño datos

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

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

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

//

// Además de las versiones con nombre

//

//

// RETORNO....:

//               0: Información recuperada satisfactoriamente

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

//

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

int INF_DimC(void)

int INF_DimC(String *sLF)

long INF_DimD(void)

long INF_DimD(String *sLF)

long INF_NITEM(void)

long INF_NITEM(String *sLF)

long INF_BAJAS(void)

long INF_BAJAS(String *sLF)

long INF_NETO(void)

long INF_NETO(String *sLF)

long INF_NIDD(void)

long INF_NIDD(String *sLF)

 

 

En el programa ejemplo permite cargar las casillas de estado, y su utilización es como sigue:

 

Private Sub Estadisticas_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Estadisticas.Click

 

Dim lDimC As Integer     ' Variable receptora “Dimensión Clave”

Dim lDimD As Integer     ' Variable receptora “Dimensión Datos”

Dim lNITEM As Integer    ' Variable receptora “NºItems bruto del fichero”

Dim lBAJAS As Integer    ' Variable receptora “Nºde bajas”

Dim lNETO As Integer     ' NºItems neto = Bruto - Bajas

Dim lNidD As Integer     ' NºDe Nids disponible

Dim lresul As Integer    ' Indice resultado

Dim lNextRead As Integer ' NºIndice lectura siguiente

 

 

' Estadísticas

 

lDimC = PRUEBASV.INF_DimC("PRUEBASV")

lDimD = PRUEBASV.INF_DimD("PRUEBASV")

lNITEM = PRUEBASV.INF_NITEM("PRUEBASV")

lBAJAS = PRUEBASV.INF_BAJAS("PRUEBASV")

lNETO = PRUEBASV.INF_NETO("PRUEBASV")

lNidD = PRUEBASV.INF_NIDD("PRUEBASV")

 

NReg.Text = lNreg.ToString

DimC.Text = lDimC.ToString

DimD.Text = lDimD.ToString

NITEM.Text = lNITEM.ToString

BAJAS.Text = lBAJAS.ToString

Neto.Text = lNETO.ToString

NIDD.Text = lNidD.ToString

 

lNextRead = lNreg + 1

NReg.Text = lNextRead.ToString

 

End Sub

                                                    _________

 

 

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

//

// Método NID

//

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

//

// Retorno

//           0: Error de proceso

//          >0: NID solicitado

//

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

long NID()

long NID(String *sLF)

 

 

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

//

// Método Name

//

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

//

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

String *Name()

String *Name(String *sFILE)

 

                                                    _________

 

 

C.2.3.3.8 Pilas y colas

 

// Constructores para pilas y colas s/ sOpci: C=Cola P=Pila

 

vbFile(String *sFILE, String *sOpci, long lDimD, long lMaxNreg)

vbFile(String *sFILE, String *sOpci, long lDimD)

 

 

 

// Reconstructores interfaz a SRRCW_FIFO_NEW (colas), SRRCW_LIFO_NEW (pilas) s/ sOpci

 

long RESIZ(String *sFILE, String *sOpci, long lDimD, long lMaxNreg)

long RESIZ(String *sFILE, String *sOpci, long lDimD)

 

                                                    _________

 

 

C.2.3.3.8.1 Métodos específicos para el grupo de emulación de pilas (LIFO)

 

long LIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long LIFO_NEW(String *sName, long lDimD)

 

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

//

// Método LIFO_READ

//

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

//

//

// Parámetros Formato completo

//

// (entrada) sFILE Nombre de la pila

// (salida)  sDato Datos del ítem

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

//

//

// Parámetros Formato compacto

//

// (entrada) sFILE Nombre de la pila

// (salida)  sDato Datos del ítem

//

// Retorno

//           0 OK

//         >0 Error de proceso

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

String *LIFO_READ(String *sFILE, String *sOpci)

String *LIFO_READ(String *sFILE)

 

 

Como en el ejemplo de PruebasV:

 

Private Sub Desapilar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Desapilar.Click

 

' Desapila ítem

 

Pila.Text = PRUEBASVPILA.LIFO_READ("PRUEBASVPILA")

 

. . .

 

                                                    _________

 

 

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

// Método LIFO_WRIT

//

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

//

// Parámetros

// (entrada) sFILE Nombre de la pila

// (entrada) sDato Datos a guardar

//

// Retorno

//         0 Error de proceso

//         >0 Índice del ítem guardado

//

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

long LIFO_WRIT(String *sFILE, String *sDato)

 

 

Que vemos implementado en el ejemplo de PruebasV:

 

Private Sub Apilar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Apilar.Click

 

Dim lresul As Integer ' Indice resultado

Dim PilaW As String

Dim i As Integer      ' Iterador

Dim lPila As Integer

 

 

' Completa datos rellenado blancos de cola

 

lPila = Len(Pila.Text)

PilaW = Pila.Text

 

For i = lPila To lDimD

 

PilaW = PilaW + " "

 

Next

 

 

' Graba item

 

lresul = PRUEBASVPILA.LIFO_WRIT("PRUEBASVPILA", PilaW)

 

 

. . .

                                                    _________

 

 

 

C.2.3.3.8.2 Métodos específicos para el grupo emulación colas (FIFO)

 

long FIFO_NEW(String *sName, long lDimD, long lMaxNreg)

long FIFO_NEW(String *sName, long lDimD)

 

 

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

//

// Método FIFO_READ

//

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

//

//

// Parámetros Formato completo

//

// (entrada) sFILE Nombre de la cola

// (salida)  sDato Datos del ítem

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

//

//

// Parámetros Formato compacto

//

// (entrada) sFILE Nombre de la cola

// (salida)  vDato Datos del ítem

//

// Retorno

//          0 OK

//         >0 Error de proceso

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

String *FIFO_READ(String *sFILE, String *sOpci)

String *FIFO_READ(String *sFILE)

 

 

Como en PruebasV:

 

Private Sub Desencolar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Desencolar.Click

 

 

' Desencola ítem

 

Cola.Text = PRUEBASVCOLA.FIFO_READ("PRUEBASVCOLA")

 

. . .

                                                    _________

 

 

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

// Método FIFO_WRIT

//

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

//

// Parámetros

// (entrada) sFILE Nombre de la cola

// (entrada) sDato Datos a guardar

//

// Retorno

//         0 Error de proceso

//         >0 Índice del ítem guardado

//

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

long FIFO_WRIT(String *sFILE, String *sDato)

 

 

Que se implementa en PruebasV:

 

Private Sub Encolar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Encolar.Click

 

Dim lresul As Integer ' Indice resultado

Dim ColaW As String   ' Aux.paso de datos a grbar en la cola

Dim i As Integer      ' Iterador

Dim lCola As Integer  ' Longitud de los datos de cola leídos

 

 

' Completa datos rellenando blancos de cola

 

lCola = Len(Cola.Text)

ColaW = Cola.Text

 

For i = lCola To lDimD

 

ColaW = ColaW + " "

 

Next

 

 

' Graba item

 

lresul = PRUEBASVCOLA.FIFO_WRIT("PRUEBASVCOLA", ColaW)

 

 

. . .

                                                    _________