* Muestro el tipo de archivo que se esta mirando en Ver Registros

[z.facultad/75.06/emufs.git] / emufs / tipo2.c

diff --git a/emufs/tipo2.c b/emufs/tipo2.c
index 5b0ebdf7dcc69941ca3cbad2039f31c4f7cfdda7..7047e455f696d3d2c7b959c1c264f71ae5a58e02 100644 (file)
--- a/emufs/tipo2.c
+++ b/emufs/tipo2.c
@@ -26,10 +26,16 @@
  *
  */
 
  *
  */
 

-/***************************************************************/
-/* Implementación del Tipo Archivo 2: Registros Variables, Sin */
-/* Bloques at all.                                             */
-/***************************************************************/
+/** \file
+ * Archivo con registros de longitud variable, sin bloques.
+ *
+ * <b>Implementacion del Archivo Tipo 2</b>
+ *
+ * La organizacion interna de un archivo de tipo 2, presenta registros de longitud variable,
+ * los cuales son grabados secuencialmente, o bien en gaps (espacios libres) que se presenten en
+ * el archivo de datos, pero no se encuentran contenidos por bloques.
+ *
+ */

 
 #include "tipo2.h"
 #include "idx.h"
 
 #include "tipo2.h"
 #include "idx.h"


@@ -40,20 +46,15 @@
 int emufs_tipo2_inicializar(EMUFS* efs)
 {
        efs->grabar_registro = emufs_tipo2_grabar_registro;           
 int emufs_tipo2_inicializar(EMUFS* efs)
 {
        efs->grabar_registro = emufs_tipo2_grabar_registro;           

-    efs->borrar_registro = emufs_tipo2_borrar_registro;
+  efs->borrar_registro = emufs_tipo2_borrar_registro;

        efs->leer_registro = emufs_tipo2_leer_registro;
        efs->leer_registro = emufs_tipo2_leer_registro;

+       efs->modificar_registro = emufs_tipo2_modificar_registro;
+       
+       return 0;

 }
 
 }
 

-/**********************************************************************/
-/* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr,    */
-/*                                 EMUFS_REG_SIZE n_RegSize)          */
-/* Objetivo: Grabar un registro en un archivo del Tipo 2.             */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             void *ptr // Puntero al buffer (registro) a guardar    */
-/*             EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion   */
-/**********************************************************************/
-void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
-                       EMUFS_REG_SIZE* reg_size, int *err)
+/* Lee y devuelve un registro de un archivo del Tipo 2. */
+void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID id_reg, EMUFS_REG_SIZE* reg_size, int *err)

 {
        FILE* f_data;
        char *registro; /* registro a leer */
 {
        FILE* f_data;
        char *registro; /* registro a leer */


@@ -64,7 +65,7 @@ void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
        strcat(name_f,".dat");
 
        /* Obtenemos la posicion del registro en el .dat */
        strcat(name_f,".dat");
 
        /* Obtenemos la posicion del registro en el .dat */

-       reg_offset = emufs_idx_buscar_registro(efs, reg_id);
+       reg_offset = emufs_idx_buscar_registro(efs, id_reg);

        if (reg_offset == EMUFS_NOT_FOUND) {
                /* TODO Manejo de errores */
                PERR("Registro no encontrado");
        if (reg_offset == EMUFS_NOT_FOUND) {
                /* TODO Manejo de errores */
                PERR("Registro no encontrado");


@@ -87,20 +88,13 @@ void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
        return registro;
 }
 
        return registro;
 }
 

-/**********************************************************************/
-/* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr,    */
-/*                                 EMUFS_REG_SIZE n_RegSize)          */
-/* Objetivo: Grabar un registro en un archivo del Tipo 2.             */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             void *ptr // Puntero al buffer (registro) a guardar    */
-/*             EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion   */
-/**********************************************************************/
-EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE n_RegSize, int* err)
+/* Grabar un registro en un archivo del Tipo 2. */
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE reg_size, int* err)

 {
 {

-       EMUFS_REG_ID n_IdReg;
-       EMUFS_FREE n_FreeSpace;
-       EMUFS_OFFSET n_WrtOffset,n_RegOffset;
-       unsigned long int n_FisicSize;
+       EMUFS_REG_ID id_reg;
+       EMUFS_FREE freespace;
+       EMUFS_OFFSET wrt_offset,reg_offset;
+       unsigned long int fisic_size;

        FILE *f_data;
        char name_f[255];
        
        FILE *f_data;
        char name_f[255];
        


@@ -112,98 +106,85 @@ EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE n
        
        /* Obtengo un offset en donde iniciar la escritura de mi registro */
        /* de manera segura (habra espacio suficiente) */
        
        /* Obtengo un offset en donde iniciar la escritura de mi registro */
        /* de manera segura (habra espacio suficiente) */

-       n_FisicSize = sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)+n_RegSize;
-       n_WrtOffset = emufs_fsc_buscar_lugar(efs,n_FisicSize,&n_FreeSpace);
-       printf("tipo2.c >> Recording Reg > Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);
+       fisic_size = sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)+reg_size;
+       wrt_offset = emufs_fsc_buscar_lugar(efs,fisic_size,&freespace);
+       /*printf("tipo2.c >> Recording Reg > Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);*/

        
        /* Si no encontre un gap, entonces escribo el registro al final */
        
        /* Si no encontre un gap, entonces escribo el registro al final */

-       if (n_WrtOffset == -1) {                       
+       if (wrt_offset == -1) {                

                
                /* Obtengo un ID libre para el registro y luego grabo a disco */
                
                /* Obtengo un ID libre para el registro y luego grabo a disco */

-        n_IdReg = emufs_idx_get_new_id(efs, err);
+        id_reg = emufs_idx_get_new_id(efs, err);

                fseek(f_data, 0, SEEK_END);
                fseek(f_data, 0, SEEK_END);

-               n_RegOffset = ftell(f_data);
+               reg_offset = ftell(f_data);

 
                /* Escribo [RegId]|[RegSize]|[RegData] */
 
                /* Escribo [RegId]|[RegSize]|[RegData] */

-               fwrite(&n_IdReg,sizeof(EMUFS_REG_ID),1,f_data);
-               fwrite(&n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);
-               fwrite(ptr,n_RegSize,1,f_data);
+               fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data);
+               fwrite(&reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
+               fwrite(ptr,reg_size,1,f_data);

                                
                /* Bye */
                                
                /* Bye */

-               printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);
+               /*printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);*/

                fclose(f_data);
                
        } else {
                
                /* Obtengo un ID libre para el registro y luego grabo en disco */
                fclose(f_data);
                
        } else {
                
                /* Obtengo un ID libre para el registro y luego grabo en disco */

-        n_IdReg = emufs_idx_get_new_id(efs, err);
-               n_RegOffset = n_WrtOffset;
-               fseek(f_data,n_RegOffset,0);
+        id_reg = emufs_idx_get_new_id(efs, err);
+               reg_offset = wrt_offset;
+               fseek(f_data,reg_offset,0);

                
         /* Escribo [RegId]|[RegSize]|[RegData] */
                
         /* Escribo [RegId]|[RegSize]|[RegData] */

-               fwrite(&n_IdReg,sizeof(EMUFS_REG_ID),1,f_data);
-               fwrite(&n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);
-               fwrite(ptr,n_RegSize,1,f_data);
+               fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data);
+               fwrite(&reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
+               fwrite(ptr,reg_size,1,f_data);

                                
                /* Bye */
                                
                /* Bye */

-               printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);
+               /*printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);*/

                fclose(f_data);
                
                /* Actualizo el espacio libre en el GAP donde puse el registro */
                fclose(f_data);
                
                /* Actualizo el espacio libre en el GAP donde puse el registro */

-               if ((n_FreeSpace-n_FisicSize) == 0) emufs_fsc_remove_gap(efs,n_RegOffset);
-               else emufs_fsc_actualizar_gap(efs,n_RegOffset,n_FreeSpace-n_FisicSize);         
+               if ((freespace-fisic_size) == 0) emufs_fsc_remove_gap(efs,reg_offset);
+               else emufs_fsc_actualizar_gap(efs,reg_offset,freespace-fisic_size);             

        }
                
        /* Finalmente, actualizamos el indice de registros (offsets) */
        }
                
        /* Finalmente, actualizamos el indice de registros (offsets) */

-       emufs_idx_agregar(efs,n_IdReg,n_RegOffset);
+       emufs_idx_agregar(efs,id_reg,reg_offset);

                
                

-       return n_IdReg;
+       return id_reg;

 }
 
 }
 

-/**********************************************************************/
-/* int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg)  */
-/* Objetivo: Borra un registro determinado y actualiza los archivos   */
-/*           de Posicion Relativa (Indice-Offset) y el de Gaps        */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             EMUFS_REG_ID n_IdReg // Id del registro a eliminar.    */
-/**********************************************************************/
-int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg)
+/* Borra un registro determinado y actualiza los archivos de Posicion Relativa (Indice-Offset) y el de Gaps */
+int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID id_reg)

 {      
 {      

-       EMUFS_OFFSET n_RegOffset,n_RegSize;
+       EMUFS_OFFSET reg_offset,reg_size;

         
        /* Obtenemos el offset donde arranca el registro */
         
        /* Obtenemos el offset donde arranca el registro */

-       if ((n_RegOffset = emufs_idx_buscar_registro(efs,n_IdReg)) != -1)
-         printf("tipo2.c >> Searching Reg %lu...Found at offset: %lu\n",n_IdReg,n_RegOffset);
-       else 
-         return -1;
+       if ((reg_offset = emufs_idx_buscar_registro(efs,id_reg)) == EMUFS_NOT_FOUND) {
+               /* TODO Manejo de errores */
+               PERR("Registro no encontrado");
+               return EMUFS_NOT_FOUND;
+       }

        
        /* Obtenemos el Size del Registro en cuestion y hacemos un dummyfill*/
        
        /* Obtenemos el Size del Registro en cuestion y hacemos un dummyfill*/

-       emufs_tipo2_get_regsize(efs,n_RegOffset,&n_RegSize);
-       printf ("tipo2.c >> About to delete Reg %lu of Size: %lu\n",n_IdReg,n_RegSize);
-       emufs_tipo2_dummyfill(efs,n_RegOffset,n_RegSize);
-       
+       emufs_tipo2_get_regsize(efs,reg_offset,&reg_size);      
+       emufs_tipo2_dummyfill(efs,reg_offset,reg_size);
+               

        /* Agregamos el GAP en el archivo de FSC, el cual hara un merge con */
        /* otro GAP por delante y/o por detras en caso de hallarlo. */
        /* Agregamos el GAP en el archivo de FSC, el cual hara un merge con */
        /* otro GAP por delante y/o por detras en caso de hallarlo. */

-       emufs_fsc_agregar_gap(efs,n_RegOffset,n_RegSize+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE));
+       emufs_fsc_agregar_gap(efs,reg_offset,reg_size+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE));

        
        /* Agrego el ID que se ha liberado al archivo de ID's Libres */
        
        /* Agrego el ID que se ha liberado al archivo de ID's Libres */

-       emufs_did_agregar(efs,n_IdReg); 
+       emufs_did_agregar(efs,id_reg);  

        
        /* Borramos el registro del indice de posiciones relativas */
        
        /* Borramos el registro del indice de posiciones relativas */

-       emufs_idx_borrar(efs,n_IdReg);
+       emufs_idx_borrar(efs,id_reg);

        
        return(0);
 }
 
        
        return(0);
 }
 

-/**********************************************************************/
-/* int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos,     */
-/*                             EMUFS_REG_SIZE *n_RegSize)             */
-/* Objetivo: Devuelve el tamanio de un registro, dado su init offset  */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             EMUFS_OFFSET n_RegPos // Offset al inicio del registro */
-/*             EMUFS_REG_SIZE *n_RegSize // Size to lookup and return */
-/**********************************************************************/
-int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE *n_RegSize)
+/* Devuelve el tamanio de un registro, dado su init offset */
+int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE *reg_size)

 {
     FILE *f_data;
        char name_f[255];
 {
     FILE *f_data;
        char name_f[255];


@@ -213,29 +194,22 @@ int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE *n
        strcat(name_f,".dat");
 
     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
        strcat(name_f,".dat");
 
     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */

-       fseek(f_data,n_RegPos+sizeof(EMUFS_REG_ID),SEEK_SET);
-       fread(n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);               
+       fseek(f_data,reg_pos+sizeof(EMUFS_REG_ID),SEEK_SET);
+       fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);                

        fclose(f_data);
        
        return (0);
 }
 
        fclose(f_data);
        
        return (0);
 }
 

-/**********************************************************************/
-/* int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos,       */
-/*                           EMUFS_REG_SIZE n_Amount                  */
-/* Objetivo: Pisa con basura lo que es hasta el momento un reg en     */
-/*           el disco para indicar su borrado (Debug Purposes Only).  */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             EMUFS_OFFSET n_RegPos // Offset al inicio del registro */
-/*             EMUFS_REG_SIZE *n_Amount // Size to lookup and return  */
-/**********************************************************************/
-int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE n_Amount)
+
+/* Pisa con basura lo que es hasta el momento un reg en el disco para indicar su borrado (Debug Purposes Only) */
+int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE amount)

 {
     FILE *f_data;
        char name_f[255];
     char *dummyfill;
        char *ptr_cur;
 {
     FILE *f_data;
        char name_f[255];
     char *dummyfill;
        char *ptr_cur;

-       unsigned long n_FillSize,n_count;
+       unsigned long fill_size,byte_count;

        
     /* Armamos el filename del archivo de datos */
        strcpy(name_f,efs->nombre);
        
     /* Armamos el filename del archivo de datos */
        strcpy(name_f,efs->nombre);


@@ -244,15 +218,20 @@ int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE n_Am
     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
        
        /* Preparo el garbage y se lo tiro encima */
     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
        
        /* Preparo el garbage y se lo tiro encima */

-       n_FillSize = n_Amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE);
-       dummyfill = (char*)malloc(n_FillSize);
+       fill_size = amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE);
+       dummyfill = (char*)malloc(fill_size);

        ptr_cur = dummyfill;
        ptr_cur = dummyfill;

-       for (n_count = 0; n_count < n_FillSize; ++n_count) memcpy(ptr_cur+n_count,"#",1);
-       fseek(f_data,n_RegPos,SEEK_SET);
-       fwrite(dummyfill,n_FillSize,1,f_data);
+       for (byte_count = 0; byte_count < fill_size; ++byte_count) memcpy(ptr_cur+byte_count,"#",1);
+       fseek(f_data,reg_pos,SEEK_SET);
+       fwrite(dummyfill,fill_size,1,f_data);

        fclose(f_data);
        
        fclose(f_data);
        

-       /* printf("Dummy Fill: %s\n",dummyfill); */ /*Uncomment to check */

        free(dummyfill);
        return (0);
 }
        free(dummyfill);
        return (0);
 }

+
+EMUFS_REG_ID emufs_tipo2_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
+{
+       emufs_tipo2_borrar_registro(emu, id);
+       return emufs_tipo2_grabar_registro(emu, data, size, error);
+}