* Cambio manejo estatico de articulos por una lista doblemente enlazada.

diff --git a/emufs_gui/articulos.c b/emufs_gui/articulos.c
index fc8841a8b9267e9fd46cee620bfd0e8ba371b21d..232e1840be9b687d8d17f4e1c8c1e637fb56e8f2 100644 (file)
--- a/emufs_gui/articulos.c
+++ b/emufs_gui/articulos.c
@@ -9,6 +9,21 @@ static t_Articulo *art_form_buscar(WINDOW *win);
 static void *procesar_guardar_articulo(t_Articulo *src, EMUFS_REG_SIZE *size, t_LstArticulos *lst);
 static int procesar_leer_articulo(t_Articulo *dst, void *src, EMUFS_REG_SIZE size, t_LstArticulos *lst);
 
+static t_Reg_Articulo *crear_nodo_articulo(EMUFS_REG_ID reg, unsigned int num);
+
+t_Reg_Articulo *crear_nodo_articulo(EMUFS_REG_ID reg, unsigned int num)
+{
+       t_Reg_Articulo *tmp;
+       if (reg == EMUFS_NOT_FOUND) return NULL;
+       tmp = malloc(sizeof(t_Reg_Articulo));
+       if (tmp == NULL) return NULL;
+       tmp->sig = tmp->ant = NULL;
+       tmp->num_reg = reg;
+       tmp->numero = num;
+
+       return tmp;
+}
+
 t_LstArticulos *art_cargar(const char *filename)
 {
        xmlDocPtr document;
@@ -17,17 +32,12 @@ t_LstArticulos *art_cargar(const char *filename)
        EMUFS_REG_SIZE size;
        t_LstArticulos *tmp;
        lst_articulos = NULL;
+       t_Reg_Articulo *reg_nodo;
 
        tmp = (t_LstArticulos *)malloc(sizeof(t_LstArticulos));
        if (tmp == NULL) return NULL;
        lst_articulos = tmp;
-       tmp->cant = 0;
-       /*      tmp->array = (t_Reg_Articulo *)malloc(sizeof(t_Reg_Articulo)*tmp->cant);*/
-
-       if (tmp->array == NULL) {
-               free(tmp);
-               return NULL;
-       }
+       tmp->primero = NULL;
 
        if (filename != NULL) {
                document = xmlReadFile(filename, "ISO-8859-1",0);
@@ -77,15 +87,21 @@ t_LstArticulos *art_cargar(const char *filename)
                                        /* Ya leido el articulo ahora paso a guardarlo en el archivo y agregarlo a la lista */
                                        save = procesar_guardar_articulo(&art, &size, lst_articulos);
                                        if (save != NULL) {
-                                               tmp->array[cant].num_reg = tmp->fp->grabar_registro(tmp->fp, save, size, &error);
-                                               tmp->array[cant].numero = art.numero;
-                                               ++cant;
+                                               reg_nodo = crear_nodo_articulo(tmp->fp->grabar_registro(tmp->fp, save, size, &error), art.numero);
+                                               if (reg_nodo != NULL) {
+                                                       if (tmp->primero) {
+                                                               tmp->primero->ant = reg_nodo;
+                                                               reg_nodo->sig = tmp->primero;
+                                                               tmp->primero = reg_nodo;
+                                                       } else {
+                                                               tmp->primero = reg_nodo;
+                                                       }
+                                               }
                                                free(save);
                                        }
                                }
                        }
                }
-               tmp->cant = cant;
                xmlFreeDoc(document);
                xmlCleanupParser();
        } else {
@@ -99,12 +115,19 @@ t_LstArticulos *art_cargar(const char *filename)
                        /* Leo el registro */
                        save = tmp->fp->leer_registro(tmp->fp, id, &size, &error);
                        if (procesar_leer_articulo(&art, save, size, tmp) == 1) {
-                               tmp->array[i].num_reg = i;
-                               tmp->array[i].numero = art.numero;
+                               reg_nodo = crear_nodo_articulo(id, art.numero);
+                               if (reg_nodo != NULL) {
+                                       if (tmp->primero) {
+                                               tmp->primero->ant = reg_nodo;
+                                               reg_nodo->sig = tmp->primero;
+                                               tmp->primero = reg_nodo;
+                                       } else {
+                                               tmp->primero = reg_nodo;
+                                       }
+                               }
                                free(save);
                        }
                }
-               tmp->cant = cant;
        }
 
        return tmp;
@@ -116,7 +139,7 @@ int art_liberar(t_LstArticulos *l)
        if (l == NULL) return 1;
 
        emufs_destruir(l->fp);
-/*     free(l->array); */
+       /* TODO : Liberar lista */
        free(l);
 
        lst_articulos = NULL;
@@ -125,21 +148,22 @@ int art_liberar(t_LstArticulos *l)
 
 t_Articulo *art_obtener(t_LstArticulos *lst, const char *numero)
 {
-       /* FIXME : NO ME GUSTA :-/ */
        t_Articulo *art;
+       t_Reg_Articulo *nodo;
        void *tmp;
-       int i, error = 0;
+       int error = 0;
        EMUFS_REG_SIZE size;
        int n = atoi(numero);
 
        if (lst == NULL) lst = lst_articulos;
        if (lst == NULL) return NULL;
 
-       for(i=0; i<lst->cant; i++) {
-               if (n == lst->array[i].numero) {
+       nodo = lst->primero;
+       while (nodo) {
+               if (n == nodo->numero) {
                        art = (t_Articulo *)malloc(sizeof(t_Articulo));
                        /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */
-                       tmp = lst->fp->leer_registro(lst->fp, lst->array[i].num_reg, &size, &error);
+                       tmp = lst->fp->leer_registro(lst->fp, nodo->num_reg, &size, &error);
                        
                        if (error) {
                                free(art);
@@ -154,6 +178,7 @@ t_Articulo *art_obtener(t_LstArticulos *lst, const char *numero)
                        free(tmp);
                        return art;
                }
+               nodo = nodo->sig;
        }
 
        return NULL;
@@ -217,7 +242,7 @@ void art_eliminar(char *s)
 {
        WINDOW *win;
        t_Articulo *articulo;
-       int i;
+       t_Reg_Articulo *nodo, *del;
        win = newwin(8, COLS-2, 13, 1);
        box(win, 0, 0);
        wrefresh(win);
@@ -231,12 +256,26 @@ void art_eliminar(char *s)
                wrefresh(win);
                getch();
        } else {
-               for(i=0; i<lst_articulos->cant; i++) {
-                       if (lst_articulos->array[i].numero == articulo->numero) {
-                               lst_articulos->array[i].numero = -1;
-                               lst_articulos->fp->borrar_registro(lst_articulos->fp, lst_articulos->array[i].num_reg);
+               nodo = lst_articulos->primero;
+               while (nodo) {
+                       if (nodo->numero == articulo->numero) {
+                               lst_articulos->fp->borrar_registro(lst_articulos->fp, nodo->num_reg);
+                               del = nodo;
+                               if (nodo->ant) {
+                                       nodo->ant->sig = nodo->sig;
+                                       if (nodo->sig) {
+                                               nodo->sig->ant = nodo->ant;
+                                       }
+                               } else {
+                                       if (nodo->sig) {
+                                               nodo->sig->ant = NULL;
+                                       }
+                                       lst_articulos->primero = nodo->sig;
+                               }
+                               free(del);
                                break;
                        }
+                       nodo = nodo->sig;
                }
                free(articulo);
        }
@@ -251,9 +290,11 @@ void art_agregar(char *s)
        WINDOW *win;
        t_Form *form;
        t_Articulo art;
+       t_Reg_Articulo *nuevo;
        void *save;
-       int error = 0, existe, i;
+       int error = 0, existe;
        EMUFS_REG_SIZE size;
+       EMUFS_REG_ID id;
 
        win = newwin(8, COLS-2, 13, 1);
        box(win, 0, 0);
@@ -270,11 +311,13 @@ void art_agregar(char *s)
        
        art.numero = atoi(form_obtener_valor_char(form, "Numero de Artículo"));
        existe = 0;
-       for(i=0; i<lst_articulos->cant; i++) {
-               if (art.numero == lst_articulos->array[i].numero) {
+       nuevo = lst_articulos->primero;
+       while (nuevo) {
+               if (art.numero == nuevo->numero) {
                        existe = 1;
                        break;
                }
+               nuevo = nuevo->sig;
        }
        
        if (!existe) {
@@ -288,16 +331,25 @@ void art_agregar(char *s)
                /* Ya leido el articulo ahora paso a guardarlo en el archivo y agregarlo a la lista */
                save = procesar_guardar_articulo(&art, &size, lst_articulos);
                if (save != NULL) {
-                       lst_articulos->array[lst_articulos->cant].num_reg = lst_articulos->fp->grabar_registro(lst_articulos->fp, save, size, &error);
+                       id = lst_articulos->fp->grabar_registro(lst_articulos->fp, save, size, &error);
                        if (error) {
                                wattron(win, COLOR_PAIR(COLOR_YELLOW));
                                mvwaddstr(win, 6, 4, "Error al tratar de agregar el nuevo registro");
                                wattroff(win, COLOR_PAIR(COLOR_YELLOW));
                                wrefresh(win);
                                getch();
+                       } else {
+                               nuevo = crear_nodo_articulo(id, art.numero);
+                               if (nuevo) {
+                                       if (lst_articulos->primero) {
+                                               lst_articulos->primero->ant = nuevo;
+                                               nuevo->sig = lst_articulos->primero;
+                                               lst_articulos->primero = nuevo;
+                                       } else {
+                                               lst_articulos->primero = nuevo;
+                                       }
+                               }
                        }
-                       lst_articulos->array[lst_articulos->cant].numero = art.numero;
-                       lst_articulos->cant++;
                        free(save);
                }
        } else {

diff --git a/emufs_gui/articulos.h b/emufs_gui/articulos.h
index 8346106b3e07c6f17a95ded949a1b9531dedfab5..4182256d25e6d78412a41dbb05a3f35b6906ebe2 100644 (file)
--- a/emufs_gui/articulos.h
+++ b/emufs_gui/articulos.h
@@ -24,11 +24,11 @@ typedef struct _articulo_ {
 typedef struct _reg_articulo_ {
        EMUFS_REG_ID num_reg; /* numero de registro en el archivo */
        unsigned int numero; /* codigo de articulo */
+       struct _reg_articulo_ *sig, *ant;
 } t_Reg_Articulo;
 
 typedef struct _lista_articulos_ {
-       t_Reg_Articulo array[100];
-       unsigned int cant;
+       t_Reg_Articulo *primero;
        EMUFS *fp; /* Filepointer al archivo donde estan los datos */
 } t_LstArticulos;