Piloteado de mini bug que pudiera existir en insertar ordenado, siempre se devuelve...

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

diff --git a/emufs/indice_b_asc.c b/emufs/indice_b_asc.c
index fa688f46cea7b9fc001ee69cae9025564e0e7df0..42903c4b12abb7cd5f83bdb8e26a33fc580f0431 100644 (file)
--- a/emufs/indice_b_asc.c
+++ b/emufs/indice_b_asc.c
@@ -90,8 +90,8 @@ static void b_asc_insertar_en_nodo(INDICE *idx, CLAVE clave, INDICE_DATO dato, i
                        if (nodo_id != 0) {
                                int izq_id, der_id, pos_padre, i;
                                B_NodoHeader padre_header, header_der, header_izq;
-                               B_NodoEntry *padre_claves;
-                               B_NodoEntry a_pasar, *buffer;
+                               B_NodoEntry *padre_claves, nuevo_entry;
+                               B_NodoEntry a_pasar, *buffer, clave_que_sale;
 
                                b_leer_header(padre, &padre_header);
                                padre_claves = b_leer_claves(padre, &padre_header);
@@ -127,14 +127,18 @@ static void b_asc_insertar_en_nodo(INDICE *idx, CLAVE clave, INDICE_DATO dato, i
 
                                buffer = malloc((nodo_header.cant+1)*sizeof(B_NodoEntry));
 
+                               nuevo_entry.clave = clave;
+                               nuevo_entry.dato = dato;
+                               nuevo_entry.hijo_derecho = hijo2;
+                               
                                /* Inserto ordenado */
                                for(i=0; (i<nodo_header.cant) && emufs_indice_es_menor(idx, claves[i].clave, clave); i++)
                                        buffer[i] = claves[i];
-                               buffer[i].clave = clave;
-                               buffer[i].dato = dato;
-                               buffer[i].hijo_derecho = hijo2;
-                               while (i<nodo_header.cant)
+                               buffer[i] = nuevo_entry;
+                               while (i<nodo_header.cant) {
                                        buffer[i+1] = claves[i];
+                                       i++;
+                               }
 
                                if ((der_id != -1) && (header_der.cant < CANT_HIJOS(idx))) {
                                        /* tomo la clave mas grande */
@@ -142,26 +146,48 @@ static void b_asc_insertar_en_nodo(INDICE *idx, CLAVE clave, INDICE_DATO dato, i
 
                                        /* la paso a la derecha */
                                        b_pasar_clave_a_derecha(idx, der, der_id, padre, nodo_header.padre, pos_padre, a_pasar);
-                                       /* XXX TODO Liberar memoria y GUARDAR*/
+                                       /* Dejo en nodo las claves que corresponden */
+                                       memcpy(claves, buffer, nodo_header.cant*sizeof(B_NodoEntry));
+                                       b_grabar_nodo(idx, der_id, der);
+                                       b_grabar_nodo(idx, nodo_header.padre, padre);
+                                       b_grabar_nodo(idx, nodo_id, nodo);
                                        free(buffer);
-                               
+                                       free(nodo);
+                                       free(der);
+                                       free(padre);
                                        return;
                                } 
                        
                                if ((izq_id != -1) && (header_izq.cant < CANT_HIJOS(idx))) {
+                                       PERR("ESTOY PASANDO CLAVE A IZQUIERDA");
                                        a_pasar = buffer[0];
-                                       b_pasar_clave_a_izquierda(idx, izq, izq_id, padre, nodo_header.padre, pos_padre, a_pasar, 0, 0);
+                                       fprintf(stderr, "YO=%d , a_pasar=%d\n", clave.i_clave, a_pasar.clave.i_clave);
+                                       b_pasar_clave_a_izquierda(idx, izq, izq_id, padre, nodo_header.padre, pos_padre, a_pasar, hijo1, padre_claves[pos_padre].hijo_derecho);
+                                       /* Pongo las claves que quedan en el nodo */
+                                       memcpy(claves, buffer+1, nodo_header.cant*sizeof(B_NodoEntry));
+                                       b_grabar_nodo(idx, izq_id, izq);
+                                       b_grabar_nodo(idx, nodo_header.padre, padre);
+                                       b_grabar_nodo(idx, nodo_id, nodo);
                                        free(buffer);
+                                       free(nodo);
+                                       free(izq);
+                                       free(padre);
                                        return;
                                }
-                        
-                               /*
+                       
+                               /* Tengo que partir, tengo que sacar una clave del padre y mandarla al partir */
+                               clave_que_sale = padre_claves[pos_padre];
+                               clave_que_sale.hijo_derecho = -1;
+                               for(i=pos_padre; i<padre_header.cant-1; i++)
+                                       padre_claves[i] = padre_claves[i+1];
+                               padre_header.cant--;
+                               b_actualizar_header(padre, &padre_header);
+                               b_grabar_nodo(idx, nodo_header.padre, padre);
                                if (izq_id != -1)
-                                       b_partir_dos_nodos_en_tres(idx, hijo_izquierdo, nodo, padre, nuevo_entry)
+                                       b_partir_dos_nodos_en_tres(idx, izq_id, nodo_id, clave_que_sale, nuevo_entry, nodo_header.padre);
                                else // Siempre alguno tiene que existir.
-                                       b_partir_dos_nodos_en_tres(idx, nodo, hijo_derecho, padre, nuevo_entry)
+                                       b_partir_dos_nodos_en_tres(idx, nodo_id, der_id, clave_que_sale, nuevo_entry, nodo_header.padre);
                                return;
-                               */
                        }
 
                        /* Bueno, soy la raiz, tengo que tratarla como el arbol B */