insertar ordenado por la mitad para tipo1, despues copio y pego para tipo3, deberia...

diff --git a/emufs/b_plus.c b/emufs/b_plus.c
index e215714ae705051ea1b053d49bf11488be5a5117..462a237482a4a43550ba500bec6a1235f7b8f38a 100644 (file)
--- a/emufs/b_plus.c
+++ b/emufs/b_plus.c
@@ -378,7 +378,7 @@ int b_plus_insert_nonfull(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_nodo, INDE
        return 0;
 }    
 
        return 0;
 }    
 

-int b_plus_insertar(INDEXSPECS *idx, INDEX_DAT *query)
+int emufs_b_plus_insertar(INDEXSPECS *idx, INDEX_DAT *query)

 {
     NODO_B_PLUS *raiz;
     
 {
     NODO_B_PLUS *raiz;
     

diff --git a/emufs/b_plus.h b/emufs/b_plus.h
index 873b5328740335ff18e518c9bcfd90481655a375..ba0b775afbb78b07163c3f9b2997f08857305b97 100644 (file)
--- a/emufs/b_plus.h
+++ b/emufs/b_plus.h
@@ -33,11 +33,11 @@ typedef struct nodo_b_plus {
 /** TODO */\r
 int emufs_b_plus_crear(INDEXSPECS *idx);\r
 int emufs_b_plus_get_bloque(INDEXSPECS *idx, INDEX_DAT *query);\r
 /** TODO */\r
 int emufs_b_plus_crear(INDEXSPECS *idx);\r
 int emufs_b_plus_get_bloque(INDEXSPECS *idx, INDEX_DAT *query);\r

+int emufs_b_plus_insertar(INDEXSPECS *idx, INDEX_DAT *query);\r

 int emufs_b_plus_actualizar_nodo(INDEX_DAT *dataset);\r
 int emufs_b_plus_buscar();\r
 int emufs_b_plus_destuir();\r
 int b_plus_insertar_clave(INDEXSPECS *, INDEX_DAT *);\r
 int emufs_b_plus_actualizar_nodo(INDEX_DAT *dataset);\r
 int emufs_b_plus_buscar();\r
 int emufs_b_plus_destuir();\r
 int b_plus_insertar_clave(INDEXSPECS *, INDEX_DAT *);\r

-int b_plus_insertar(INDEXSPECS *idx, INDEX_DAT *query);\r

 NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num);\r
 \r
 #endif
 NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num);\r
 \r
 #endif

diff --git a/emufs/b_plus_test.c b/emufs/b_plus_test.c
index 0dc7603b2677fcdbe848d5e2848dbbd0fbe60716..9e258e5bacf8468c51a949fe51242076e75a29ba 100644 (file)
--- a/emufs/b_plus_test.c
+++ b/emufs/b_plus_test.c
@@ -20,7 +20,7 @@ for (i=1;i<34;++i)
 {      
 querydata.num_bloque = i;
 querydata.clave.i_clave = i;
 {      
 querydata.num_bloque = i;
 querydata.clave.i_clave = i;

-b_plus_insertar(&indice,&querydata);
+emufs_b_plus_insertar(&indice,&querydata);

 }
 
 /*
 }
 
 /*

diff --git a/emufs/emufs.h b/emufs/emufs.h
index 7e04f55f24f8f12ce0fcc485422ebd34eb9bcf45..5befe3638098bfa267ced5bbb7ed6f06644041c4 100644 (file)
--- a/emufs/emufs.h
+++ b/emufs/emufs.h
@@ -176,4 +176,5 @@ int debug_ver_estadisticas(EMUFS *emu);
 int emufs_agregar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato,  unsigned int offset, unsigned int tam_bloque); 
 
 INDICE_DATO *emufs_buscar_registros(EMUFS *emu, char *indice, char *data, int *cant);
 int emufs_agregar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato,  unsigned int offset, unsigned int tam_bloque); 
 
 INDICE_DATO *emufs_buscar_registros(EMUFS *emu, char *indice, char *data, int *cant);

+

 #endif /* _EMUFS_H_ */
 #endif /* _EMUFS_H_ */

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index fa1c0126669f12070bc77e6b0d05a5143e5267ad..99cf50c63dc322200705ae5ba58ad9a9608d5369 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -75,6 +75,9 @@ static void* emufs_tipo1_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
 static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
                EMUFS_BLOCK_ID, EMUFS_FREE, int*);
 
 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, void *bloque, int num_bloque);
+

 /*------------------ Funciones públicas ----------------------*/
 
 int emufs_tipo1_inicializar(EMUFS* efs)
 /*------------------ Funciones públicas ----------------------*/
 
 int emufs_tipo1_inicializar(EMUFS* efs)


@@ -724,6 +727,53 @@ int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count)
        return EMUFS_OK;
 }
 
        return EMUFS_OK;
 }
 

+/*crea un bloque y devuelve en numero del mismo*/
+EMUFS_BLOCK_ID create_new_block(EMUFS *emu)
+{
+       FILE *fp;
+       char name[255];
+       char *dummy;
+       EMUFS_BLOCK_ID num;
+       
+       /* obtengo nombre del archivo */
+       strcpy(name, emu->nombre);
+       strcat(name,".dat");
+       
+       if ( (fp=fopen(name,"a+")) == NULL ){
+               PERR("NO SE PUDO ABRIR EL ARCHIVO");
+               return -1;
+       }
+       
+       dummy = (char*)malloc(emu->tam_bloque);
+       memset(dummy, 0, emu->tam_bloque);
+       fwrite(dummy, emu->tam_bloque, 1, fp);
+       
+       num = (ftell(fp)-emufs_tipo1_header_size())/emu->tam_bloque;
+       fclose(fp);
+       free(dummy);
+       return num;
+}
+
+/*devuelve un numero de bloque siguiente al ultimo*/
+EMUFS_BLOCK_ID get_new_block_number(EMUFS *emu)
+{
+       FILE *fp;
+       char name[255];
+       EMUFS_BLOCK_ID num;
+       
+       /* obtengo nombre del archivo */
+       strcpy(name, emu->nombre);
+       strcat(name,".dat");
+
+       if ( (fp=fopen(name,"a+")) == NULL ){
+               PERR("NO SE PUDO ABRIR EL ARCHIVO");
+               return -1;
+       }
+       num = (ftell(fp)-emufs_tipo1_header_size())/emu->tam_bloque;
+       fclose(fp);
+       return num+1;
+}
+

 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,
                EMUFS_TIPO1_REG_HEADER header, char* reg, EMUFS_REG_SIZE reg_size)
 {
 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,
                EMUFS_TIPO1_REG_HEADER header, char* reg, EMUFS_REG_SIZE reg_size)
 {


@@ -743,3 +793,135 @@ void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
        (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err);
        (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 }
        (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err);
        (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 }

+
+int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
+{
+       #ifdef ESTO_NO_ANDA_TODAVIA
+       CLAVE clave, clave_ajena;
+       EMUFS_BLOCK_ID num_bloque = get_new_block_number(emu); 
+       EMUFS_TIPO1_REG_HEADER header;
+       EMUFS_REG_SIZE tam_reg;
+       INDEX_DAT query;
+       char *bloque, *aux, *new_bloque, *registro;
+       int cant_reg, i, j;
+       
+       /*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*/
+       if ( emu->indices->emufs_b_plus_get_bloque(ind, &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.size = size;
+               cant_reg = 1;
+               /*pongo la cabecera en el registro*/
+               memcpy(bloque, &header, sizeof(EMUFS_TIPO1_REG_HEADER)); 
+               /*inserto el footer en el bloque*/
+               memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
+               /*inserto el registro en el bloque*/
+               if ( size <= emu->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER)-sizeof(int) )
+                       memcpy(bloque+sizeof(EMUFS_TIPO1_REG_HEADER), 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 != 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);
+               /*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_tipo1_leer_bloque(emu, 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 */
+               aux = bloque;
+               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);
+               } /*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, bloque, query->num_bloque);
+                       /*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
+}
+
+/*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/
+CLAVE insertar_odenado_en_bloque(EMUFS *emu, void *ptr, void *bloque, int num_bloque)
+{
+       #ifdef CAMBIAR
+       char *aux, *new_bloque;
+       int cant_reg, tam_reg, i, j;
+       EMUFS_TIPO1_REG_HEADER header;
+       CLAVE clave, clave_ajena;
+       
+       header.id = emufs_idx_get_new_id(efs, err);
+       header.size = size;
+       cant_reg++;
+       new_bloque = (char*)malloc(emu->tam_bloque);
+       aux = new_bloque;
+       for (i=0; i<cant_reg+1; i++){
+               bloque += sizeof(EMUFS_TIPO1_REG_HEADER); /*salteo el encabezado del registro*/
+               if ( emu->tam_bloque-fs < sizeof(EMUFS_TIPO1_REG_HEADER)+emu->indices->offset ){
+                       PERR("ESTOY LEYENDO FUERA DEL BLOQUE!!!");
+                       free(new_bloque);
+                       return clave;
+               }
+               clave_ajena = emufs_indice_generar_clave(emu->indices, bloque); /*leo la clave*/
+               bloque -= sizeof(EMUFS_TIPO1_REG_HEADER); /*vuelvo al principio*/
+               if (  i<cant_reg && emufs_indice_es_menor(clave_ajena, clave) ){
+                       memcpy(&tam_reg, bloque+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
+                       /*copio el reg al bloque nuevo*/
+                       memcpy(new_bloque, bloque, sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg);
+                       bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+ tam_reg; /*paso al proximo*/
+                       new_bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+ tam_reg; /*dejo preparado*/
+                       continue;
+               } else {
+                       /*meto el registro que me mandan*/
+                       memcpy(new_bloque, &header, sizeof(EMUFS_TIPO1_REG_HEADER));
+                       memcpy(new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER), ptr, size);
+                       new_bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+size;
+                       /*tengo que copiar los que faltan*/
+                       j = i;
+                       while ( j < cant_reg ){
+                               memcpy(&tam_reg, bloque+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
+                               memcpy(new_bloque, bloque, sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg);
+                               bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
+                               new_bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
+                               j++;
+                       }
+               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, query->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
+}

diff --git a/emufs/tipo1.h b/emufs/tipo1.h
index ef89e12d6d0df897768eca8480b5615e91637a19..9ebb2dacd58ec55e0ba05bd33b5121f94ad85a28 100644 (file)
--- a/emufs/tipo1.h
+++ b/emufs/tipo1.h
@@ -39,6 +39,7 @@
 #define _EMUFS_TIPO1_H_
 
 #include "emufs.h"
 #define _EMUFS_TIPO1_H_
 
 #include "emufs.h"

+#include "b_plus.h"

 
 /** Inicializa un EMUFS para poder ser utilizado como un archivo tipo1.
  *
 
 /** Inicializa un EMUFS para poder ser utilizado como un archivo tipo1.
  *


@@ -73,4 +74,5 @@ void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual,
                char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1,
                EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3);
 
                char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1,
                EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3);
 

+int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err);

 #endif /* _EMUFS_TIPO1_H_ */
 #endif /* _EMUFS_TIPO1_H_ */

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 28eafd5716c2b6adbe09783df3b28041791c9e9a..24d2e72e5ea0e095615af0016df8d318a176b522 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -585,7 +585,7 @@ 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, INDICE *indice, int *err)
+int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, int *err)

 {
        #ifdef ESTO_NO_ANDA_TODAVIA
        CLAVE clave, clave_aux;
 {
        #ifdef ESTO_NO_ANDA_TODAVIA
        CLAVE clave, clave_aux;


@@ -596,9 +596,9 @@ int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, INDICE *indice, int *er
        /*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*/
        /*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(indice, ptr);
+       query.clave = emufs_indice_generar_clave(emu->indices, ptr);

        /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
        /*mando a buscar en el arbol el bloque correspondiente a esa clave*/

-       indice->emufs_b_plus_get_bloque(ind, &query);
+       emu->indices->emufs_b_plus_get_bloque(ind, &query);

        /*en query->num_bloque tengo el bloque donde debo meter el registro*/
        
        /*cargo el bloque*/
        /*en query->num_bloque tengo el bloque donde debo meter el registro*/
        
        /*cargo el bloque*/


@@ -613,6 +613,9 @@ int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, INDICE *indice, int *er
        /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
        
        
        /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
        
        

+       
+       
+       

        #endif /*ESTO_NO_ANDA_TODAVIA*/
        return 0;
 }
        #endif /*ESTO_NO_ANDA_TODAVIA*/
        return 0;
 }

diff --git a/emufs/tipo3.h b/emufs/tipo3.h
index 84f610f6b89b298e30f661abc17d3554264d3e23..88be2705b01f4943a5b4c671766557bd1ab03c17 100644 (file)
--- a/emufs/tipo3.h
+++ b/emufs/tipo3.h
@@ -141,6 +141,6 @@ void emufs_tipo3_leer_bloque_raw(EMUFS *emu, EMUFS_BLOCK_ID block_id, char **act
   * \param ind Indice del archivo.
   * \param err Codigo de error devuelto en caso de falla.
   */
   * \param ind Indice del archivo.
   * \param err Codigo de error devuelto en caso de falla.
   */

-int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, INDICE *ind, int *err);
+int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, int *err);

 
 #endif /* _EMUFS_TIPO3_H_ */
 
 #endif /* _EMUFS_TIPO3_H_ */