emufs/indices.c

   1
   2 #include "indices.h"
   3 #include "emufs.h"
   4 #include "indice_b.h"
   5 #include "common.h"
   6
   7 INDICE *emufs_indice_crear(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato, unsigned int offset, unsigned int tam_bloque)
   8 {
   9         int len;
  10         INDICE *tmp;
  11         char string_file[255];
  12         tmp = (INDICE *)malloc(sizeof(INDICE));
  13         if (tmp == NULL) return NULL;
  14
  15         len = strlen(emu->nombre);
  16         len += strlen(nombre);
  17
  18         tmp->filename = (char *)malloc(sizeof(char)*(len+6));
  19         strcpy(tmp->filename, emu->nombre);
  20         strcat(tmp->filename, "_");
  21         strcat(tmp->filename, nombre);
  22         strcat(tmp->filename, ".idx");
  23
  24         tmp->nombre = (char *)malloc(sizeof(char)*(strlen(nombre)+1));
  25         strcpy(tmp->nombre, nombre);
  26
  27         tmp->tipo = tipo;
  28
  29         tmp->tipo_dato = tipo_dato;
  30         switch (tipo_dato) {
  31                 case IDX_STRING:
  32                         sprintf(string_file, "%s_%s_%s", emu->nombre, nombre, "string");
  33                         tmp->emu_string = emufs_crear(string_file, T2, 0, 0);
  34                 break;
  35                 case IDX_FLOAT:
  36                 case IDX_INT:
  37                         tmp->emu_string = NULL;
  38         }
  39
  40         tmp->tam_bloque = tam_bloque;
  41         tmp->funcion = funcion;
  42         tmp->offset = offset;
  43         tmp->sig = NULL;
  44
  45         switch (tipo) {
  46                 case IND_B:
  47                         PERR("Creando indice con Arbol B");
  48                         emufs_indice_b_crear(tmp);
  49                         tmp->agregar_entrada = emufs_indice_b_insertar;
  50                         tmp->borrar_entrada = emufs_indice_b_borrar;
  51                         tmp->existe_entrada = emufs_indice_b_buscar;
  52                         tmp->buscar_entradas = NULL;
  53                 break;
  54                 case IND_B_ASC:
  55                         /* llenar metodos */
  56                         PERR("Creando indice con Arbol B*");
  57                         PERR("AÚN NO IMPLEMENTADO!!!!!!!!");
  58                         break;
  59         }
  60
  61         return tmp;
  62 }
  63
  64 void emufs_indice_destruir(EMUFS *emu, INDICE *i)
  65 {
  66         /* TODO Sacar el indice de la lista en EMUFS */
  67
  68         if (i->tipo == IDX_STRING)
  69                 emufs_destruir(i->emu_string);
  70         free(i->filename);
  71         free(i->nombre);
  72         free(i);
  73 }
  74
  75 void emufs_indice_agregar(INDICE *primero, char *data, INDICE_DATO dato)
  76 {
  77         INDICE *iter = primero;
  78
  79         while (iter) {
  80                 iter->agregar_entrada(iter, emufs_indice_generar_clave(iter, data), dato);
  81                 iter = iter->sig;
  82         }
  83 }
  84
  85 INDICE_DATO emufs_indice_buscar(INDICE *primero, char *data)
  86 {
  87         return primero->existe_entrada(primero, emufs_indice_generar_clave_desde_valor(primero, data));
  88 }
  89
  90 CLAVE emufs_indice_generar_clave_desde_valor(INDICE *idx, char *data)
  91 {
  92         CLAVE k;
  93         if (idx == NULL) PERR("NULL INDEX!");
  94
  95         switch (idx->tipo_dato) {
  96                 case IDX_FLOAT:
  97                         k.f_clave= *((float *)(data));
  98                 break;
  99                 case IDX_INT:
 100                         k.i_clave = *((int *)(data));
 101                 case IDX_STRING:
 102                         k = k;
 103                         /* XXX Y DE QUE COLOR NOS PINTAMOS ACA?
 104                          *
 105                          * ESTA EL PROBLEMA DE QUE ESTO SE GENERA ON THE FLY
 106                          * Y NOSOTROS TENEMOS COSAS EN UN ARCHIVO DE TIPO2
 107                          *
 108                          * COMO GENERAMOS LA CLAVE???
 109                          */
 110         }
 111
 112         return k;
 113 }
 114
 115 CLAVE emufs_indice_generar_clave(INDICE *idx, char *data)
 116 {
 117         CLAVE k;
 118         int error;
 119
 120         switch (idx->tipo_dato) {
 121                 case IDX_FLOAT:
 122                         k.f_clave= *((float *)(data+idx->offset));
 123                 break;
 124                 case IDX_INT:
 125                         k.i_clave = *((int *)(data+idx->offset));
 126                 break;
 127                 case IDX_STRING:
 128                         k.i_clave = idx->emu_string->grabar_registro(idx->emu_string,
 129                                                                                 data+idx->offset,
 130                                                                                 strlen(data+idx->offset)+1,
 131                                                                                 &error
 132                                                                         );
 133         }
 134
 135         return k;
 136 }
 137
 138 int emufs_indice_es_menor(INDICE *idx, CLAVE c1, CLAVE c2)
 139 {
 140         char *sc1, *sc2; /* Si es IDX_STRING aca pongo los strings leidos */
 141         EMUFS_REG_SIZE dummy; /* No me interesa el tamaño del string aca! */
 142         int error;
 143
 144         switch (idx->tipo_dato) {
 145                 case IDX_FLOAT:
 146                         return c1.f_clave < c2.f_clave;
 147                 case IDX_INT:
 148                         return c1.i_clave < c2.i_clave;
 149                 case IDX_STRING:
 150                         sc1 = idx->emu_string->leer_registro(idx->emu_string, c1, &dummy, &error);
 151                         sc2 = idx->emu_string->leer_registro(idx->emu_string, c2, &dummy, &error);
 152                         error = (strcmp(sc1, sc2) < 0);
 153                         free(sc1);
 154                         free(sc2);
 155                         return error;
 156         }
 157         return 0;
 158 }
 159
 160 int emufs_indice_es_igual(INDICE *idx, CLAVE c1, CLAVE c2)
 161 {
 162         char *sc1, *sc2; /* Si es IDX_STRING aca pongo los strings leidos */
 163         EMUFS_REG_SIZE dummy; /* No me interesa el tamaño del string aca! */
 164         int error;
 165
 166         switch (idx->tipo_dato) {
 167                 case IDX_FLOAT:
 168                         return c1.f_clave == c2.f_clave;
 169                 case IDX_INT:
 170                         return c1.i_clave == c2.i_clave;
 171                 case IDX_STRING:
 172                         sc1 = idx->emu_string->leer_registro(idx->emu_string, c1, &dummy, &error);
 173                         sc2 = idx->emu_string->leer_registro(idx->emu_string, c2, &dummy, &error);
 174                         error = (strcmp(sc1, sc2) == 0);
 175                         free(sc1);
 176                         free(sc2);
 177                         return error;
 178         }
 179         return 0;
 180 }
 181