Ya casi lo tenemo al muchacho insertar...

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

diff --git a/emufs/indice_b.c b/emufs/indice_b.c
index afb6b8ecdf68ba818eb271806ec547a492f06aaa..bf07a88577b872dbbb20df24da9a28723973779e 100644 (file)
--- a/emufs/indice_b.c
+++ b/emufs/indice_b.c
@@ -2,7 +2,7 @@
 #include "indice_b.h"
 #include "common.h"
 #include "emufs.h"
 #include "indice_b.h"
 #include "common.h"
 #include "emufs.h"

-#include <curses.h>
+#include "form.h"

 
 /* Cantidad de claves por nodo */
 #define CANT_HIJOS(x) ((x->tam_bloque-sizeof(B_NodoHeader))/sizeof(B_NodoEntry))
 
 /* Cantidad de claves por nodo */
 #define CANT_HIJOS(x) ((x->tam_bloque-sizeof(B_NodoHeader))/sizeof(B_NodoEntry))


@@ -14,18 +14,10 @@
 static void b_grabar_nodo(INDICE *idx, int id, char *data);
 /** Da el ID del proximo nodo a poder ser utilizado */
 static int b_ultimo_id(INDICE *idx);
 static void b_grabar_nodo(INDICE *idx, int id, char *data);
 /** Da el ID del proximo nodo a poder ser utilizado */
 static int b_ultimo_id(INDICE *idx);

-/** Lee un nodo desde el archivo */
-static char *b_leer_nodo(INDICE *idx, int id);

 /** Crea un nodo en el archivo y lo retorna. En i se pone el ID asignado */
 static char *b_crear_nodo(INDICE *idx, int *i);
 /** Crea un nodo en el archivo y lo retorna. En i se pone el ID asignado */
 static char *b_crear_nodo(INDICE *idx, int *i);

-/** Lee el header de un nodo y lo guarda en header */
-static void b_leer_header(char *src, B_NodoHeader *header);

 /** Actualiza el header de un nodo desde header */
 static void b_actualizar_header(char *src, B_NodoHeader *header);
 /** Actualiza el header de un nodo desde header */
 static void b_actualizar_header(char *src, B_NodoHeader *header);

-/** Retorna el array de claves del nodo (esta data modifica directamente el bloque
- *  por eso no es necesario usar un actualizar_claves 
- */
-static B_NodoEntry *b_leer_claves(char *src, B_NodoHeader *header);

 /** Inserta una clave en el nodo de manera iterativa.
  * \param idx Índice en donde insertar la clave.
  * \param clave Clave a insertar.
 /** Inserta una clave en el nodo de manera iterativa.
  * \param idx Índice en donde insertar la clave.
  * \param clave Clave a insertar.


@@ -222,6 +214,7 @@ int emufs_indice_b_borrar(INDICE *idx, CLAVE k)
 
        if (encontrado) {
                PERR("Clave encontrada, borrando ...");
 
        if (encontrado) {
                PERR("Clave encontrada, borrando ...");

+               fprintf(stderr, "La clave a borrar esta en el nodo %d\n", nodo_id);

                b_borrar_clave(idx, nodo, nodo_id, k);
        } else {
                PERR("Clave no encontrada");
                b_borrar_clave(idx, nodo, nodo_id, k);
        } else {
                PERR("Clave no encontrada");


@@ -262,7 +255,7 @@ static char *b_crear_nodo(INDICE *idx, int *id)
        return bloque;
 }
 
        return bloque;
 }
 

-static char *b_leer_nodo(INDICE *idx, int id)
+char *b_leer_nodo(INDICE *idx, int id)

 {
        FILE *fp;
        char *out;
 {
        FILE *fp;
        char *out;


@@ -317,7 +310,7 @@ static void b_grabar_nodo(INDICE *idx, int id, char *data)
        fclose(fp);
 }
 
        fclose(fp);
 }
 

-static void b_leer_header(char *src, B_NodoHeader *header)
+void b_leer_header(char *src, B_NodoHeader *header)

 {
        if (!src) return;
 
 {
        if (!src) return;
 


@@ -330,7 +323,7 @@ static void b_actualizar_header(char *src, B_NodoHeader *header)
        memcpy(src, header, sizeof(B_NodoHeader));
 }
 
        memcpy(src, header, sizeof(B_NodoHeader));
 }
 

-static B_NodoEntry *b_leer_claves(char *src, B_NodoHeader *header)
+B_NodoEntry *b_leer_claves(char *src, B_NodoHeader *header)

 {
        return (B_NodoEntry *)(src+sizeof(B_NodoHeader));
 }
 {
        return (B_NodoEntry *)(src+sizeof(B_NodoHeader));
 }


@@ -616,6 +609,7 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k)
        while (emufs_indice_es_menor(idx, claves[pos].clave, k)) pos++;
 
        /* Es el nodo una hoja? */
        while (emufs_indice_es_menor(idx, claves[pos].clave, k)) pos++;
 
        /* Es el nodo una hoja? */

+       fprintf(stderr, "La clave esta en la pos = %d\n", pos);

        if (header.hijo_izquierdo != -1) {
                PERR("Nodo no es hoja, intercambio");
                /* No!, es un nodo intermedio!! */
        if (header.hijo_izquierdo != -1) {
                PERR("Nodo no es hoja, intercambio");
                /* No!, es un nodo intermedio!! */


@@ -640,11 +634,14 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k)
        } else {
                PERR("Nodo es hoja");
                actual = nodo;
        } else {
                PERR("Nodo es hoja");
                actual = nodo;

+               header_actual = header;
+               claves_actual = claves;
+               actual_id = nodo_id;

        }
 
        /* Borro la clave */
        PERR("Borrando clave");
        }
 
        /* Borro la clave */
        PERR("Borrando clave");

-       for(i=pos; i < header_actual.cant; i++) {
+       for(i=pos; i < header_actual.cant-1; i++) {

                claves_actual[i] = claves_actual[i+1];
        }
        PERR("Borrado completo");
                claves_actual[i] = claves_actual[i+1];
        }
        PERR("Borrado completo");


@@ -655,6 +652,7 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k)
 
        /* Se cumple la condicion de hijos? */
        PERR("Dejo todo consistente");
 
        /* Se cumple la condicion de hijos? */
        PERR("Dejo todo consistente");

+       fprintf(stderr, "Condicion : %d >= %d\n", header_actual.cant, MIN_HIJOS(idx));

        if (header_actual.cant >= MIN_HIJOS(idx)) {
                PERR("Borrar completo sin fundir");
                return;
        if (header_actual.cant >= MIN_HIJOS(idx)) {
                PERR("Borrar completo sin fundir");
                return;


@@ -678,7 +676,7 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k)
                        b_leer_header(der, &header_der);
                } else {
                        PERR("Buscando que hijo soy");
                        b_leer_header(der, &header_der);
                } else {
                        PERR("Buscando que hijo soy");

-                       for(pos_padre=0; (pos_padre<header_padre.cant) && (claves_padre[pos_padre].hijo_derecho != actual_id); pos_padre++)     {       }
+                       for(pos_padre=0; (claves_padre[pos_padre].hijo_derecho != actual_id); pos_padre++)      {       }

 
                        if (pos_padre == header_padre.cant) {
                                PERR("ERROR GRAVE. Padre no me contiene :-(");
 
                        if (pos_padre == header_padre.cant) {
                                PERR("ERROR GRAVE. Padre no me contiene :-(");


@@ -708,11 +706,20 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k)
                PERR("Ta calcule lo que tengo que hacer");
                if ((derecha_id != -1) && (header_der.cant > MIN_HIJOS(idx))) {
                        PERR("Le pido clave a derecha");
                PERR("Ta calcule lo que tengo que hacer");
                if ((derecha_id != -1) && (header_der.cant > MIN_HIJOS(idx))) {
                        PERR("Le pido clave a derecha");

+                       fprintf(stderr, "ANTES DE PEDIR DERECHA TENGO %d claves\n", header_actual.cant);

                        b_pedir_clave_derecha(der, derecha_id, padre, padre_id, actual, actual_id, pos_padre);
                        PERR("listo");
                        b_pedir_clave_derecha(der, derecha_id, padre, padre_id, actual, actual_id, pos_padre);
                        PERR("listo");

+                       b_leer_header(der, &header_der);
+                       b_leer_header(padre, &header_padre);
+                       b_leer_header(actual, &header_actual);
+                       fprintf(stderr, "DESPUES DE PEDIR DERECHA TENGO %d claves\n", header_actual.cant);

                } else if ((izquierda_id != -1) && (header_izq.cant > MIN_HIJOS(idx))) {
                        PERR("Le pido clave a izquierda");
                } else if ((izquierda_id != -1) && (header_izq.cant > MIN_HIJOS(idx))) {
                        PERR("Le pido clave a izquierda");

-                       b_pedir_clave_izquierda(izq, izquierda_id, padre, padre_id, actual, actual_id, pos_padre-1);
+                       b_pedir_clave_izquierda(izq, izquierda_id, padre, padre_id, actual, actual_id, pos_padre);
+                       /* como se modificaron cosas, leo de nuevo los headers */
+                       b_leer_header(izq, &header_izq);
+                       b_leer_header(padre, &header_padre);
+                       b_leer_header(actual, &header_actual);

                        PERR("Listo");
                } else {
                        /* No pude pasar clave, tengo que fundir :-( */
                        PERR("Listo");
                } else {
                        /* No pude pasar clave, tengo que fundir :-( */


@@ -726,16 +733,17 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k)
 
                /* TODO que guardo ?, todo ? */
                b_grabar_nodo(idx, actual_id, actual);
 
                /* TODO que guardo ?, todo ? */
                b_grabar_nodo(idx, actual_id, actual);

-               b_grabar_nodo(idx, izquierda_id, izq);
-               b_grabar_nodo(idx, derecha_id, der);
-               b_grabar_nodo(idx, padre_id, padre);
+               if (izquierda_id != -1) b_grabar_nodo(idx, izquierda_id, izq);
+               if (derecha_id != -1) b_grabar_nodo(idx, derecha_id, der);
+               if (padre_id != -1) b_grabar_nodo(idx, padre_id, padre);

                if (actual_id != -1) free(actual);
                if (actual_id != -1) free(actual);

-               /*if (padre_id != -1) free(padre);*/

                if (derecha_id != -1) free(der);
                if (izquierda_id != -1) free(izq);
                actual = padre;
                actual_id = padre_id;
                if (derecha_id != -1) free(der);
                if (izquierda_id != -1) free(izq);
                actual = padre;
                actual_id = padre_id;

-       } while ((actual_id != -1) && (header_actual.cant < MIN_HIJOS(idx)));
+               b_leer_header(actual, &header_actual);
+               claves_actual = b_leer_claves(actual, &header_actual);
+       } while ((actual_id != -1) && (actual_id != 0) && (header_actual.cant < MIN_HIJOS(idx)));

 }
 
 static void b_pedir_clave_derecha(char *der, int der_id, char *padre, int padre_id, char *nodo, int nodo_id, int pos_clave)
 }
 
 static void b_pedir_clave_derecha(char *der, int der_id, char *padre, int padre_id, char *nodo, int nodo_id, int pos_clave)


@@ -751,14 +759,14 @@ static void b_pedir_clave_derecha(char *der, int der_id, char *padre, int padre_
        b_leer_header(padre, &h_padre);
        c_padre = b_leer_claves(padre, &h_padre);
 
        b_leer_header(padre, &h_padre);
        c_padre = b_leer_claves(padre, &h_padre);
 

-       c_nodo[h_nodo.cant] = c_padre[pos_clave];
+       c_nodo[h_nodo.cant] = c_padre[pos_clave+1];

        c_nodo[h_nodo.cant].hijo_derecho = -1; /* XXX */
 
        c_nodo[h_nodo.cant].hijo_derecho = -1; /* XXX */
 

-       c_padre[pos_clave] = c_der[0];
-       c_padre[pos_clave].hijo_derecho = der_id;
+       c_padre[pos_clave+1] = c_der[0];
+       c_padre[pos_clave+1].hijo_derecho = der_id;

        
        /* Muevo las claves de derecho */
        
        /* Muevo las claves de derecho */

-       for(i=0; i<h_der.cant; i++) {
+       for(i=0; i<h_der.cant-1; i++) {

                c_der[i] = c_der[i+1];
        }
        h_der.cant--;
                c_der[i] = c_der[i+1];
        }
        h_der.cant--;


@@ -797,19 +805,24 @@ void b_pedir_clave_izquierda(char *izq, int izq_id, char *padre, int padre_id, c
        b_leer_header(padre, &h_padre);
        c_padre = b_leer_claves(padre, &h_padre);
 
        b_leer_header(padre, &h_padre);
        c_padre = b_leer_claves(padre, &h_padre);
 

-       for(i=h_nodo.cant; i>0;i++)
+       PERR("Muevo las claves");
+       for(i=h_nodo.cant; i>0;i--)

                c_nodo[i] = c_nodo[i-1];
 
        h_nodo.cant++;
                c_nodo[i] = c_nodo[i-1];
 
        h_nodo.cant++;

+       PERR("Paso clave de padre a nodo");

        c_nodo[0] = c_padre[pos_clave];
        c_nodo[0].hijo_derecho = -1; /* XXX */
        c_nodo[0] = c_padre[pos_clave];
        c_nodo[0].hijo_derecho = -1; /* XXX */

+       PERR("Paso clave de izquierda a padre");

        c_padre[pos_clave] = c_izq[h_izq.cant-1];
        c_padre[pos_clave] = c_izq[h_izq.cant-1];

-       c_padre[pos_clave].hijo_derecho = izq_id;
+       c_padre[pos_clave].hijo_derecho = nodo_id;

        h_izq.cant--;
 
        h_izq.cant--;
 

+       PERR("ACTUALIZO")

        b_actualizar_header(izq, &h_izq);
        b_actualizar_header(padre, &h_padre);
        b_actualizar_header(nodo, &h_nodo);
        b_actualizar_header(izq, &h_izq);
        b_actualizar_header(padre, &h_padre);
        b_actualizar_header(nodo, &h_nodo);

+       PERR("Salgo");

 }
 
 void b_pasar_clave_a_izquierda(INDICE* idx, char *izq, int izq_id, char *padre, int padre_id, int padre_pos, B_NodoEntry entry, int id_entry_hijo_izq, int id_entry_nodo)
 }
 
 void b_pasar_clave_a_izquierda(INDICE* idx, char *izq, int izq_id, char *padre, int padre_id, int padre_pos, B_NodoEntry entry, int id_entry_hijo_izq, int id_entry_nodo)


@@ -969,58 +982,3 @@ static void desabreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *he
        free(primera);
 }
 
        free(primera);
 }
 

-int emufs_indice_b_ver(INDICE *idx, WINDOW *win, int w, int h, int id)
-{
-       int y=0;
-       B_NodoHeader header;
-       B_NodoEntry *claves;
-       char *nodo;
-       char tmp[100];
-       int i;
-       int proximo;
-
-       mvwaddstr(win, y++, 0, "Nombre : ");
-       waddstr(win, idx->nombre);
-
-       /* Muestro la raiz */
-       nodo = b_leer_nodo(idx, id);
-       b_leer_header(nodo, &header);
-       claves = b_leer_claves(nodo, &header);
-
-       mvwaddstr(win, y++, 0, "Nodo Nro ");
-       sprintf(tmp, "%d", id);
-       waddstr(win, tmp);
-       mvwaddstr(win, y++, 0, "Nivel =  ");
-       sprintf(tmp, "%d", header.nivel);
-       waddstr(win, tmp);
-       mvwaddstr(win, y++, 0, "Cantidad de hijo = ");
-       sprintf(tmp, "%d", header.cant);
-       waddstr(win, tmp);
-       mvwaddstr(win, y++, 0, "Padre = ");
-       sprintf(tmp, "%d", header.padre);
-       waddstr(win, tmp);
-
-       /* Muestro las claves */
-       mvwaddstr(win, y++, 0, "Claves");
-       wmove(win, y, 0);
-       sprintf(tmp, "%d", header.hijo_izquierdo);
-       waddstr(win, tmp);
-       for(i=0; i<header.cant; i++) {
-               sprintf(tmp, "(%d)%d",
-                               claves[i].clave.i_clave,
-/*                             claves[i].dato.id,
-                               claves[i].dato.bloque,*/
-                               claves[i].hijo_derecho
-               );
-               waddstr(win, tmp);
-       }
-       free(nodo);
-       wrefresh(win);
-       proximo = getch()-'0';
-       werase(win);
-       wrefresh(win);
-       emufs_indice_b_ver(idx, win, w, h, proximo);
-       werase(win);
-       wrefresh(win);
-}
-