void destruir_mesa( mesa_t* mesa_votos )
{
lista_destruir(mesa_votos->boletas_en_mesa, destruir_boleta);
lista_destruir(mesa_votos->padron, destruir_votante);
lista_destruir(mesa_votos->personas_a_votar, destruir_votante);
free(mesa_votos);
}
void destruir(vector_t* vectorzonas, vector_t* vectorprecios, pila_t* pila){
int i;
lista_t * aux;
int* intaux;
pedido_t* pedidoaux;
i=vector_obtener_tamanio(vectorzonas);
for (i=0; i<vector_obtener_tamanio(vectorzonas);i++){
aux= vector_obtener(vectorzonas, i);
if (aux != NULL)
lista_destruir(aux,free);
}
for (i=0; i<vector_obtener_tamanio(vectorprecios);i++){
intaux= vector_obtener(vectorprecios, i);
if (intaux != NULL)
free(intaux);
}
vector_destruir(vectorzonas);
vector_destruir(vectorprecios);
if (pila) {
while (!pila_esta_vacia(pila)) {
pedidoaux=pila_desapilar(pila);
free(pedidoaux);
}
pila_destruir(pila);
}
}
bool redimensionar(hash_t* hash, unsigned long nuevo_largo){
lista_t** nueva_tabla = malloc(sizeof(lista_t*) * nuevo_largo);
for (int i = 0; i < nuevo_largo; i++){
nueva_tabla[i] = NULL;
}
lista_iter_t* iter_lista = NULL;
daton_t* paquete;
hash->tam = 0;
for (int a = 0; a < hash->largo ; a++){
if (hash->tabla[a]){
iter_lista = lista_iter_crear(hash->tabla[a]);
while (!lista_iter_al_final(iter_lista)){
paquete = lista_iter_ver_actual(iter_lista);
almacenar(hash, nueva_tabla, paquete, nuevo_largo);
lista_iter_avanzar(iter_lista);
}
lista_iter_destruir(iter_lista);
lista_destruir(hash->tabla[a], NULL);
}
}
hash->largo = nuevo_largo;
free(hash->tabla) ;
hash->tabla = nueva_tabla;
return true;
}
void destruir_curso(curso_t* curso){
free(curso->idc);
free(curso->descripcion);
free(curso->materia);
lista_destruir(curso->inscriptos,(destruccion_dato)&destruir_inscripto);
free(curso);
}
/* Procesar todos los votos y volcar resultados */
bool comando_cerrar(maquina_votacion_t* maquina, char* entrada[]) {
#ifdef DEBUG
printf("Comando cerrar ejecutado\n");
#endif
if(maquina->estado < ABIERTA) return error_manager(OTRO);
if(maquina->estado > ABIERTA || !cola_esta_vacia(maquina->cola) ) return error_manager(COLA_NO_VACIA);
lista_iter_t* iter = lista_iter_crear(maquina->listas);
if(!iter) return error_manager(OTRO);
while(!lista_iter_al_final(iter))
{
partido_politico_t* partido = lista_iter_ver_actual(iter);
if(!partido) { lista_iter_destruir(iter); return error_manager(OTRO); }
printf("%s:\n", partido_nombre(partido));
for(size_t i=0;i<partido_largo(partido);i++)
{
size_t* votos = partido_votos(partido)[i];
printf("%s: %zu votos\n", CARGOS[i], *votos);
}
// Liberar memoria
destruir_partido(partido);
lista_iter_avanzar(iter);
}
lista_iter_destruir(iter);
lista_destruir(maquina->listas, NULL);
maquina->listas = NULL;
return false;
}
void base_destruir(base_t* base){
//destruyo lo interior a la base
grafo_destruir(base->mapa);
heap_destruir(base->cerradofabricas,NULL);
lista_destruir(base->fabricasavisitar,NULL);
hash_destruir(base->fabricas);
//destruyo la base
free(base);
}
/* Llama a las funciones de destruccion necesarias */
void cerrar_maquina(maquina_votacion_t* maquina) {
if(maquina->padron)
lista_destruir(maquina->padron, votante_destruir);
maquina->padron = NULL;
if(maquina->listas)
lista_destruir(maquina->listas, destruir_partido);
maquina->listas = NULL;
if(maquina->cola)
cola_destruir(maquina->cola, votante_destruir);
maquina->cola = NULL;
/* Destruye la pila del ciclo de votacion */
if(maquina->ciclo)
pila_destruir(maquina->ciclo, free);
maquina->ciclo = NULL;
}
/**
* @brief Decompresses all palz files in a folder
* @details Receives a folder name and scans it looking for palz files. If it finds one it calls the decompression routine.
*
* @param dirname Name of the folder (directory) to decompress.
* @return Returns 0 if succesful.
*/
int folderDecompress (const char *dirname) {
int function = 2;
LISTA_GENERICA_T* listOfDir = lista_criar(NULL);
lista_inserir_inicio(listOfDir, strdup(dirname));
while (lista_numero_elementos(listOfDir) > 0) {
char *fdirname = lista_remover_inicio(listOfDir);
DIR *workdir = opendir(fdirname);
struct dirent *entry;
while ( ( entry = readdir(workdir) ) ) {
if( strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0 )
continue;
char *fullname = MALLOC(strlen(dirname) + strlen(entry->d_name) + 2);
sprintf(fullname, "%s/%s", dirname, entry->d_name);
struct stat info;
if( lstat(fullname, &info) != 0 ) {
WARNING("lstat() failed for item %s", fullname);
return -1;
}
if( S_ISDIR(info.st_mode) ) {
folderDecompress(fullname);
} else {
if (is_extension_palz(fullname) == -1)
{
FREE(fullname);
continue;
}else{
printf("Decompress file %s\n", fullname);
decompress(fullname, function);
}
}
FREE(fullname);
}
closedir(workdir);
FREE(fdirname);
}
lista_destruir(&listOfDir);
return 0;
}
void hash_destruir(hash_t* hash) {
for (int i = 0; i < hash->tamanio; i ++) {
lista_iter_t* iter = lista_iter_crear(hash->tabla[i]);
while (!lista_iter_al_final(iter)) {
nodo_hash_t* nodo = lista_borrar(hash->tabla[i],iter);
if (hash->destruir_dato) {
hash->destruir_dato(nodo->dato);
}
free(nodo->clave);
free(nodo);
}
lista_iter_destruir(iter);
lista_destruir(hash->tabla[i],NULL);
}
free(hash->tabla);
free(hash);
}
/*
Si recibe parametros validos, llama a funciones abrir de listas y padron.
*/
bool comando_abrir(maquina_votacion_t* maquina, char* entrada[]) {
#ifdef DEBUG
printf("Comando abrir ejecutado.");
#endif
if(!entrada[ENTRADA_LISTAS] || !entrada[ENTRADA_PADRON])
return error_manager(LECTURA);
if(maquina->estado >= ABIERTA)
return error_manager(MESA_ABIERTA);
maquina->listas = cargar_csv_en_lista(maquina, entrada[ENTRADA_LISTAS], enlistar_partido);
if(!maquina->listas) return false;
maquina->padron = cargar_csv_en_lista(maquina, entrada[ENTRADA_PADRON], enlistar_votante);
if(!maquina->padron) { lista_destruir(maquina->listas, votante_destruir); return false; }
maquina->cantidad_partidos = lista_largo(maquina->listas);
maquina->estado = ABIERTA;
return true;
}
base_t *base_crear(){
//creo la base
base_t* base = malloc(sizeof(base_t));
if (base == NULL) return NULL;
//creo los componentes de la base
base->mapa = grafo_crear();
base->fabricas = hash_crear((hash_destruir_dato_t)destruir_fabrica);
base->cerradofabricas = heap_crear((cmp_func_t)fabrica_cierra_primero);
base->fabricasavisitar = lista_crear();
//verifico si los componentes se crearon correctamente
if ((base->mapa==NULL) || (base->fabricas==NULL) || (base->cerradofabricas==NULL) || (base->fabricasavisitar==NULL)){
if (base->mapa!=NULL) grafo_destruir(base->mapa);
if (base->cerradofabricas!=NULL) heap_destruir(base->cerradofabricas,NULL);
if (base->fabricasavisitar!=NULL) lista_destruir(base->fabricasavisitar,NULL);
if (base->fabricas!=NULL) hash_destruir(base->fabricas);
return NULL;
}
base->capacidad = 0;
base->polonorte = 0;
//todo exitoso
return base;
}
hash_t* hash_redimensionar(hash_t* hash, size_t tamanio) {
lista_t** nueva_tabla = creacion_tabla(hash,tamanio);
if (nueva_tabla == NULL) return NULL;
for (int i = 0; i < hash->tamanio; i ++) {
lista_iter_t* iter = lista_iter_crear(hash->tabla[i]);
const char* clave;
size_t posicion;
nodo_hash_t* nodo;
while (!lista_iter_al_final(iter)) {
nodo = lista_borrar(hash->tabla[i],iter);
clave = nodo->clave;
posicion = fhash(clave,tamanio);
lista_insertar_primero(nueva_tabla[posicion],nodo);
}
lista_destruir(hash->tabla[i],NULL);
lista_iter_destruir(iter);
}
free(hash->tabla);
hash->tamanio = tamanio;
hash->tabla = nueva_tabla;
return hash;
}
void *hash_borrar(hash_t *hash, const char *clave){
unsigned long indice = fh(clave,hash->largo);
if (!hash->tabla[indice]) return NULL;
lista_iter_t* iter_l = busqueda(hash->tabla[indice], clave);
if (lista_iter_al_final(iter_l)) {
lista_iter_destruir(iter_l);
return NULL;
}
daton_t* aux = lista_iter_borrar(iter_l);
void* dato_salida = aux->dato;
free(aux->clave);
free(aux);
hash->tam--;
lista_iter_destruir(iter_l);
if (lista_esta_vacia(hash->tabla[indice])){
lista_destruir(hash->tabla[indice], NULL);
hash->tabla[indice] = NULL;
}
if (hash->tam < 3 * hash->largo && hash->largo > TAM_INI) {
unsigned long nuevo_largo = hash->largo / 2;
redimensionar(hash, nuevo_largo);
}
return dato_salida;
}
void cerrar_base_de_datos(base_t* basededatos){
lista_destruir(basededatos->listadecursos,(destruccion_dato)&destruir_curso);
free(basededatos);
}
void sesion_destruir(sesion_t* sesion){
lista_destruir(sesion->inscripciones,(destruccion_dato)&destruir_inscripcion);
free(sesion->padron);
free(sesion);
}
void destruir_lista (void* lista){
lista_destruir(lista, NULL);
return;
}
/* Pruebas */
void prueba_tipos() {
// Declaro de variables
lista_iter_t *iter;
lista_t* lista;
alumno_t* alumno1;
alumno_t* alumno2;
alumno_t* alumno3;
int padron1=94111;
int padron2=77777;
int padron3=10104;
// las inicializo
lista = lista_crear();
alumno1=alumno_crear(padron1);
alumno2=alumno_crear(padron2);
alumno3=alumno_crear(padron3);
printf("---------------------------PRUEBAS---------------------------\n");
//pruebo que este vacia
print_test("Pruebo que la lista se crea vacía", lista_esta_vacia(lista) );
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//inserto ultimo
print_test("Inserto ultimo elemento alumno2", lista_insertar_ultimo(lista,alumno2) );
//inesrto un nuevo ultimo
print_test("Inserto ultimo elemento alumno3", lista_insertar_ultimo(lista,alumno3) );
//veo el primero
print_test("Veo el primer elemento(alumno1)", alumno1==lista_ver_primero(lista));
//borro el primero y veo devuelta
print_test("Borro el primero", lista_borrar_primero(lista));
print_test("Veo el primer elemento(alumno2)", alumno2==lista_ver_primero(lista));
//veo el largo de la lista
print_test("Veo el largo de la lista (2)", 2==lista_largo(lista));
//creo iterador
iter= lista_iter_crear(lista);
//pruebas del iterador
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo elemento actual del iterador (alumno3)", alumno3==lista_iter_ver_actual(iter));
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo si esta al final", lista_iter_al_final(iter));
//pruebas de lista junto con iterador
print_test("Inserto de nuevo alumno1", lista_insertar(lista,iter,alumno1));
print_test("Lo borro", alumno1==lista_borrar(lista,iter));
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//destruyo el iterador
lista_iter_destruir(iter);
//creo iterador
iter= lista_iter_crear(lista);
print_test("Destruyo iterador,lo creo devuelta y borro el primer elemento (alumno1)", alumno1==lista_borrar(lista,iter));
destruir_dato(alumno1);
//destruyo lista e iterador
lista_iter_destruir(iter);
lista_destruir(lista,destruir_dato);
}
void lista_prueba(){
//Pruebo crear listas
lista_t* lista1 = lista_crear();
lista_t* lista2 = lista_crear();
lista_t* lista3 = lista_crear();
print_test("Probando si lista1 se creo bien", lista1!=NULL);
print_test("Probando si lista1 esta vacia", lista_esta_vacia(lista1));
print_test("Probando si el largo de lista2 es 0", lista_largo(lista2)==0);
int vector[]={ 1, 2, 3, 4};
char vector2[]="hola que tal";
// Probando insertar en la lista;
print_test("Probando si se inserta al principio un elemento en la lista1", lista_insertar_primero(lista1, &vector));
print_test("Probando si se inserta al final un elemento en la lista1", lista_insertar_ultimo(lista1, &vector2));
// Probando el largo de la lista con 2 elementos
print_test("Probando que el largo de la lista1 sea dos", lista_largo(lista1)==2);
// Probando el lista borrar primero en la lista 1
print_test("Probando si se borra el primer elemento en la lista1", lista_borrar_primero(lista1) == vector);
// Probando el lista ver primero
print_test("Probando ver el primero de la lista 1", lista_ver_primero(lista1) == vector2 );
// Probando agregar al principio en lista 3
print_test("Probando si se inserta al principio un elemento en la lista3", lista_insertar_primero(lista3, &vector));
lista_insertar_ultimo(lista3, &vector2);
// PRUEBAS CON EL ITERADOR CON LA LISTA 3
lista_iter_t* iter = lista_iter_crear(lista3);
// Probando el iter avanzar
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
// Probando el iter ver actual
print_test("Probando el iter ver actual", lista_iter_ver_actual(iter) == vector2);
// Probando el iter al final
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
print_test("Probando el iter avanzar (no puede avanzar mas)", lista_iter_avanzar(iter) == false);
print_test("Probando el iter al final", lista_iter_al_final(iter));
print_test("Probando si el iter esta el final el ver_actual", lista_iter_ver_actual(iter) == NULL);
lista_iter_destruir(iter);
// Probando lista_insertar con iterador
lista_iter_t* iter2 = lista_iter_crear(lista2);
char vector3[]="chau";
print_test("Probando el lista_insertar en la lista con el iter", lista_insertar(lista2,iter2,&vector3));
print_test("Probando ver el primero de la lista2", lista_ver_primero(lista2) == &vector3 );
print_test("Probando borrar con el iter", lista_borrar(lista2,iter2) == vector3 );
print_test("Probando el lista_ver_primero con los nodos borrados", lista_ver_primero(lista2) == NULL );
print_test("Probando el largo de una lista vacia", lista_largo(lista2) == 0 );
print_test("Probando el lista_borrar_primero en una lista vacia", lista_borrar_primero(lista2) == NULL );
lista_iter_destruir(iter2);
// Pruebo Agregar 30 Datos y luego borrarlos
for ( int i=0 ; i < 30 ; i++){
lista_insertar_ultimo(lista2, &i);
}
print_test("Probando el largo de la lista2 luego de agregar 30 elementos", lista_largo(lista2) == 30);
lista_iter_t* iter3=lista_iter_crear(lista2);
while (!lista_iter_al_final(iter3)){
lista_borrar(lista2,iter3);
}
print_test("Probando que se borraron todos los elementos" , lista_largo(lista2) == 0);
print_test("Prubando borrar un elemento en una lista vacia" , lista_borrar(lista2,iter3) == NULL);
lista_iter_destruir(iter3);
//Finalmente, pruebo si estan vacias las 3 listas
print_test( "Probando que la lista1 no este vacia", lista_esta_vacia(lista1) == false );
print_test( "Probando que la lista2 este vacia", lista_esta_vacia(lista2) );
print_test( "Probando que la lista3 no este vacia", lista_esta_vacia(lista3) == false );
//Elimino las 3 listas
lista_destruir(lista1, NULL);
lista_destruir(lista2, NULL);
lista_destruir(lista3, NULL);
/* ******************************************************************
* Pruebas con lista 4
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista4 = lista_crear();
for( int num=1; num <= 10 ; num++){
int elemento=1;
lista_insertar_ultimo(lista4 , &elemento);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 10 );
lista_iter_t* iter4= lista_iter_crear(lista4);
print_test("Probando que se creo el iter 4", iter4!=NULL);
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
for (int j=1; j<=10; j++){
lista_iter_avanzar(iter4);
}
print_test("Probando que el iter 4 este al final", lista_iter_al_final(iter4));
char prueba[] = "prueba";
print_test("Probando lista_insertar con el iter al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
print_test("Probando avanzar con el iter 4 al final", lista_iter_avanzar(iter4));
print_test("Probando lista_borrar con el iter 4 al final", lista_borrar(lista4,iter4) == NULL);
print_test("Probando lista_insertar con el iter 4 al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando lista_borrar con el iter 4", lista_borrar(lista4,iter4) == prueba);
for (int j=0; j<=10; j++){
lista_borrar_primero(lista4);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 0 );
// elimino el iter 4
lista_iter_destruir(iter4);
//Elimino la lista
lista_destruir(lista4, free);
/* ******************************************************************
* Pruebas con lista 5
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista5 = lista_crear();
// le creo un iter
lista_iter_t* iter5= lista_iter_crear(lista5);
print_test("Probando que se creo el iter 5", iter5!=NULL);
for( int num=1; num <= 10 ; num++){
char elemento2[]="hola";
lista_insertar(lista5, iter5, &elemento2);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 10 );
print_test("Probando que el iter 5 no este al final", lista_iter_al_final(iter5) == false);
char prueba2[] = "prueba";
print_test("Probando lista_borrar con el iter 5 al principio", lista_borrar(lista5,iter5) != NULL);
print_test("Probando lista_insertar con el iter 5 al principio", lista_insertar(lista5, iter5, &prueba2));
print_test("Probando lista_borrar con el iter 5 ", lista_borrar(lista5,iter5) == prueba2);
for (int j=0; j<=10; j++){
lista_borrar(lista5, iter5);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 0 );
print_test("Probando que la lista 5 este vacia", lista_esta_vacia(lista5));
print_test("Probando lista ver_primero de la lista 5", lista_ver_primero(lista5) == NULL);
print_test("Probando avanzar con el iter 5 al final", lista_iter_avanzar(iter5) == false);
print_test("Probando avanzar con el iter 5 al final", lista_iter_ver_actual(iter5) == NULL);
// elimino el iter 5
lista_iter_destruir(iter5);
//Elimino la lista
lista_destruir(lista5, free);
/* ******************************************************************
* Pruebas con lista 6
* *****************************************************************/
// Creo una nueva Lista
lista_t* lista6 = lista_crear();
// le creo un iter
lista_iter_t* iter6= lista_iter_crear(lista6);
print_test("Probando que se creo el iter 6", iter6!=NULL);
void* elemento = malloc(sizeof(void*)) ;
print_test("Probando agregar un elemento con lista_insertar con la lista 6 vacia", lista_insertar(lista6, iter6, elemento));
print_test("Probando largo de la lista 6", lista_largo(lista6) == 1 );
print_test("Probando que el iter 6 no este al final", lista_iter_al_final(iter6) == false);
print_test("Probando si puedo avanzar con el iter 6", lista_iter_avanzar(iter6));
print_test("Probando que el iter 6 este al final", lista_iter_al_final(iter6));
void* borrar=lista_borrar_primero(lista6);
free(borrar);
// elimino el iter 6
lista_iter_destruir(iter6);
//Elimino la lista 6
lista_destruir(lista6, free);
/* ******************************************************************
* Pruebas con lista 7
* *****************************************************************/
lista_t* lista7 = lista_crear();
for (int x=1 ; x<=10 ; x++){
lista_insertar_primero(lista7, &x);
}
lista_iter_t* iter7 = lista_iter_crear(lista7);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
while (!lista_iter_al_final(iter7)){
lista_iter_avanzar(iter7);
}
void* y;
print_test("Probando si se puede ver el elemento actual del iter", lista_iter_ver_actual(iter7) == NULL);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el largo de la lista7 sea 11", lista_largo(lista7) == 11);
print_test("Probando borrar el ultimo elemento de lista7", lista_borrar(lista7,iter7) == &y);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el iter7 no quede al final", lista_iter_al_final(iter7) == false);
lista_iter_destruir(iter7);
lista_destruir(lista7, NULL);
/* ******************************************************************
* Pruebas con lista 8
* *****************************************************************/
lista_t* lista8 = lista_crear();
for (int x=1 ; x<=5 ; x++){
lista_insertar_ultimo(lista8, &x);
}
print_test("Probando que el largo de la lista8 sea 5", lista_largo(lista8) == 5);
lista_iter_t* iter8 = lista_iter_crear(lista8);
int elem=0;
print_test("Probando que el elemento actual del iter8 no es null", lista_iter_ver_actual(iter8) != NULL);
print_test("Probando insertar al principio con el iter en lista8", lista_insertar(lista8, iter8, &elem));
print_test("Probando que el largo de lista8 sea 6", lista_largo(lista8) == 6);
print_test("Probando eliminar el primer elemento de la lista8 con el iter", lista_borrar(lista8, iter8) == &elem);
print_test("Probado que el largo de la lista8 es 5", lista_largo(lista8) == 5);
print_test("Probando insertar un elemento en la primera posicion de lista8", lista_insertar_primero(lista8, &elem));
print_test("Probando que el actual del iter8 sea distinto que el primero de lista8", lista_ver_primero(lista8) != lista_iter_ver_actual(iter8));
lista_iter_destruir(iter8);
lista_destruir(lista8 , NULL);
/* ******************************************************************
* Pruebas con lista 9
* *****************************************************************/
lista_t* lista9 = lista_crear();
int num;
print_test("Probando insertar el elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando que el largo de lista9 es 1", lista_largo(lista9));
lista_iter_t* iter9 = lista_iter_crear(lista9);
print_test("Probando que el elemento actual del iter9 no es null", lista_iter_ver_actual(iter9) != NULL);
print_test("Probando borrar el elemento de lista9 con el iter", lista_borrar(lista9, iter9) == &num);
print_test("Probando que el largo de lista9 es 0", lista_largo(lista9) == 0);
print_test("Probando borrar un elemento de la lista9 que esta vacia", lista_borrar(lista9, iter9) == NULL);
print_test("Probando avanzar en lista9 que esta vacia", lista_iter_avanzar(iter9) == false);
print_test("Probando agregar un elemento con el iter9", lista_insertar(lista9, iter9, &num));
print_test("Probando eliminar el ultimo elemento con el iter9", lista_borrar(lista9, iter9) == &num);
print_test("Probando agregar un elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando eliminar el ultimo elemento con borrar primero", lista_borrar_primero(lista9) == &num);
lista_iter_destruir(iter9);
lista_destruir(lista9 , NULL);
lista_t* lista10= lista_crear();
int i=0;
print_test("Probando agregar un elemento a lista10", lista_insertar_primero(lista10 , &i));
print_test("Probando eliminar primer elemento", lista_borrar_primero(lista10) != NULL);
lista_destruir(lista10, NULL);
}
mesa_t* abrir_mesa(char *mesa_electoral, char *padron)
{
mesa_t* la_mesa;
if( !(la_mesa = malloc(sizeof(mesa_t))) )
return NULL;
la_mesa->estado = false;
la_mesa->boletas_en_mesa = lista_crear();
la_mesa->personas_a_votar = lista_crear();
la_mesa->padron = lista_crear();
if( !la_mesa->boletas_en_mesa || !la_mesa->personas_a_votar || !la_mesa->padron )
{
fprintf(stderr, "ERROR1\n");
return NULL;
}
if( mesa_electoral == NULL || padron == NULL )
{
fprintf(stderr, "ERROR1\n");
lista_destruir(la_mesa->boletas_en_mesa, NULL);
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->padron, NULL);
free(la_mesa);
return NULL;
}
FILE *postulantes, *votantes;
if( !(postulantes = fopen(mesa_electoral, "r")) )
{
fprintf(stderr, "ERROR2\n");
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->boletas_en_mesa, NULL);
lista_destruir(la_mesa->padron, NULL);
free(la_mesa);
return NULL;
}
if( !(votantes = fopen(padron, "r")) )
{
fprintf(stderr, "ERROR2\n");
fclose(postulantes);
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->boletas_en_mesa, NULL);
lista_destruir(la_mesa->padron, NULL);
free(la_mesa);
return NULL;
}
char *linea_fixeada;
fila_csv_t* parseado;
while( (linea_fixeada = leer_linea(postulantes)) != NULL )
{
parseado = parsear_linea_csv(linea_fixeada, 5);
boleta_t* nueva_boleta;
if( ( nueva_boleta = malloc(sizeof(boleta_t)) ) == NULL )
{
lista_destruir(la_mesa->boletas_en_mesa, NULL);
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->padron, NULL);
fclose(postulantes);
fclose(votantes);
free(la_mesa);
return NULL;
}
nueva_boleta->IDpartido = atoi(obtener_columna(parseado, 0));
nueva_boleta->nombrePartido = strdup(obtener_columna(parseado, 1));
nueva_boleta->presidente = strdup(obtener_columna(parseado, 2));
nueva_boleta->gobernador = strdup(obtener_columna(parseado, 3));
nueva_boleta->intendente = strdup(obtener_columna(parseado, 4));
nueva_boleta->votos_recibidos[0] = 0;
nueva_boleta->votos_recibidos[1] = 0;
nueva_boleta->votos_recibidos[2] = 0;
lista_insertar_ultimo(la_mesa->boletas_en_mesa, nueva_boleta);
destruir_fila_csv(parseado, false);
}
while( (linea_fixeada = leer_linea(votantes)) != NULL )
{
parseado = parsear_linea_csv(linea_fixeada, 2);
votante_t* nuevo_votante;
if( ( nuevo_votante = malloc(sizeof(votante_t)) ) == NULL )
{
lista_destruir(la_mesa->boletas_en_mesa, destruir_boleta);
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->padron, NULL);
fclose(postulantes);
fclose(votantes);
free(la_mesa);
return NULL;
}
nuevo_votante->tipoDNI = strdup(obtener_columna(parseado, 0));
nuevo_votante->numeroDNI = atoi((obtener_columna(parseado, 1)));
nuevo_votante->voto_realizado = false;
lista_insertar_ultimo(la_mesa->padron, nuevo_votante);
destruir_fila_csv(parseado, false);
}
fclose(votantes);
fclose(postulantes);
return la_mesa;
}
void destruir_fabrica(fabrica_t* fabrica){
while (!lista_esta_vacia(fabrica->juguetes)) destruir_juguete(lista_borrar_primero(fabrica->juguetes));
free(fabrica->idfabrica);
lista_destruir(fabrica->juguetes,NULL);
free(fabrica);
}
void TransfAde_EliminarTodas(tListaUsuariosADS *lista)
{
lista_destruir(lista);
}
