- emufs.c: Utilizacion de emufs_tipo2_inicializar, idem a lo que hizo luca con su...

- tipo2.c | .h: Added funcion emufs_tipo2_leer_registro, por lo cual el tipo 2 ya se encuentra terminado. Also Added inicializador de punteros a funciones para la estructura EMUFS*, mencionado arriba.

- tipo2_main.c: Se agregaron algunos tests de leer registro, espacio libre, etc.

diff --git a/emufs/emufs.c b/emufs/emufs.c
index ef22753e9a34cfeef89adf206525cd00b947f230..0c55064550722b1e474eff4f8efbe55bc3970265 100644 (file)
--- a/emufs/emufs.c
+++ b/emufs/emufs.c
@@ -142,6 +142,7 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_b
        switch (tipo) {
 
                case T1:
+                       /* Asigna punteros a funciones. */
                        emufs_tipo1_inicializar(efs);
 
                        /* Guarda cabeceras propias. */
@@ -151,10 +152,7 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_b
 
                case T2:
                        /* Asigna punteros a funciones. */
-                       efs->grabar_registro = emufs_tipo2_grabar_registro;           
-            efs->borrar_registro = emufs_tipo2_borrar_registro;
-                       efs->nombre = str_dup(filename);
-                   /*efs->leer_registro = emufs_tipo2_leer_registro;*/                                         
+                       emufs_tipo2_inicializar(efs);
                        break;
 
                case T3:
@@ -207,6 +205,7 @@ EMUFS *emufs_abrir(const char *filename)
 
        switch (tipo) {
                case T1:
+                       /* Asigna punteros a funciones. */
                        emufs_tipo1_inicializar(efs);
                        /* Lee cabeceras propias. */
                        if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
@@ -217,6 +216,8 @@ EMUFS *emufs_abrir(const char *filename)
                        }
                        break;
                case T2:
+                       /* Asigna punteros a funciones. */
+                       emufs_tipo2_inicializar(efs);                   
                        break;
                case T3:
                        if ((!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) ||
@@ -227,10 +228,11 @@ EMUFS *emufs_abrir(const char *filename)
                                fclose(fp);
                                return NULL;
                        }                       
+                       /* Asigna punteros a funciones. */                      
                        efs->leer_bloque = emufs_tipo3_leer_bloque;
                        efs->leer_registro = emufs_tipo3_leer_registro;
                        efs->grabar_registro = emufs_tipo3_grabar_registro;
-                       /*efs->borrar_registro = emufs_tipo3_borrar_registro;*/
+                       efs->borrar_registro = emufs_tipo3_borrar_registro;
                        break;
        }
 

diff --git a/emufs/tipo2.c b/emufs/tipo2.c
index d2901d7bd1c7376bf0ac0b5a687f6331427b3708..5b0ebdf7dcc69941ca3cbad2039f31c4f7cfdda7 100644 (file)
--- a/emufs/tipo2.c
+++ b/emufs/tipo2.c
@@ -36,6 +36,57 @@
 #include "fsc.h"
 #include "did.h"
 
+/* Asigna los punteros a las funciones apropiadas para el Tipo2 */
+int emufs_tipo2_inicializar(EMUFS* efs)
+{
+       efs->grabar_registro = emufs_tipo2_grabar_registro;           
+    efs->borrar_registro = emufs_tipo2_borrar_registro;
+       efs->leer_registro = emufs_tipo2_leer_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   */
+/**********************************************************************/
+void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
+                       EMUFS_REG_SIZE* reg_size, int *err)
+{
+       FILE* f_data;
+       char *registro; /* registro a leer */
+       char  name_f[255];      
+       EMUFS_OFFSET reg_offset; /* offset donde se encuentra el registro */
+       
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,".dat");
+
+       /* Obtenemos la posicion del registro en el .dat */
+       reg_offset = emufs_idx_buscar_registro(efs, reg_id);
+       if (reg_offset == EMUFS_NOT_FOUND) {
+               /* TODO Manejo de errores */
+               PERR("Registro no encontrado");
+               *err = EMUFS_NOT_FOUND;
+               return NULL;
+       }
+       
+       /* Levantamos el registro */
+       if ((f_data = fopen(name_f, "rb")) == NULL) {
+               PERR("No se puede abrir archivo");
+               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               return NULL; /* FIXME ERROR */
+       }
+       fseek(f_data,reg_offset+sizeof(EMUFS_REG_ID),0);
+       fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
+       registro = (char*)malloc(*reg_size);
+       fread(registro,*reg_size,1,f_data);
+       fclose(f_data);
+       
+       return registro;
+}
+
 /**********************************************************************/
 /* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr,    */
 /*                                 EMUFS_REG_SIZE n_RegSize)          */
@@ -202,6 +253,6 @@ int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE n_Am
        fclose(f_data);
        
        /* printf("Dummy Fill: %s\n",dummyfill); */ /*Uncomment to check */
-       
+       free(dummyfill);
        return (0);
 }

diff --git a/emufs/tipo2.h b/emufs/tipo2.h
index e6b4051623bee6453610035bc36d6c8bc216ef61..f36aea2e0486798a18dafdb09782bde1a6018959 100644 (file)
--- a/emufs/tipo2.h
+++ b/emufs/tipo2.h
@@ -37,13 +37,11 @@
 #include <unistd.h>
 #include "emufs.h"
 
-EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *, void *, EMUFS_REG_SIZE, int*);
+int emufs_tipo2_inicializar(EMUFS*);
+void *emufs_tipo2_leer_registro(EMUFS* , EMUFS_REG_ID , EMUFS_REG_SIZE *, int *);
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *, void *, EMUFS_REG_SIZE, int *);
 int emufs_tipo2_borrar_registro(EMUFS*, EMUFS_REG_ID);
-int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos,EMUFS_REG_SIZE *n_RegSize);
-int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos,EMUFS_REG_SIZE n_Amount);
-
-/* OJO!! Fijate que cambio el prototipo:
-   int emufs_tipo2_leer_registro(EMUFS *, EMUFS_REG_ID , void *, EMUFS_REG_SIZE);
-   int emufs_tipo2_buscar_registro(EMUFS *, int); */
+int emufs_tipo2_get_regsize(EMUFS *, EMUFS_OFFSET n_RegPos,EMUFS_REG_SIZE *);
+int emufs_tipo2_dummyfill(EMUFS *, EMUFS_OFFSET n_RegPos,EMUFS_REG_SIZE n_Amount);
 
 #endif /* _EMUFS_TIPO2_H_ */

diff --git a/emufs/tipo2_main.c b/emufs/tipo2_main.c
index 068b0304b714c4864fc87fbf38a341fd3b722dac..9778593f936f7edea92b65fe9c66c3b67a3a0c9d 100644 (file)
--- a/emufs/tipo2_main.c
+++ b/emufs/tipo2_main.c
@@ -31,11 +31,14 @@
 #include <stdio.h>
 #include <string.h>
 #include "emufs.h"
+#include "fsc.h"
 
 int main(int argc, char *argv[])
 {
-       EMUFS *fp;
+       EMUFS *efs;
        EMUFS_REG_ID n0, n1, n2, n3, n4, n5, n6, n7, n8;
+       EMUFS_REG_SIZE reg_size;
+       char *registro;         
        char a[11];
        char b[63];
        char c[13];
@@ -46,6 +49,7 @@ int main(int argc, char *argv[])
        char h[63];
        char i[43];
        int err = 0;
+       EMUFS_FREE totalfsc = 0;
 
        strcpy(a, "1234567890");
        strcpy(b, "REGISTRO NUMERO 2. ESTE REGISTRO ES MUCHO MAS LARGO QUE EL UNO");
@@ -59,36 +63,45 @@ int main(int argc, char *argv[])
        
        /* Creamos el archivo Tipo 2. Pasamos blocksize = 0 y Regsize = 0 pues estar */
        /* variable. */
-       fp = emufs_crear("articulos", T2, 0, 0);
+       efs = emufs_crear("articulos", T2, 0, 0);
        
        /* Grabamos un par de registros */
-       n0 = fp->grabar_registro(fp, a, 11, &err);
-       n1 = fp->grabar_registro(fp, b, 63, &err);
-       n2 = fp->grabar_registro(fp, c, 13, &err);
-       n3 = fp->grabar_registro(fp, d, 8, &err);
-       n4 = fp->grabar_registro(fp, e, 39, &err);
-       n5 = fp->grabar_registro(fp, f, 9, &err);
-       n6 = fp->grabar_registro(fp, g, 41, &err);
-       n7 = fp->grabar_registro(fp, h, 63, &err);
+       n0 = efs->grabar_registro(efs, a, 11, &err);
+       n1 = efs->grabar_registro(efs, b, 63, &err);
+       n2 = efs->grabar_registro(efs, c, 13, &err);
+       n3 = efs->grabar_registro(efs, d, 8, &err);
+       n4 = efs->grabar_registro(efs, e, 39, &err);
+       n5 = efs->grabar_registro(efs, f, 9, &err);
+       n6 = efs->grabar_registro(efs, g, 41, &err);
+       n7 = efs->grabar_registro(efs, h, 63, &err);
 
        /* Borramos un registro del medio */
        printf("tipo2_main.c >> Borrando registro: %lu\n",n5);
-       fp->borrar_registro(fp, n5);            
+       efs->borrar_registro(efs, n5);          
        printf("tipo2_main.c >> Borrando registro: %lu\n",n1);
-       fp->borrar_registro(fp, n1);
+       efs->borrar_registro(efs, n1);
     printf("tipo2_main.c >> Borrando registro: %lu\n",n0);
-       fp->borrar_registro(fp, n0);
+       efs->borrar_registro(efs, n0);
        printf("tipo2_main.c >> Borrando registro: %lu\n",n3);
-       fp->borrar_registro(fp, n3);    
+       efs->borrar_registro(efs, n3);  
        printf("tipo2_main.c >> Borrando registro: %lu\n",n7);
-       fp->borrar_registro(fp, n7);    
+       efs->borrar_registro(efs, n7);  
        printf("tipo2_main.c >> Borrando registro: %lu\n",n4);
-       fp->borrar_registro(fp, n4);
+       efs->borrar_registro(efs, n4);
          
-       n8 = fp->grabar_registro(fp, d, 8, &err);
+       n8 = efs->grabar_registro(efs, d, 8, &err);
        printf("tipo2_main.c >> Id recuperado: %lu\n",n8);
        
-       emufs_destruir(fp);
+       totalfsc = emufs_fsc_get_total_fs(efs);
+       printf("tipo2_main.c >> Total de espacio libre en el .dat: %lu\n",totalfsc);
+       
+       registro = efs->leer_registro(efs,n2,&reg_size,&err);
+       if (err == 0) {
+               printf("tipo2_main.c >>Registro: %lu Size: %lu Content: %s\n\n",n2,reg_size,registro);
+               printf("Total de espacio libre en el .dat: %lu\n",totalfsc);
+       }
+       
+       emufs_destruir(efs);    
        
        return 0;
 }