gistfile1.c

/*
 * EjerArchivo.c
 *
 *  Created on: 21/08/2014
 *      Author: utnso
 */

//Archivo entrada:Región; Nombre y Apellido; Edad; Número Telefónico; DNI; Saldo
//Archivo salida:Región | Edad | DNI | Nombre y Apellido (30 chars máximo) | Número telefónico
//\n
//setbuf(stdin,NULL);

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <commons/collections/list.h>
#include <commons/txt.h>
#include <commons/string.h>
#include <stdbool.h>

typedef struct {
	  char* region;
	  char* nomyape;
	  int edad;
	  char* telefono;
	  char* dni;
	  float saldo;
}info;

char* leer_linea(FILE* archivo);
info* sacar_campos(char *string);
void imprimir_info(info *registro);
void imprimir_info_salida(info *registro);
void pasar_archivo_a_lista(FILE *archivo, t_list *lista);
void mostrar_lista(t_list *lista);
void mostrar_lista_salida(t_list *lista);
_Bool saldo_menor_a_100(void *puntero);
t_list* filtar_saldo(t_list *lista);
t_list* filtar_edad(t_list *lista);
t_list* oedenar_lista_region_edad(t_list *lista);
bool criterio_region_edad(void *puntero1, void *puntero2);


int main(){
	txt_write_in_stdout("Comienzo 1\n");
	char *rutaEntrada=malloc(sizeof(char)*80), *rutaSalida=malloc(sizeof(char)*80);
	strcpy(rutaEntrada,"/home/utnso/Documentos/entrada.txt");
	strcpy(rutaSalida,"/home/utnso/Documentos/salida.txt");
	FILE* archEntrada=fopen(rutaEntrada, "r");
	FILE* archSalida=fopen(rutaSalida, "w");
	t_list *lista;

        // El list_create() ya hace el malloc(), por lo tanto estarías alocando memoria que luego no usas.
	lista=malloc(sizeof(t_list));
	lista=list_create();

	txt_write_in_stdout("Comienzo 2\n");
	txt_write_in_stdout("\n");

	pasar_archivo_a_lista(archEntrada, lista);
	mostrar_lista(lista);

	system("clear");

	t_list *filtrada1;
        // mismo tema de arriba.
	filtrada1=malloc(sizeof(t_list));

        // no hace falta crear una nueva lista ya que el list_filter() de filtrar_saldo
        // ya se va a encargar de crear una nueva lista.
	filtrada1=list_create();
	filtrada1=filtar_saldo(lista);
	mostrar_lista_salida(filtrada1);

	system("clear");

        // mismos comentarios que para arriba
	t_list *filtrada2;
	filtrada2=malloc(sizeof(t_list));
	filtrada2=list_create();
	filtrada2=filtar_edad(filtrada1);
	mostrar_lista_salida(filtrada2);


/*	t_list *ordenada;
	ordenada=malloc(sizeof(t_list));
	ordenada=list_create();
	ordenada=filtar_edad(filtrada2);*/




	txt_write_in_stdout("Fin 1\n");
	fclose(archSalida);
	fclose(archEntrada);
	free(rutaEntrada);
	free(rutaSalida);

        // Las listas tienen sus propias funciones para eliminar los nodos internos
        // pensa que un free solo libera la memoria de 'ese' puntero, si ese puntero
        // conocia a otro entonces, a este 'otro' no lo liberaría
	free(lista);
	free(filtrada1);
	free(filtrada2);
//	free(ordenada);
	txt_write_in_stdout("Fin 2\n");
	return 0;
}


char* leer_linea(FILE* archivo){
	char* linea=malloc(sizeof(char)*120);
	fscanf(archivo, "%[^\n]", linea);
	fgetc(archivo);
	return linea;
}

info* sacar_campos(char *string){
	info *registro= malloc(sizeof(info));
	char** array= string_n_split(string,10,";");
	registro->region=array[0];
	registro->nomyape=array[1];
	
        // no hace falta alocarle memoria, ya que va a apuntar al puntero guardado en array[2]
        char* edad=malloc(sizeof(char)*3);
	edad=array[2];

	registro->edad=atoi(edad);
	registro->telefono=array[3];
	registro->dni=array[4];

        // mismo comentario
	char* saldo=malloc(sizeof(char)*10);
	saldo=array[5];
	registro->saldo=atof(saldo);
	return registro;
}

void imprimir_info(info *registro){
	printf("Region: %s",registro->region);
	txt_write_in_stdout("\n");
	printf("Nombre: %s",registro->nomyape);
	txt_write_in_stdout("\n");
	printf("Edad: %d", registro->edad);
	txt_write_in_stdout("\n");
	printf("Teléfono: %s",registro->telefono);
	txt_write_in_stdout("\n");
	printf("DNI: %s",registro->dni);
	txt_write_in_stdout("\n");
	printf("Saldo: %.2f", registro->saldo);
	txt_write_in_stdout("\n");
	txt_write_in_stdout("\n");
}

void pasar_archivo_a_lista(FILE *archivo, t_list *lista){
        // sacar_campos ya reserva memoria para este puntero
	info *registro=malloc(sizeof(info));
        // leer_linea ya esta alocando memoria para este puntero.
	char* linea=malloc(sizeof(char)*120);
	do{
		linea=leer_linea(archivo);
                // hay una función de la commons para saber si un string es vacio
		if (strcmp(linea,"")!=0){

			registro=sacar_campos(linea);
			list_add(lista, registro);
		}
	}while ((feof(archivo)==0));
	free(registro);
	free(linea);
}

void mostrar_lista(t_list *lista){
	int cant=list_size(lista), i=0;
        // cuando haces un get ya te devuelve un puntero a un dato reservado
	info *registro=malloc(sizeof(info));

        hay una función que se llama list_iterate, que aplica una función a cada elemento de la lista
	for(i=0;i<cant;i++){
		registro =list_get(lista, i);
		imprimir_info(registro);
	}
	free(registro);
}

void mostrar_lista_salida(t_list *lista){
	int cant=list_size(lista), i=0;

        // cuando haces un get ya te devuelve un puntero a un dato reservado
	info *registro=malloc(sizeof(info));

        //hay una función que se llama list_iterate, que aplica una función a cada elemento de la lista
	for(i=0;i<cant;i++){
		registro =list_get(lista, i);
		imprimir_info_salida(registro);
	}
	free(registro);
}

void imprimir_info_salida(info *registro){
	printf("Region: %s",registro->region);
	txt_write_in_stdout("\n");
	printf("Edad: %d", registro->edad);
	txt_write_in_stdout("\n");
	printf("DNI: %s",registro->dni);
	txt_write_in_stdout("\n");
	printf("Nombre: %s",registro->nomyape);
	txt_write_in_stdout("\n");
	printf("Teléfono: %s",registro->telefono);
	txt_write_in_stdout("\n");
	txt_write_in_stdout("\n");
}

_Bool saldo_menor_a_100(void *puntero){
	info *registro= malloc(sizeof(info));
	registro=(info *)puntero;

        // la comparación ya devuelve un booleano, te conviene retornarlo.
	if (registro->saldo<100){
		return true;
	}
	else
	{
		return false;
	}
}

t_list* filtar_saldo(t_list *lista){
	_Bool (*punteroACondicion)(void *);

        // no hace falta guardar el puntero a una función en una variable
        // directamente podes usar el nombre de la función
        // ejemplo, list_filter(lista, saldo_menor_a_100)
	punteroACondicion = &saldo_menor_a_100;
	t_list* lista_filtrada;
        
        // no hace falta alocar memoria, list_filter crea una lista nueva
	lista_filtrada=malloc(sizeof(t_list));
	lista_filtrada = list_filter(lista, punteroACondicion);
	return lista_filtrada;
}

_Bool es_mayor(void *puntero){
	info *registro= malloc(sizeof(info));
	registro=(info *)puntero;
	if (registro->edad>=18){
		return true;
	}
	else
	{
		return false;
	}
}

t_list* filtar_edad(t_list *lista){
	_Bool (*punteroACondicion)(void *);
	punteroACondicion = &es_mayor;
	t_list* lista_filtrada;
	lista_filtrada=malloc(sizeof(t_list));
	lista_filtrada = list_filter(lista, punteroACondicion);
	return lista_filtrada;
}

//void list_sort(t_list *self, bool (*comparator)(void *, void *))

bool criterio_region_edad(void *puntero1, void *puntero2){
	info *registro1= malloc(sizeof(info));
	registro1=(info *)puntero1;
	info *registro2= malloc(sizeof(info));
	registro2=(info *)puntero2;
	if (registro1->region>registro2->region){
		return true;
	}
	else
	{
		if (registro1->region==registro2->region){
			if (registro1->edad>=registro2->edad){
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
}

t_list* oedenar_lista_region_edad(t_list *lista){
	bool (*punteroAComparador)(void *, void *);
	punteroAComparador = &criterio_region_edad;
	t_list* lista_ordenada;
	lista_ordenada=malloc(sizeof(t_list));
	lista_ordenada = list_sort(lista, punteroAComparador); //me tira error acá
	return lista_ordenada;
}