Se implementa borrar_registro en tipo1. Soporta registros mas grandes que el

bloque. Lo unico que falta es alinear a izquiera los registros del bloque
modificado (si hubiera registros a la derecha del registro borrado).

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index f1cc3c92ee820515555bd024c3abe87ea79b6d97..6e35771a27b54f6964735789ad29c52ed900850c 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -153,13 +153,17 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
                }
                /* Desplazo el offset */
                offset += curr_reg_header.size;
-       } while (offset < efs->tam_bloque);
+
+       /* esto no debería ser nunca false porque sé positivamente que el */
+       } while (offset < efs->tam_bloque); /* registro está en el bloque */
 
        free(block);
        return registro;
 }
 
-void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE *size, int *pos)
+/* @todo TODO hacer que soporte registros de más de un bloque */
+void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id,
+               EMUFS_REG_SIZE *size, int *pos)
 {
        char* block; /* bloque leido (en donde está el registro a leer) */
        EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
@@ -335,7 +339,97 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg, EMUFS_REG_SIZE r
        return reg_header.id;
 }
 
-/*Graba un bloque en el archivo*/
+int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
+{
+       char* block; /* bloque leido (en donde está el registro a leer) */
+       EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
+       EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */
+       EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
+       int err = 0; /* para almacenar código de error */
+
+       block_id = emufs_idx_buscar_registro(efs, reg_id);
+       if (block_id == EMUFS_NOT_FOUND) {
+               /* TODO Manejo de errores */
+               PERR("Registro no encontrado");
+               return EMUFS_NOT_FOUND;
+       }
+       if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
+               /* TODO Manejo de errores */
+               PERR("no se pudo reservar memoria");
+               return err;
+       }
+
+       /* Busco secuencialmente en el bloque el registro a leer */
+       offset = 0;
+       do {
+               /* Copio la cabecera del registro actual. */
+               memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER));
+               offset += sizeof(EMUFS_TIPO1_REG_HEADER);
+               if (curr_reg_header.id == reg_id) {
+                       /* identificador del bloque actual */
+                       EMUFS_BLOCK_ID curr_block_id = block_id;
+                       /* tamaño máximo ultilizable para datos en un bloque */
+                       EMUFS_BLOCK_SIZE block_space
+                                       = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
+                       EMUFS_FREE fs; /* cantidad de espacio libre en el bloque */
+
+                       while (1) {
+                               /* actualizo archivo de espacio libre por bloque */
+                               fs = emufs_fsc_get_fs(efs, curr_block_id)
+                                       + MIN(curr_reg_header.size, block_space)
+                                       + sizeof(EMUFS_TIPO1_REG_HEADER);
+                               if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) {
+                                       /* TODO Manejo de errores */
+                                       PERR("no se pudo actualizar .fsc");
+                                       free(block);
+                                       return err;
+                               }
+                               /* falta liberar un bloque (o porción) */
+                               if (curr_reg_header.size > block_space) {
+                                       free(block);
+                                       if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
+                                                                       ++curr_block_id, &err))) {
+                                               /* TODO Manejo de errores */
+                                               PERR("no se pudo leer el bloque");
+                                               return err;
+                                       }
+                                       /* copio la cabecera del primer registro (si ocupa más de un
+                                        * registro está en bloques contiguos) */
+                                       memcpy(&curr_reg_header, block,
+                                                       sizeof(EMUFS_TIPO1_REG_HEADER));
+                               } else { /* se terminó de leer */
+                                       break;
+                               }
+                       }
+
+                       /* actualizo archivo de identificadores de registros borrados */
+                       if ((err = emufs_did_agregar(efs, reg_id))) {
+                               /* TODO Manejo de errores */
+                               PERR("no se pudo actualizar .did");
+                               free(block);
+                               return err;
+                       }
+                       /*actualizo archivo .idx*/
+                       if ((err = emufs_idx_borrar(efs, reg_id))) {
+                               /* TODO Manejo de errores */
+                               PERR("no se pudo actualizar .did");
+                               free(block);
+                               return err;
+                       }
+
+                       /* TODO desplazar a izquierda registros */
+               }
+               /* desplazo el offset */
+               offset += curr_reg_header.size;
+
+       /* esto no debería ser nunca false porque sé positivamente que el */
+       } while (offset < efs->tam_bloque); /* registro está en el bloque */
+
+       free(block);
+       return 0; /* EMUFS_OK */
+}
+
+/** Graba un bloque en el archivo. */
 EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque(EMUFS *efs, void *block,
                EMUFS_BLOCK_ID block_id, int* err)
 {
@@ -390,17 +484,6 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque(EMUFS *efs, void *block,
        return block_id;
 }
 
-/*borra un registro de un bloque y acomoda los registros que quedan*/
-int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg)
-{
-       return -1; /* FIXME Error */
-}
-
-int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg)
-{
-       return -1; /* FIXME Error */
-}
-
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS *emu, EMUFS_REG_ID id,
                void *data, EMUFS_REG_SIZE size, int *error)
 {

diff --git a/emufs/tipo1_main.c b/emufs/tipo1_main.c
index 9c45fc3d7cbf11d821bd73a3715b6f186e86f38f..b40749beb5766d9a8690d54747310dc0025fbe67 100644 (file)
--- a/emufs/tipo1_main.c
+++ b/emufs/tipo1_main.c
@@ -62,21 +62,21 @@ int main(int argc, char* argv[]) {
        id1 = efs->grabar_registro(efs, reg1, sizeof(reg1), &err);
        if (err) {
                printf("No se pudo grabar el registro 1 (%d).\n", err);
-               goto error;
+               goto out;
        }
        printf("Se grabó el registro 1 (size: %u) con el id %lu.\n", sizeof(reg1), id1);
 
        id2 = efs->grabar_registro(efs, reg2, sizeof(reg2), &err);
        if (err) {
                printf("No se pudo grabar el registro 2 (%d).\n", err);
-               goto error;
+               goto out;
        }
        printf("Se grabó el registro 2 (size: %u) con el id %lu.\n", sizeof(reg2), id2);
 
        id3 = efs->grabar_registro(efs, reg3, sizeof(reg3), &err);
        if (err) {
                printf("No se pudo grabar el registro 3 (%d).\n", err);
-               goto error;
+               goto out;
        }
        printf("Se grabó el registro 3 (size: %u) con el id %lu.\n", sizeof(reg3), id3);
 
@@ -84,7 +84,7 @@ int main(int argc, char* argv[]) {
        reg = efs->leer_registro(efs, id1, &size, &err);
        if (err) {
                printf("No se pudo leer el registro 1 (%d).\n", err);
-               goto error;
+               goto out;
        }
        printf("El contenido del registro 1 es: '%s'.\n", reg);
        free(reg);
@@ -92,7 +92,7 @@ int main(int argc, char* argv[]) {
        reg = efs->leer_registro(efs, id2, &size, &err);
        if (err) {
                printf("No se pudo leer el registro 2 (%d).\n", err);
-               goto error;
+               goto out;
        }
        printf("El contenido del registro 2 es: '%s'.\n", reg);
        free(reg);
@@ -100,7 +100,7 @@ int main(int argc, char* argv[]) {
        reg = efs->leer_registro(efs, id3, &size, &err);
        if (err) {
                printf("No se pudo leer el registro 3 (%d).\n", err);
-               goto error;
+               goto out;
        }
        printf("El contenido del registro 3 es: '%s'.\n", reg);
        free(reg);
@@ -108,12 +108,23 @@ int main(int argc, char* argv[]) {
        /* Ve archivos auxiliares */
        printf("\nArchivos auxiliares:\n\n");
        ver_archivo_FS(efs);
+       printf("\n--------------------------------------------------\n\n");
 
-       emufs_destruir(efs);
-       return 0;
+       /* Borra registro */
+       err = efs->borrar_registro(efs, id2);
+       if (err) {
+               printf("No se pudo borrar el registro 2 (%d).\n", err);
+               goto out;
+       }
+       printf("Registro 2 (id = %lu) borrado!.\n", id2);
+
+       /* Ve archivos auxiliares */
+       printf("\n--------------------------------------------------\n");
+       printf("Archivos auxiliares:\n\n");
+       ver_archivo_FS(efs);
 
-error:
+out:
        emufs_destruir(efs);
-       return 2;
+       return err;
 
 }