Borro files en 0 bytes

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 73ea3e24a85d3bf42593434210cb3a66316b6eb5..d14d756af55e32f32a498fa2e049b7a5bcea11f5 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -99,16 +99,26 @@ int emufs_tipo1_inicializar(EMUFS* efs)
        return EMUFS_OK;
 }
 
        return EMUFS_OK;
 }
 

-void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
+void* emufs_tipo1_leer_registro(EMUFS* efs, CLAVE clave,

                EMUFS_REG_SIZE* reg_size, int *err)
 {
        char* block; /* bloque leido (en donde está el registro a leer) */
        char* registro; /* 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_REG_SIZE* reg_size, int *err)
 {
        char* block; /* bloque leido (en donde está el registro a leer) */
        char* registro; /* 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_REG_ID reg_id;

        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */

-
-       block_id = emufs_idx_buscar_registro(efs, reg_id);
+       INDICE_DATO dato;
+       
+       if (efs->indices != NULL) {
+               /* TODO : Verificar donde esta el indice primario */
+               dato = efs->indices->existe_entrada(efs->indices, clave);
+               block_id = dato.bloque;
+               reg_id = dato.id;
+       } else {
+               /* TODO ID de donde lo puedo sacar :-) , lo cargo en CLAVE ? */
+               block_id = emufs_idx_buscar_registro(efs, reg_id);
+       }

        if (block_id == EMUFS_NOT_FOUND) {
                PERR("Registro no encontrado");
                *err = EMUFS_NOT_FOUND;
        if (block_id == EMUFS_NOT_FOUND) {
                PERR("Registro no encontrado");
                *err = EMUFS_NOT_FOUND;


@@ -240,10 +250,12 @@ void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int* err)
        if (block == NULL) {
                PERR("No hay memoria");
                *err = EMUFS_ERROR_OUT_OF_MEMORY;
        if (block == NULL) {
                PERR("No hay memoria");
                *err = EMUFS_ERROR_OUT_OF_MEMORY;

+               fclose(file);

                return NULL;
        }
        if (fread(block, efs->tam_bloque, 1, file) != 1) {
                free(block);
                return NULL;
        }
        if (fread(block, efs->tam_bloque, 1, file) != 1) {
                free(block);

+               fclose(file);

                PERR("Error al leer bloque");
                *err = EMUFS_ERROR_FILE_READ;
                return NULL;
                PERR("Error al leer bloque");
                *err = EMUFS_ERROR_FILE_READ;
                return NULL;


@@ -266,6 +278,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
        EMUFS_BLOCK_ID curr_block_id;
        /* tamaño de la porción de registro que se guarda */
        EMUFS_REG_SIZE chunk_size = 0; 
        EMUFS_BLOCK_ID curr_block_id;
        /* tamaño de la porción de registro que se guarda */
        EMUFS_REG_SIZE chunk_size = 0; 

+       INDICE_DATO idx_data;

 
        /* obtengo identificador que corresponderá al registro */
        header.id = emufs_idx_get_new_id(efs, err);
 
        /* obtengo identificador que corresponderá al registro */
        header.id = emufs_idx_get_new_id(efs, err);


@@ -313,7 +326,9 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                emufs_tipo1_escribir_reg_chunk_en_memoria(block + efs->tam_bloque - fs,
                                header, chunk_ptr, chunk_size);
                /* rellena el espacio libre con ceros para la GUI */
                emufs_tipo1_escribir_reg_chunk_en_memoria(block + efs->tam_bloque - fs,
                                header, chunk_ptr, chunk_size);
                /* rellena el espacio libre con ceros para la GUI */

-               if (fs) memset(block + efs->tam_bloque - fs, 0, fs);
+               memset(block + efs->tam_bloque - fs + chunk_size
+                               + sizeof(EMUFS_TIPO1_REG_HEADER), 0,
+                               fs - chunk_size - sizeof(EMUFS_TIPO1_REG_HEADER));

                /* graba el bloque en el archivo */
                new_block_id = emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id,
                                fs - sizeof(EMUFS_TIPO1_REG_HEADER) - chunk_size, err);
                /* graba el bloque en el archivo */
                new_block_id = emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id,
                                fs - sizeof(EMUFS_TIPO1_REG_HEADER) - chunk_size, err);


@@ -344,23 +359,34 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                PERR("No se pudo agregar idx");
                return EMUFS_NOT_FOUND;
        }
                PERR("No se pudo agregar idx");
                return EMUFS_NOT_FOUND;
        }

+       idx_data.id = header.id;
+       idx_data.bloque = block_id;
+       emufs_indice_agregar(efs->indices, reg, idx_data);

 
        return header.id;
 }
 
 
        return header.id;
 }
 

-int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
+int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k)

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

+       EMUFS_REG_ID reg_id;
+       INDICE_DATO dato;

        int err = 0; /* para almacenar código de error */
 
        int err = 0; /* para almacenar código de error */
 

-       block_id = emufs_idx_buscar_registro(efs, reg_id);
+       /*block_id = emufs_idx_buscar_registro(efs, reg_id);

        if (block_id == EMUFS_NOT_FOUND) {
                PERR("Registro no encontrado");
                return EMUFS_NOT_FOUND;
        if (block_id == EMUFS_NOT_FOUND) {
                PERR("Registro no encontrado");
                return EMUFS_NOT_FOUND;

-       }
+       }*/
+       dato = efs->indices->existe_entrada(efs->indices, k);
+       block_id = dato.bloque; /*emufs_idx_buscar_registro(emu, ID);*/
+       reg_id = dato.id;
+
+       if (reg_id == -1) return EMUFS_NOT_FOUND;
+

        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
                PERR("no se pudo reservar memoria");
                return err;
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
                PERR("no se pudo reservar memoria");
                return err;


@@ -377,12 +403,14 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
                        /* tamaño máximo ultilizable para datos en un bloque */
                        EMUFS_BLOCK_SIZE block_space
                                        = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
                        /* 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 */
+                       /* cantidad de espacio libre original del ultimo bloque */
+                       EMUFS_FREE orig_fs; 

 
                        while (1) {
 
                        while (1) {

+                               EMUFS_FREE fs; /* cantidad de espacio libre en el bloque */
+                               orig_fs = emufs_fsc_get_fs(efs, curr_block_id);

                                /* actualizo archivo de espacio libre por bloque */
                                /* actualizo archivo de espacio libre por bloque */

-                               fs = emufs_fsc_get_fs(efs, curr_block_id)
-                                       + MIN(curr_reg_header.size, block_space)
+                               fs = orig_fs + MIN(curr_reg_header.size, block_space)

                                        + sizeof(EMUFS_TIPO1_REG_HEADER);
                                if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) {
                                        PERR("no se pudo actualizar .fsc");
                                        + sizeof(EMUFS_TIPO1_REG_HEADER);
                                if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) {
                                        PERR("no se pudo actualizar .fsc");


@@ -426,11 +454,14 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
                                /* si es necesario desplazar */
                                if (offset < offset_reg_end) {
                                        /* muevo la porción de bloque a izquierda */
                                /* si es necesario desplazar */
                                if (offset < offset_reg_end) {
                                        /* muevo la porción de bloque a izquierda */

+                                       /* XXX Este memcpy() puede copiar regiones de memoria que
+                                        * se superponen, si copia de principio a fin y byte a byte
+                                        * no debería haber problema */

                                        memcpy(block + offset, block + offset_reg_end,
                                                efs->tam_bloque - offset_reg_end);
                                        /* rellena el espacio libre con ceros para la GUI */
                                        memcpy(block + offset, block + offset_reg_end,
                                                efs->tam_bloque - offset_reg_end);
                                        /* rellena el espacio libre con ceros para la GUI */

-                                       if (fs) memset(block + offset_reg_end, 0,
-                                                       efs->tam_bloque - offset_reg_end);
+                                       memset(block + efs->tam_bloque - offset_reg_end - orig_fs + offset,
+                                                       0, offset_reg_end + orig_fs - offset);

                                }
                        }
                        /* guardo el bloque en disco (actualizando espacio libre) */
                                }
                        }
                        /* guardo el bloque en disco (actualizando espacio libre) */


@@ -508,6 +539,7 @@ EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)
 
 void emufs_tipo1_compactar(EMUFS* efs)
 {
 
 void emufs_tipo1_compactar(EMUFS* efs)
 {

+#ifdef ARREGLAR

        EMUFS_BLOCK_SIZE block_space /* tamaño para datos de un bloque */
                = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
        EMUFS_REG_ID total_ids; /* cantidad total de registros en el array */
        EMUFS_BLOCK_SIZE block_space /* tamaño para datos de un bloque */
                = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
        EMUFS_REG_ID total_ids; /* cantidad total de registros en el array */


@@ -571,6 +603,7 @@ void emufs_tipo1_compactar(EMUFS* efs)
                        emufs_fsc_truncate(efs, block_id);
                }
        }
                        emufs_fsc_truncate(efs, block_id);
                }
        }

+#endif

 }
 
 EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
 }
 
 EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,


@@ -660,7 +693,7 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, EMUFS_REG_ID id,
                void *data, EMUFS_REG_SIZE size, int* err)
 {
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, EMUFS_REG_ID id,
                void *data, EMUFS_REG_SIZE size, int* err)
 {

-       emufs_tipo1_borrar_registro(efs, id);
+/*     emufs_tipo1_borrar_registro(efs, id);*/

        return emufs_tipo1_grabar_registro(efs, data, size, err);
 }
 
        return emufs_tipo1_grabar_registro(efs, data, size, err);
 }