Serie ficheros virtuales

 

 

 

 

C Ficheros virtuales

 

 

 

 

 

 

 

A.I.8 Extensión. Alternativa C++. La clase vFile

 

 A.I.8.1 Exposición de la clase vFile

 A.I.8.2 Implementación

 

                                                                                               _________

 

 

A.I.8.1 Exposición de vFile

 

Hasta ahora el desarrollo ha seguido el sendero C ANSI básicamente, aunque por comodidad se ha utilizado sobrecarga multifunción en SRRCW. En iSeries se utiliza una versión donde se elude la sobrecarga explícita por una sobrecarga implícita poniendo varios nombres, con la misma raíz, para la misma función lógica en sus distintas variantes, como en la función READ, de la que se ofrecen dos prototipos, uno con el nombre base y el otro extendido:

 

 int SRRCW_READ (const char *cFILE, long lINDIp, void *vDato);

 int SRRCW_READC(const char *cFILE, long lINDIp, void *vDato, void *vClav);

 

 

vFile es una versión implementada como clases, que proporciona las funciones que hemos visto hasta ahora como métodos aplicables a los objetos que se instancien para su utilización.

 

En ésta perspectiva, cada base de datos virtual es un objeto y las funciones se implementan como métodos aplicables a estos objetos.

 

Estos métodos son interfaces de las funciones SRRCW que serán finalmente aplicadas.

 

Así, es fácil implementar un objeto multiagenda que sea una lista de agendas que a su vez sean objetos a los que se les puede añadir y modificar ítems mediante los métodos de la clase vFile.

 

Con los métodos de vFile las agendas se pueden presentar ordenadas por nombre, por número de teléfono, etc.

 

De hecho este será uno de los ejemplos que se presenten en la segunda parte de esta zona del libro. (De hecho, será el más simple de ellos)

 

El manual de uso de SRRCW es aplicable a vFile reinterpretando el uso de funciones de SRRCW como los métodos de vFile que se presentan ahora

 

 

                                                                                               _________

 

Funciones de gestión de objetos

 

Constructores

 

Constructores interfaz a SRRCW_NEW

 

vFile(); // Instrumental para definir como variable global y poder dar tamaño luego

vFile(long lDimD);

vFile(int iDimC, long lDimD);

vFile(int iDimC, long lDimD, long lMaxNreg);

 

 

Constructores interfaz a SRRCW_FIFO_NEW / SRRCW_LIFO_NEW (Colas y pilas)

 

// cOpci C=Cola P=Pila

// (Nota: se utiliza char* en vez de char para evitar ambiguedad con def.previa,

// puesto que char es un sinónimo especial de int)

 

vFile(const char *cOpci, long lDimD);

vFile(const char *cOpci, long lDimD, long lMaxNreg);

 

 

Destructor

 

~vFile(); // Interfaz a SRRCW_ERASE

 

 

Reconstructores, interfaz a SRRCW_RESIZE

 

long RESIZ(long lMaxNreg);

long RESIZ(int iDimC, long lDimD);

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

 

 

Reconstructores, interfaz a SRRCW_FIFO_NEW / SRRCW_LIFO_NEW

 

// cOpci C=Cola P=Pila

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

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

 

 

 

Otras funciones de gestión de objetos

 

// Vaciado de datos

 

long CLRF(long *lNBAJp);

long CLRF();

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

long CLRF(const char *cLF);

 

 

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

 

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

 

                                                                                               _________

 

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

 

// Grupo CHAIN

 

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

long CHAIN( void *vClav);

long CHAIN(const char *cLF, const void *vClav, void *vDato);

long CHAIN(const char *cLF, void *vClav);

long VER(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);

 

short int REORGANIZE(long *lNBAJp);

short int REORGANIZE(void);

 

 

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

 

                                                                                               _________

 

Persistencia de datos

 

// Restauración desde fichero físico

 

long RSTF(const char *cSAVF);

 

// Salvado a fichero físico

 

long SAVF(const char *cSAVF);

 

 

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();

 

long NID();

long NID(const char *cLF);

 

 

Grupos de emulación de pilas y colas

 

// Grupo emulación pilas

 

short int LIFO_READ(void *vDato, char cOpci);

short int LIFO_READ(void *vDato);

 

long LIFO_WRIT(const void *vDato);

 

 

// Grupo emulación colas

 

short int FIFO_READ(void *vDato, char cOpci);

short int FIFO_READ(void *vDato);

 

long FIFO_WRIT(const void *vDato);

 

                                                                                               _________

 

A.I.8.2 Implementación

 

Veamos un extracto de la codificación de vFile que se centra en el mecanismo de paso de la implementación de las funciones de SRRCW a los métodos de vFile.

 

Este mecanismo consiste en generar, con los constructores de vFile, ficheros virtuales que ya no precisarán utilizarse por su nombre, que se genera internamente de forma privada, sino que se trataran como objetos a los que se asignan propiedades tales como claves, datos, tamaño, etc. y a los que se les aplicarán las funciones de SRRCW como se verá con el extracto prototipo del CHAIN.

 

Hay que remarcar que la implementación que se presenta es de una clase no administrada clásica C++6, y que además está diseñada para ser utilizada en invocaciones únicas desde un programa “dialog-based”.

 

En la segunda zona del libro se presentarán evoluciones de vFile al modelo COM y al modelo NET con el mismo objetivo pero distinta implementación.

 

Así, para el modelo NET, se presentará la clase wFile, de tipo administrado y que ya no estará restringida por la limitación de invocación única.




  
// vFile.cpp : Defines the initialization routines for the DLL.


  
// Código incluido automáticamente

  
#using <mscorlib.dll>
  
using namespace System;

  
#include "stdafx.h"


  
// Includes de funciones de usuario

  
#include "vFile.h"
  
#include "srrcalx.h"
  
#include "srrcwx.h"


 
... (Sigue código incluido automáticamente hasta llegar al cuerpo de la clase)


  
//-----------------------------------------------------------------------------------
  
// Definición del tipo de dato abstracto vFile soporte de ficheros virtuales
  
//-----------------------------------------------------------------------------------
  
class AFX_EXT_CLASS vFile{

  
public:


    
   
// Zona de prototipos



   
// Constructores, interfaces a SRRCW_NEW

   
vFile(int  iDimC, long lDimD, long lMaxNreg);
   
   
...



   
// Reconstructores, para cambiar atributos del objeto vFile

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

   
...


   
// Metodos ordinarios, interfaces de las funciones de SRRCW a los objetos vFile

   
long CHAIN(const void *vClav, void *vDato);
   
long CHAIN(void *vClav);
   
long CHAIN(const char *cLF, const void *vClav, void *vDato);
   
long CHAIN(const char *cLFvoid *vClav);
   
   
...


  
private:
 
   
long lCONT;      // Contador maestro de files, es cFILE en formato numérico
   
char cFILE[33];  // Identificador, es lCONT en formato alfanumérico
   
long lNID;       // Nid asociado
    
   
...
  
};

                                                                                               _________


  
// Zona de implementación


  
//-----------------------------------------------------------------------------------
  
// Constructores interfaz a SRRCW_NEW
  
//-----------------------------------------------------------------------------------

  
vFile::vFile(int  iDimC, long lDimD, long lMaxNreg)
  
{
   
// Genera nombre interno incrementando contador global
   
++lCONT;
   
cLTOA = SRRCAL_ltoal(lCONT);


   
// Pasa el contador a alfanumérico
   
memset(cFILE, ' ', 32);
   
memcpy(cFILE, cLTOA, 10);
   
memset(cFILE+32, '\x00', 1);


   
// Genera NID asociado
   
lNID = SRRCW_NEW(cFILE, iDimC, lDimD, lMaxNreg);

   
return;
  
}
  
...


  
//-----------------------------------------------------------------------------------
  
// Reconstructores interfaz a (SRRCW_ERASE + SRRCW_NEW)  ó  a SRRCW_RESIZE
  
//-----------------------------------------------------------------------------------

  
long vFile::RESIZ(int  iDimC, long lDimD, long lMaxNreg)
  
{
   
long lresul; // Control de resultados intermedios

   
// Elimina previo
   
lresul = SRRCW_ERASE(cFILE);


   
// Regenera nombre interno incrementando contador global
   
lCONT += 1000;
   
cLTOA  = SRRCAL_ltoal(lCONT);


   
// Pasa el contador a alfanumérico
   
memset(cFILE, ' ', 32);
   
memcpy(cFILE, cLTOA, 10);
   
memset(cFILE+32, '\x00', 1);


   
// Regenera con nuevo tamaño
   
lNID = SRRCW_NEW(cFILE, iDimC, lDimD, lMaxNreg);

   
return lNID;
  
}
  
...

  
//-----------------------------------------------------------------------------------
  
// Método  CHAIN
  
//
  
// DESCRIPCION: Recupera un ítem de memoria por clave
  
//
  
//
  
// PARAMETROS.: Formato completo
  
//
  
// (entrada) vClav: Clave del Item
  
// (salida ) vDato: Datos del Item
  
//
  
//
  
// PARAMETROS.: Formato compacto
  
//
  
// (I/O)     vClav: Clave + datos del ítem
  
//
  
//
  
// Además de las versiones para lógicos, que incluyen el nombre de éste
  
//
  
// RETORNO....:
  
//                 0: Error de Proceso (No encontrado, ...)
  
//                >0: Indice en memoria-claves del ítem encontrado
  
//                    (formato 1..N)
  
//
  
//-----------------------------------------------------------------------------------
  
long vFile::CHAIN(const void *vClav, void *vDato)
  
{
   
return SRRCW_CHAIN(cFILE, vClav, vDato);
  
}

  
long vFile::CHAIN(void *vDato)
  
{
   
return SRRCW_CHAIN(cFILE, vDato);
  
}

  
long vFile::CHAIN(const char *cLF, const void *vClav, void *vDato)
  
{
   
return SRRCW_CHAIN(cLF, vClav, vDato);
  
}

  
long vFile::CHAIN(const char *cLF, void *vDato)
  
{
   
return SRRCW_CHAIN(cLF, vDato);
  
}
  
. . .
                                                                                               _________



La codificación completa de vFile está disponible bien directamente en su enlace o bien desde el capítulo "C3 Detalle de relación de programas de servicio (DLL) soporte de de los ficheros virtuales", además de la versión wFile para uso .Net, que disfruta de más capacidades y que se presentará detalladamente en la segunda zona del libro.


                                                                                               _________