nada importante, cosas que se escapan por tocar para probar, etc

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

diff --git a/emufs/indice_b.c b/emufs/indice_b.c
index 89a5b7715e8792c7670db4e0e1914269e6faa983..4edaca21d4921d3821bb013249be90fcfe36bb73 100644 (file)
--- a/emufs/indice_b.c
+++ b/emufs/indice_b.c
@@ -104,7 +104,6 @@ int emufs_indice_b_insertar(INDICE *idx, CLAVE clave, INDICE_DATO dato)
                                return 0;
                        }
                        
-                       /* TODO : Implementar carga de valor en clave duplicada! */
                        b_insertar_dup_en_pos(idx, claves[i].dato, dato);
                
                        if (idx->tipo_dato == IDX_STRING) {
@@ -285,11 +284,11 @@ char *b_leer_nodo(INDICE *idx, int id)
        }
 
        /* Si estoy manejando string tengo que sacar las abreviaturas */
-       if (idx->tipo_dato == IDX_STRING) {
+/*     if (idx->tipo_dato == IDX_STRING) {
                b_leer_header(out, &header);
                claves = b_leer_claves(out, &header);
                desabreviar_claves(idx, claves, &header);
-       }
+       }*/
        fclose(fp);
        return out;
 }
@@ -301,11 +300,11 @@ static void b_grabar_nodo(INDICE *idx, int id, char *data)
        B_NodoEntry *claves;
 
        /* Si las claves son de tipo string debo abreviar antes de guardar */
-       if (idx->tipo_dato == IDX_STRING) {
+/*     if (idx->tipo_dato == IDX_STRING) {
                b_leer_header(data, &header);
                claves = b_leer_claves(data, &header);
                abreviar_claves(idx, claves, &header);
-       }
+       }*/
        fp = fopen(idx->filename, "r+");
        fseek(fp, id*idx->tam_bloque, SEEK_SET);
        fwrite(data, 1, idx->tam_bloque, fp);
@@ -1151,14 +1150,18 @@ CLAVE emufs_indice_b_obtener_sig_clave(INDICE *idx, CLAVE k)
                while ((i<header.cant) && (emufs_indice_es_menor(idx, claves[i].clave, k))) i++;
                if ((i<header.cant) && (emufs_indice_es_igual(idx, claves[i].clave, k))) {                              
                                /* LA ENCONTRE! , ahora busco la siguiente clave!! */           
+                               fprintf(stderr, "Me encontre en pos %d en el padre\n", i);
                                if ((i+1)<header.cant) {
+                                       PERR("Joya, hay lugar a la derecha");
                                        if (claves[i].hijo_derecho == -1) {
+                                               PERR("Y soy hoja!!");
                                                /* Joya!, fue facil, la siguiente va en camino! */
-                                               salida = claves[i].clave;
+                                               salida = claves[i+1].clave;
                                                free(nodo);
                                                return salida;
                                        }
 
+                                       PERR("No soy hoja, busco la hoja de menor");
                                        /* Mmmmm ... la siguiente esta en uno de mis hijo */
                                        /* Necesito la mas chica de las siguientes, para eso
                                         * me voy a mi hijo derecho y de ahi bajo siempre
@@ -1178,21 +1181,34 @@ CLAVE emufs_indice_b_obtener_sig_clave(INDICE *idx, CLAVE k)
                                        return salida;
                                }
 
+                               PERR("Fuck, tengo que ir otro nodo a buscar");
                                /* Fuck, la siguiente clave la tengo que sacar de padre */
                                /* Busco al mi padre, perdido en un maremoto hace mucho,muchos
                                 * años
                                 */
                                free(nodo);
+                               if (header.padre == -1) {
+                                       salida.i_clave = -1;
+                                       return salida;
+                               }
                                nodo = b_leer_nodo(idx, header.padre);
                                b_leer_header(nodo, &header);
                                claves = b_leer_claves(nodo, &header);
                                i = 0;
-                               while ((i<header.cant) && (emufs_indice_es_menor(idx, claves[i].clave, k))) i++;
-                               if (i<header.cant)
+                               PERR("Busco mi siguiente en mi padre");
+                               fprintf(stderr, "Padre tiene %d claves\n", header.cant);
+                               while ((i<header.cant) && (emufs_indice_es_menor(idx, claves[i].clave, k))) {
+                                       i++;
+                                       fprintf(stderr, "Proximo i : %d\n", i);
+                               }
+                               if (i<header.cant) {
+                                       PERR("Siguiente clave encontrada");
                                        salida = claves[i].clave;
-                               else
+                               } else {
                                        /* No hay mas claves! */
+                                       PERR("Busque y busque pero no aparecio");
                                        salida.i_clave = -1;
+                               }
                                return salida;
                } else {
                        tmp = nodo;
@@ -1209,6 +1225,7 @@ CLAVE emufs_indice_b_obtener_sig_clave(INDICE *idx, CLAVE k)
        }
 
        /* No encontre la clave pasada, no existe */
+       PERR("No encontre la clave pasada!!");
        salida.i_clave = -1;
        return salida;
 }