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         tmp = (INDICE *)malloc(sizeof(INDICE));
  12         if (tmp == NULL) return NULL;
  13
  14         len = strlen(emu->nombre);
  15         len += strlen(nombre);
  16
  17         tmp->filename = (char *)malloc(sizeof(char)*(len+6));
  18         strcpy(tmp->filename, emu->nombre);
  19         strcat(tmp->filename, "_");
  20         strcat(tmp->filename, nombre);
  21         strcat(tmp->filename, ".idx");
  22
  23         tmp->nombre = (char *)malloc(sizeof(char)*(strlen(nombre)+1));
  24         strcpy(tmp->nombre, nombre);
  25
  26         tmp->tipo = tipo;
  27         tmp->tipo_dato = tipo_dato;
  28         tmp->tam_bloque = tam_bloque;
  29         tmp->funcion = funcion;
  30         tmp->offset = offset;
  31         tmp->sig = NULL;
  32
  33         switch (tipo) {
  34                 case IND_B:
  35                         PERR("Creando indice con Arbol B");
  36                         emufs_indice_b_crear(tmp);
  37                         tmp->agregar_entrada = emufs_indice_b_insertar;
  38                         tmp->borrar_entrada = emufs_indice_b_borrar;
  39                         tmp->existe_entrada = emufs_indice_b_buscar;
  40                         tmp->buscar_entradas = NULL;
  41                 break;
  42                 case IND_B_ASC:
  43                         /* llenar metodos */
  44                         break;
  45         }
  46
  47         return tmp;
  48 }
  49
  50 void emufs_indice_destruir(EMUFS *emu, INDICE *i)
  51 {
  52         /* TODO Sacar el indice de la lista en EMUFS */
  53
  54         free(i->filename);
  55         free(i->nombre);
  56         free(i);
  57 }
  58
  59 void emufs_indice_agregar(INDICE *primero, char *data, INDICE_DATO dato)
  60 {
  61         INDICE *iter = primero;
  62
  63         while (iter) {
  64                 iter->agregar_entrada(iter, emufs_indice_generar_clave(iter, data), dato);
  65                 iter = iter->sig;
  66         }
  67 }
  68
  69 INDICE_DATO emufs_indice_buscar(INDICE *primero, char *data)
  70 {
  71         return primero->existe_entrada(primero, emufs_indice_generar_clave_desde_valor(primero, data));
  72 }
  73
  74 CLAVE emufs_indice_generar_clave_desde_valor(INDICE *idx, char *data)
  75 {
  76         CLAVE k;
  77         if (idx == NULL) PERR("NULL INDEX!");
  78
  79         PERR("---- 1 ----");
  80         switch (idx->tipo_dato) {
  81                 case IDX_FLOAT:
  82                         k.f_clave= *((float *)(data));
  83                 break;
  84                 case IDX_INT:
  85                         k.i_clave = *((int *)(data));
  86         }
  87         PERR("---- 2 ----");
  88
  89         return k;
  90 }
  91
  92 CLAVE emufs_indice_generar_clave(INDICE *idx, char *data)
  93 {
  94         CLAVE k;
  95         switch (idx->tipo_dato) {
  96                 case IDX_FLOAT:
  97                         k.f_clave= *((float *)(data+idx->offset));
  98                 break;
  99                 case IDX_INT:
 100                         k.i_clave = *((int *)(data+idx->offset));
 101         }
 102
 103         return k;
 104 }
 105
 106 int emufs_indice_es_menor(INDICE *idx, CLAVE c1, CLAVE c2)
 107 {
 108         switch (idx->tipo_dato) {
 109                 case IDX_FLOAT:
 110                         return c1.f_clave < c2.f_clave;
 111                 case IDX_INT:
 112                         return c1.i_clave < c2.i_clave;
 113         }
 114         return 0;
 115 }
 116
 117 int emufs_indice_es_igual(INDICE *idx, CLAVE c1, CLAVE c2)
 118 {
 119         switch (idx->tipo_dato) {
 120                 case IDX_FLOAT:
 121                         return c1.f_clave == c2.f_clave;
 122                 case IDX_INT:
 123                         return c1.i_clave == c2.i_clave;
 124         }
 125         return 0;
 126 }
 127