/* 
 *  Programa:   main.cpp
 *  Autor:      Miguel Guanira
 *
 *  Creado el 15 de abril de 2010, 04:02 PM
 */

#include <stdlib.h>
#include "manipDato.h"
#include "lista.h"


int main(void) {
    void *lista=NULL;

    // Aquí, la función main no sabe qué tipo de datos va a almacenar
    // en la lista dligada. 
    // Las funciones: creaLista, imprimeLista y eliminaLista están definidas
    // en los módulos lista.h y lista.cpp
    // Las funciones: compDato, impDato y elimdato están definidas en los
    // módulos manipDato.h y manipDato.cpp
    
    crearLista(lista, leeDato, compDato);
    imprimeLista(lista,impDato);
    eliminaLista(lista,elimDato);

    return (EXIT_SUCCESS);
}


//****************************************************
//
//                Módulo: Lista.h
//
//    Funciones para crear, imprimir y eleiminar 
//                una lista genérica
//
//****************************************************

#ifndef _LISTA_H
#define	_LISTA_H
    void crearLista(void *&, void * (*)(void), int (*)(void*, void*));
    void imprimeLista(void *, void (*)(void *));
    void eliminaLista(void *, void (*)(void *));
    void insertLista(void *&, void *, int (*)(void*, void*));
#endif	/* _LISTA_H */



//****************************************************
//
//                Módulo: ManipDato.h
//
//    Funciones que permiten crear, imprimir, 
//    eliminar y comparar un dato específico según 
//                una plantilla dada
//
//****************************************************

#ifndef _MANIPDATO_H
#define	_MANIPDATO_H
    void * leeDato(void);
    int  compDato(void*, void*);
    void impDato(void *);
    void elimDato(void *);
#endif	/* _MANIPDATO_H */


//****************************************************
//
//                Módulo: Lista.cpp
//
//    Módulo de implementación de las funciones
//
//****************************************************


#include <stdio.h>
#include "lista.h"

// Aquí, las funciones definidas son capaces de manipular una lista ligada
// sin saber qué tipo de dato va a manejar, todo el trabajo se realiza
// a través de púnteros a funciones que son los que manipulan los datos
// especificos para cada situación.

void crearLista(void *&lista, void * (*leeDato)(void),
        int (*compDato)(void*, void*)){
    void *dato;

    while (1){
        dato = leeDato(); // Lee un dato de cualquier tipo y devuelve
                          // un puntero genérico que apunta al dato
        if (dato == NULL) break;
        insertLista(lista, dato, compDato);
    }
}

void insertLista(void *&lista, void* dato,
        int (*compDato)(void*, void*) ){
    void **p, **nuevo, **ant;

    nuevo = new void*[2];
    nuevo[0] = dato;  // Cuelga el dato sea culfuera su naturaleza

    p = (void**)lista;
    ant=NULL;
    while(p){
        if (compDato(p[0],dato)>0)break; // Compara dos datos, devuelve 0 si
        // son iguales, un valor mayor que cereo si el primero es mayor que
        // el segundo y un valor menor que cereo si el primero es menor que
        // el segundo. El tipo de dato que comprar depende de la función a
        // la que apunte el puntero
        ant = p;
        p = (void**)(p[1]);
    }
    nuevo[1] = p;
    if(ant == NULL) lista = nuevo;
    else ant[1] = nuevo;
}

void imprimeLista(void *lista, void (*impDato)(void *)){
    void **lst;

    lst = (void**)lista;

    while (lst){
        impDato(lst[0]); // imprime un dato sea cualfuera su naturaleza
        lst = (void**)lst[1];
    }
}

void eliminaLista(void *lista, void (*elimDato)(void *)){
    void **lst, **sale;

    lst = (void**)lista;

    while (lst){
        elimDato(lst[0]);  // elimina un dato sea cualfuera su naturaleza
        sale = lst;
        lst = (void**)lst[1];
        delete []sale;
    }
}



//****************************************************
//
//          Módulo: ManipDato.cpp Versión 1
//
//      Módulo de implementación de las funciones
//           para manejar valores enteros
//
//****************************************************


#include <stdio.h>

void * leeDato(void){
    // lee un entero, si se intenta leer el fin del archivo
    // devuelve NULL
    int dato, *ptDato;

    if (scanf("%d", &dato)==EOF) return NULL;
    ptDato = new int;
    *ptDato = dato;
    return ptDato;
}

int  compDato(void *v1, void *v2){
    int *n1, *n2;
    // Compara los valores enteros apuntados por los punteros
    n1 = (int*)v1;
    n2 = (int*)v2;
    return *n1 - *n2;
}

void impDato(void *v){
    int *n;
    
    // Imprime los valores enteros apuntados por los punteros
    n = (int *)v;
    printf("%d\n", *n);
}

void elimDato(void *v){
    int *n;
    
    // Elimina los valores enteros apuntados por los punteros
    n = (int *)v;
    delete n;
}


//****************************************************
//
//          Módulo: ManipDato.cpp Versión 2
//
//      Módulo de implementación de las funciones
//       para manejar valores de punto flotante
//
//****************************************************

#include <stdio.h>

void * leeDato(void){
    // lee un entero, si se intenta leer el fin del archivo
    // devuelve NULL
    float dato, *ptDato;

    if (scanf("%f", &dato)==EOF) return NULL;
    ptDato = new float;
    *ptDato = dato;
    return ptDato;
}

int  compDato(void *v1, void *v2){
    float *n1, *n2;
    // Compara los valores enteros apuntados por los punteros
    n1 = (float*)v1;
    n2 = (float*)v2;
    return (int)(*n1 - *n2);
}

void impDato(void *v){
    float *n;

    // Imprime los valores enteros apuntados por los punteros
    n = (float *)v;
    printf("%f\n", *n);
}

void elimDato(void *v){
    float *n;

    // Elimina los valores enteros apuntados por los punteros
    n = (float *)v;
    delete n;
}


//****************************************************
//
//          Módulo: ManipDato.cpp Versión 3
//
//      Módulo de implementación de las funciones
//         para manejar cadenas de caracteres
//
//****************************************************


#include <stdio.h>
#include <string.h>
void * leeDato(void){
    // lee una cadena , si se intenta leer una cadena
    // vacía develve NULL
    char *dato, aux[300];
    int tam;

    if (gets(aux)==NULL) return NULL;
    tam = strlen(aux);
    if (tam==0) return NULL;
    dato = new char[tam+1];
    strcpy(dato,aux);

    return dato;
}

int  compDato(void *v1, void *v2){
    char *n1, *n2;

    // Compara las cadenas de caracteres apuntadas por los punteros
    n1 = (char*)v1;
    n2 = (char*)v2;
    return strcmp(n1,n2);
}

void impDato(void *v){
    char *n;

    // Imprime las cadenas apuntados por los punteros
    n = (char *)v;
    printf("%s\n", n);
}

void elimDato(void *v){
    char *n;
    
    // Elimina las cadenas apuntadas por los punteros
    n = (char *)v;
    delete []n;
}




//****************************************************
//
//          Módulo: ManipDato.cpp Versión 4
//
//      Módulo de implementación de las funciones
//          para manejar registros de datos
//
//****************************************************

/*
 * Este módulo permite manejar una ficha de datos
 * implementada con un arreglo de punteros genéricos
 * en la lista ligada. La lista estará ordenada por
 * el segundo registro (codigo).
 */
#include <stdio.h>
#include <string.h>
void * leeDato(void){
    void **dato;
    char auxStr[300], *nombre, *fechIng; // <-- dd/mm/aaaa
    int *codigo, tam;
    float *sueldo;

    // lee una ficha que contiene el nombre, el código,
    // la fecha de ingreso y el sueldo de empleados a una
    // compañía, si se intenta leer un nombre vacío
    // develve NULL
    printf("Nombre: ");
    if (gets(auxStr)==NULL) return NULL;
    tam = strlen(auxStr);
    if (tam==0) return NULL;

    dato = new void *[4];
    nombre = new char[strlen(auxStr)+1];
    strcpy(nombre, auxStr);

    printf("Codigo: ");
    codigo = new int;
    scanf("%d", codigo);
    while(getchar() != '\n');

    printf("Fecha de ingreso: ");
    fechIng = new char[11]; //<-- dd/mm/aaaa0
    scanf("%s", fechIng);

    printf("Sueldo: ");
    sueldo = new float;
    scanf("%f", sueldo);
    while(getchar() != '\n');

    dato[0] = nombre;
    dato[1] = codigo;
    dato[2] = fechIng;
    dato[3] = sueldo;

    return dato;
}

int  compDato(void *v1, void *v2){
    void **n1, **n2;
    int *c1, *c2;

    // Compara los segundos campos de registros apuntados
    //  por los punteros
    n1 = (void**)v1;
    n2 = (void**)v2;
    c1 = (int *)n1[1];
    c2 = (int *)n2[1];

    return *c1 - *c2;
}

void impDato(void *v){
    void **n;
    
    // Imprime los campos de registros apuntados por
    // los punteros
    n = (void **)v;
    char *nombre, *fechIng;
    int *codigo;
    float *sueldo;

    nombre  = (char *) n[0];
    codigo  = (int *)  n[1];
    fechIng = (char *) n[2];
    sueldo  = (float *)n[3];
    
    printf("Nombre:           %s\n", nombre);
    printf("Codigo:           %d\n", *codigo);
    printf("Fecha de ingreso: %s\n", fechIng);
    printf("Sueldo:           %f\n", *sueldo);
}

void elimDato(void *v){
    void **n;
    char *nombre, *fechIng;
    int *codigo;
    float *sueldo;
    
    // elimina los campos y el 5registros apuntados por
    // los punteros
    n = (void **)v;
    nombre  = (char *) n[0];
    codigo  = (int *)  n[1];
    fechIng = (char *) n[2];
    sueldo  = (float *)n[3];

    delete []nombre;
    delete codigo;
    delete []fechIng;
    delete sueldo;
    delete []n;
}