Compiling version para Nico aunque la anterior deberia haber estado functional

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

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index a28b635f5a0d120031b4ba3de425ae98b04e3320..acffac856add1b0c0505aedc57858f9bd673c815 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -42,6 +42,9 @@
 #include <stdio.h>
 #include <string.h>
 
 #include <stdio.h>
 #include <string.h>
 

+CLAVE grabar_ordenado_en_bloque_tipo3(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size,
+                                       void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
+

 /** Leo un registro del archivo, devuelve NULL si no lo encuentra.**/
 void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                EMUFS_REG_SIZE* reg_size, int* err)
 /** Leo un registro del archivo, devuelve NULL si no lo encuentra.**/
 void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                EMUFS_REG_SIZE* reg_size, int* err)


@@ -337,7 +340,7 @@ int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
 }
 
 /*borra un registro de un bloque y acomoda los registros que quedan*/
 }
 
 /*borra un registro de un bloque y acomoda los registros que quedan*/

-int emufs_tipo3_borrar_registro(EMUFS *emu, CLAVE k)
+int emufs_tipo3_borrar_registro(EMUFS *emu, CLAVE k, INDICE_DATO dato1)

 {
        EMUFS_BLOCK_SIZE num_bloque;
        EMUFS_BLOCK_SIZE ptr_elim;
 {
        EMUFS_BLOCK_SIZE num_bloque;
        EMUFS_BLOCK_SIZE ptr_elim;


@@ -354,9 +357,14 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, CLAVE k)
                cant_bloques = 1;
 
        PERR("Buscando datos del registro en el indice");
                cant_bloques = 1;
 
        PERR("Buscando datos del registro en el indice");

-       dato = emu->indices->existe_entrada(emu->indices, k);
-       num_bloque = dato.bloque; /*emufs_idx_buscar_registro(emu, ID);*/
-       ID = dato.id;
+       if (emu->indices != NULL) {
+               dato = emu->indices->existe_entrada(emu->indices, k);
+               num_bloque = dato.bloque;
+               ID = dato.id;
+       } else {
+               ID = k.i_clave;
+               num_bloque = emufs_idx_buscar_registro(emu, ID);
+       }

 
        if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
                /* TODO Manejo de errores */
 
        if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
                /* TODO Manejo de errores */


@@ -364,9 +372,6 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, CLAVE k)
                return -1;
        }
 
                return -1;
        }
 

-       PERR("Borrando clave");
-       /* TODO Borrar en todos los indices!! */
-       emu->indices->borrar_entrada(emu->indices, k);

        /*apunto al registro que voy a eliminar*/
        ptr_elim = 0;
        while ( ptr_elim < emu->tam_bloque ){
        /*apunto al registro que voy a eliminar*/
        ptr_elim = 0;
        while ( ptr_elim < emu->tam_bloque ){


@@ -427,6 +432,9 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, CLAVE k)
        }
 
        free(bloque);
        }
 
        free(bloque);

+       PERR("Borrando claves");
+       emufs_indice_borrar(emu->indices, k, dato1);
+       PERR("Clave borrada de todos los indices");

        return 0;
 }
 
        return 0;
 }
 


@@ -477,9 +485,9 @@ EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
        return stats;   
 }
 
        return stats;   
 }
 

-EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
+EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, CLAVE k, void *data, EMUFS_REG_SIZE size, int *error, INDICE_DATO dato)

 {
 {

-       /*emufs_tipo3_borrar_registro(emu, id);*/
+       emufs_tipo3_borrar_registro(emu, k, dato);

        return emufs_tipo3_grabar_registro(emu, data, size, error);
 }
 
        return emufs_tipo3_grabar_registro(emu, data, size, error);
 }
 


@@ -580,7 +588,239 @@ void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
        (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 }
 
        (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 }
 

-int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, CLAVE clave, int offset, EMUFS_BLOCK_ID num_bloque, int *err)
+int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
+{
+       CLAVE clave;
+       EMUFS_BLOCK_ID num_bloque = emufs_get_new_block_number(emu); 
+       EMUFS_REG_SIZE tam_reg, move_size;
+       INDEX_DAT query;
+       EMUFS_FREE fs;
+       char *bloque, *aux, *new_bloque;
+       int cant_reg, i, result, dif;
+       EMUFS_REG_ID header;
+       /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
+       query.num_bloque = num_bloque;  
+       /*saco la clave del stream*/
+       query.clave = emufs_indice_generar_clave(emu->indices, ptr);
+       /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
+       /*en query->num_bloque tengo el bloque donde debo meter el registro*/
+       /*debo insertar el reg en el bloque en forma ordenada*/
+       /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
+       /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
+       /* emufs_b_plus_get_bloque retorna asi
+       -1 = Nuevo bloque, retorno idem num_bloque que ingreso
+       0 = Sin problemas, retorno bloque donde insertar
+       1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
+       */
+       result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
+       if (result == 1){
+               PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
+               return -1;
+       }
+       if ( result == -1 ){            
+               /*creo un bloque nuevo*/
+               bloque = (char*) malloc(emu->tam_bloque);
+               if (bloque == NULL){
+                       PERR("NO SE PUDO CREAR EL BLOQUE");
+                       return -1;
+               }
+               header = emufs_idx_get_new_id(emu, err);
+               cant_reg = 1;
+               /*pongo la cabecera en el registro*/
+               memcpy(bloque, &header, sizeof(EMUFS_REG_ID)); 
+               /*inserto el footer en el bloque*/
+               memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
+               /*inserto el registro en el bloqude*/
+               if ( size <= emu->tam_bloque-sizeof(EMUFS_REG_ID)-sizeof(int) )
+                       memcpy(bloque+sizeof(EMUFS_REG_ID), ptr, size); 
+               else {
+                       PERR("NO ENTRA EL REGISTRO EN EL BLOQUE!!!!!");
+                       free(bloque);
+                       return -1;
+               }
+               /*hago lugar en el archivo para grabar*/
+               if ( num_bloque != emufs_create_new_block(emu) ) PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
+               /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
+               emufs_tipo3_grabar_bloque(emu, bloque, query.num_bloque);
+               /*agrego la clave al arbol*/
+               emufs_b_plus_insertar(emu->indices, &query);
+               free(bloque);
+               return 0;
+       } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
+               /*leo el bloque correspondiente*/
+               bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
+               /*me fijo cuantos registros hay en el */
+               memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+               /*me fijo si entra en nuevo reg en el bloque */
+               fs = emu->tam_bloque;
+               aux = bloque;
+               tam_reg = size;
+               for (i=0; i<cant_reg; i++){
+                       aux += sizeof(EMUFS_REG_ID)+tam_reg;
+                       fs -= (tam_reg+sizeof(EMUFS_REG_ID));
+               } /*aca deberia estar apuntando al final de los registros. espacio libre*/
+               fs -= sizeof(int); /*footer*/
+               if ( fs >= size+sizeof(EMUFS_REG_ID) ){ /* puedo meter el registro en este bloque*/     
+                       grabar_ordenado_en_bloque_tipo3(emu, ptr, size, bloque, query.num_bloque, fs, err);
+                       /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/
+                       return 0;
+               /*aca va lo que saque*/
+               } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
+                       new_bloque = (char*)malloc(emu->tam_bloque);
+                       move_size=0;
+                       for(i=0; i<cant_reg/2; i++){ /*copio mitad aca y mitad en el nuevo*/
+                               /*avanzo*/
+                               aux += sizeof(EMUFS_REG_ID)+tam_reg;
+                               move_size += sizeof(EMUFS_REG_ID)+tam_reg;
+                       }
+                       /*copio el resto del bloque al nuevo bloque*/
+                       memcpy(new_bloque, aux, emu->tam_bloque-move_size);
+                       /*borro lo que sobra en el bloque original, guardando el footer*/
+                       memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
+                       /*actualizo la cant de registros (footer)*/
+                       memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
+                       /*grabo el bloque original*/
+                       emufs_tipo3_grabar_bloque(emu, bloque, num_bloque);
+                       /*actualizo el footer del nuevo bloque*/
+                       dif = cant_reg - i; /*por las dudas*/
+                       memcpy(new_bloque+emu->tam_bloque, &dif, sizeof(int));
+                       /*genero un nuevo espacio para un bloque en el archivo y lo cargo en query
+                         la clave ya estaba en query desde antes*/
+                       query.num_bloque = emufs_create_new_block(emu);
+                       /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
+                       clave = grabar_ordenado_en_bloque_tipo3(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);
+                       /*actualizo el arbol con la nueva clave*/
+                       emufs_b_plus_insertar(emu->indices, &query);
+                       free(new_bloque);
+                       free(bloque);
+                       return 0;
+               }
+       }
+       return 0;
+}
+
+/*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/
+CLAVE grabar_ordenado_en_bloque_tipo3(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, EMUFS_FREE fs, int *err)

 {
 {

+       char *aux, *new_bloque;
+       int cant_reg, i, j;
+       EMUFS_REG_SIZE tam_reg;
+       EMUFS_REG_ID header;
+       CLAVE clave, clave_ajena;
+       
+       /*saco la cant de registros del bloque*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       /*obtengo la clave del nuevo registro*/
+       clave = emufs_indice_generar_clave(emu->indices, ptr);
+       /*cargo el header*/
+       header = emufs_idx_get_new_id(emu, err);
+       cant_reg++; /*voy a poner un reg mas*/
+       new_bloque = (char*)malloc(emu->tam_bloque);
+       aux = new_bloque;
+       tam_reg = size;
+       for (i=0; i<cant_reg+1; i++){
+               bloque += sizeof(EMUFS_REG_ID); /*salteo el encabezado del registro*/
+               if ( emu->tam_bloque-fs < sizeof(EMUFS_REG_ID)+emu->indices->offset ){
+                       PERR("ESTOY LEYENDO FUERA DEL BLOQUE!!!");
+                       free(new_bloque);
+                       *err = -1;
+                       return clave;
+               }
+               clave_ajena = emufs_indice_generar_clave(emu->indices, bloque); /*leo la clave*/
+               bloque -= sizeof(EMUFS_REG_ID); /*vuelvo al principio*/
+               if (  i<cant_reg && emufs_indice_es_menor(emu->indices, clave_ajena, clave) ){
+                       /*copio el reg al bloque nuevo*/
+                       memcpy(new_bloque, bloque, sizeof(EMUFS_REG_ID)+tam_reg);
+                       bloque += sizeof(EMUFS_REG_ID)+ tam_reg; /*paso al proximo*/
+                       new_bloque += sizeof(EMUFS_REG_ID)+ tam_reg; /*dejo preparado*/
+                       continue;
+               } else {
+                       /*meto el registro que me mandan*/
+                       memcpy(new_bloque, &header, sizeof(EMUFS_REG_ID));
+                       memcpy(new_bloque+sizeof(EMUFS_REG_ID), ptr, size);
+                       new_bloque += sizeof(EMUFS_REG_ID)+size;
+                       /*tengo que copiar los que faltan*/
+                       j = i;
+                       while ( j < cant_reg ){
+                               memcpy(new_bloque, bloque, sizeof(EMUFS_REG_ID)+tam_reg);
+                               bloque += sizeof(EMUFS_REG_ID)+tam_reg;
+                               new_bloque += sizeof(EMUFS_REG_ID)+tam_reg;
+                               j++;
+                       }
+               break; /*corto el for porque ya inserte todos*/
+               }
+       }
+       /*grabo el bloque en el archivo*/
+       new_bloque = aux; /*apunto al principio del bloque*/
+       emufs_tipo3_grabar_bloque(emu, new_bloque, num_bloque);
+       clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
+       free(new_bloque);
+       return clave;
+}
+
+int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
+{
+       char *bloque, *aux;
+       INDEX_DAT query;
+       int result, iter, cant_reg;
+       EMUFS_REG_SIZE tam_reg;
+       CLAVE clave_ajena;
+       /*cargo el query para buscar*/
+       query.num_bloque = 0;
+       query.clave = clave;
+       /*mando a buscar el bloque donde esta la clave que quiero eliminar*/
+       result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
+       if ( result == 1 ){
+               PERR("SE PRODUJO UN ERROR EN EL ARBOL");
+               return -1;
+       }
+       if ( result == -1 ){
+               PERR("NO EXISTE EL BLOQUE ¿?¿?¿?");
+               return -1;
+       }
+       /*cargo el bloque que corresponde*/
+       bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
+       if ( bloque == NULL ){
+               PERR("NO SE CARGO EL BLOQUE");
+               return -1;
+       }
+       /*leo la cantidad de registros en el bloque*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       /*busco y elimino*/
+       iter = 0;
+       aux = bloque;
+       /*me fijo si el que tengo que eliminar es el ancla del bloque*/
+       clave_ajena = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_REG_ID));
+       if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
+               /* TENGOQ QUE BORRAR LA CLAVE DEL ARBOL !!!!*/
+               /* Y HAY QUE BORRAR EL BLOQUE DEL ARCHIVO*/
+       }
+       memcpy(&tam_reg, aux, sizeof(EMUFS_REG_SIZE));
+       while ( iter < emu->tam_bloque ){
+               clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
+               if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
+                       /*tenngo que borrar este registro*/
+                       /*limpio el espacio que ocupaba*/
+                       memset(aux, 0, tam_reg+sizeof(EMUFS_REG_ID));
+                       /*hay que reacomodar todo*/
+                       /*me posiciono en el reg siguiente*/
+                       iter += tam_reg+sizeof(EMUFS_REG_ID);
+                       break;/*ya borre, corto aca*/
+               }
+               iter += tam_reg+sizeof(EMUFS_REG_ID);
+               aux += iter;
+       }
+       
+       /*reacomodo el bloque */
+       memcpy(bloque+iter-tam_reg-sizeof(EMUFS_REG_ID), aux+iter, emu->tam_bloque-iter-sizeof(int)); 
+       /*le vuelvo a copiar la cantidad de registros*/
+       cant_reg--;
+       memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
+       /*grabo el bloque en el archivo*/
+       if ( emufs_tipo3_grabar_bloque(emu, bloque, query.num_bloque) != 0 ){
+               PERR("NO SE PUDO GRABAR EL BLOQUE");
+               return -1;
+       }
+       free(bloque);

        return 0;
 }
        return 0;
 }