no se como voy a hacer para probarlo

diff --git a/emufs/b_plus.c b/emufs/b_plus.c
index 462a237482a4a43550ba500bec6a1235f7b8f38a..99e0b24b3482051b116bd1eba5e34641af11e345 100644 (file)
--- a/emufs/b_plus.c
+++ b/emufs/b_plus.c
@@ -1,7 +1,7 @@
 /** Arbol B+ */
 #include "b_plus.h"
 #include <math.h>
-
+#define INDEXSPECS INDICE
 /**#*#*#*#*#**#*#*#*#*#* Private prototypes*#*#*#*#*#**#*#*#*#*#**#*#*#*/
 /* numerando los bloques */
 int b_plus_grabar_nodo(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_node);

diff --git a/emufs/b_plus.h b/emufs/b_plus.h
index ba0b775afbb78b07163c3f9b2997f08857305b97..a321ab54268b6f9ceb0507b253f53a40f058449f 100644 (file)
--- a/emufs/b_plus.h
+++ b/emufs/b_plus.h
@@ -5,18 +5,18 @@
 #include "emufs.h"\r
 \r
 #define SIZE_B_PLUS_HEADER (sizeof(int)*2)\r
-\r
+#define INDEXSPECS INDICE\r
 /** Estructura que define un nodo B+. Para los nodos hojas, el ultimo valor de hijo, será el nro\r
  *  de nodo con el que se encadena el actual. (Lista de nodos a nivel hoja. Sequence Set).\r
  */\r
- \r
+/* \r
 typedef struct _indexspecs_ {\r
        unsigned int tam_bloque;\r
        unsigned int size_claves;\r
        unsigned int size_hijos;\r
        char *filename;\r
 } INDEXSPECS;\r
-\r
+*/\r
 typedef struct _index_dat_ {\r
        EMUFS_BLOCK_ID num_bloque;\r
        CLAVE clave;\r

diff --git a/emufs/indices.h b/emufs/indices.h
index ad2686c340c757402337c8112a908584852ad625..5ed09c7df1cc3d687c502a164365a68b99a82216 100644 (file)
--- a/emufs/indices.h
+++ b/emufs/indices.h
@@ -56,6 +56,10 @@ typedef struct _indices_h_ {
        int offset;                   /**< Offset desde el inicio del dato hasta el lugar donde esta la clave */
        unsigned int tam_bloque;      /**< Tamaño del bloque (nodo). Deber set multiplo de 512! */
 
+       /******NICO********/
+       unsigned int size_claves;
+       unsigned int size_hijos;
+       /******NICO********/
        /** Agrega la clave k de posicion location en el 
         * indice de forma ordenada
         */

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 98ddb6e7759d1e63f19114c0941d7124f1f5113f..1172e4ff44eff9175809de8ae872f82e67c4cf8c 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -76,7 +76,7 @@ static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
                EMUFS_BLOCK_ID, EMUFS_FREE, int*);
 
 
-CLAVE insertar_odenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, int *err);
+CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, int *err);
 
 /*------------------ Funciones públicas ----------------------*/
 
@@ -796,14 +796,14 @@ void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
 
 int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 {
-       #ifdef ESTO_NO_ANDA_TODAVIA
-       CLAVE clave, clave_ajena;
+       CLAVE clave;
        EMUFS_BLOCK_ID num_bloque = get_new_block_number(emu); 
        EMUFS_TIPO1_REG_HEADER header;
-       EMUFS_REG_SIZE tam_reg;
+       EMUFS_REG_SIZE tam_reg, move_size;
        INDEX_DAT query;
-       char *bloque, *aux, *new_bloque, *registro;
-       int cant_reg, i, j;
+       EMUFS_FREE fs;
+       char *bloque, *aux, *new_bloque;
+       int cant_reg, i;
        
        /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
        query.num_bloque = num_bloque;  
@@ -814,14 +814,14 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
        /*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*/
-       if ( emu->indices->emufs_b_plus_get_bloque(ind, &query) == -1 ){
+       if ( emufs_b_plus_get_bloque(emu->indices, &query) == -1 ){
                /*creo un bloque nuevo*/
                bloque = (char*) malloc(emu->tam_bloque);
                if (bloque == NULL){
                        PERR("NO SE PUDO CREAR EL BLOQUE");
                        return -1;
                }
-               header.id = emufs_idx_get_new_id(efs, err);
+               header.id = emufs_idx_get_new_id(emu, err);
                header.size = size;
                cant_reg = 1;
                /*pongo la cabecera en el registro*/
@@ -839,7 +839,7 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                /*hago lugar en el archivo para grabar*/
                if ( num_bloque != create_new_block(emu) )      PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
-               emufs_tipo1_grabar_bloque_fsc(emu, bloque, query->num_bloque, EMUFS_NOT_FOUND, err);
+               emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err);
                /*agrego la clave al arbol*/
                emufs_b_plus_insertar(emu->indices, &query);
                free(bloque);
@@ -854,25 +854,47 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                for (i=0; i<cant_reg; i++){
                        memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                        aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
-                       fs -= (tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
+                       fs -= (tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));
                } /*aca deberia estar apuntando al final de los registros. espacio libre*/
                fs -= sizeof(int); /*footer*/
                if ( fs >= size ){ /* puedo meter el registro en este bloque*/  
-                       insertar_odenado_en_bloque(emu, ptr, size, bloque, query->num_bloque, err);
+                       grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, 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);
-                       for(i=0; i<cant_reg/2; i++);
-                               
-       #endif
+                       move_size=0;
+                       for(i=0; i<cant_reg/2; i++){ /*copio mitad aca y mitad en el nuevo*/
+                               /*avanzo*/
+                               memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
+                               aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
+                               move_size += sizeof(EMUFS_TIPO1_REG_HEADER)+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));
+                       /*grabo el bloque original*/
+                       emufs_tipo1_grabar_bloque_fsc(emu, bloque, num_bloque, EMUFS_NOT_FOUND, err);
+                       /*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 = create_new_block(emu);
+                       /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
+                       clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, 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 insertar_odenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, int *err)
+CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, int *err)
 {
-       /*#ifdef CAMBIAR*/
        char *aux, *new_bloque;
        int cant_reg, tam_reg, i, j;
        EMUFS_TIPO1_REG_HEADER header;
@@ -920,12 +942,10 @@ CLAVE insertar_odenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, voi
                break; /*corto el for porque ya inserte todos*/
                }
        }
-       free(bloque);/*no lo uso mas*/
        /*grabo el bloque en el archivo*/
        new_bloque = aux; /*apunto al principio del bloque*/
        emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, num_bloque, EMUFS_NOT_FOUND, err);
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
        free(new_bloque);
        return clave;
-       /*#endif CAMBIAR*/
 }