int sesion_deshacer(sesion_t* sesion){
if (strcmp(sesion->padron,"00000")==0) return -1;
if (lista_largo(sesion->inscripciones)==0) return -2;
lista_iter_t* iteradordeprueba = lista_iter_crear(sesion->inscripciones);
lista_iter_t* iteradorreal = lista_iter_crear(sesion->inscripciones);
while(!lista_iter_al_final(iteradordeprueba)){
lista_iter_avanzar(iteradordeprueba);
if (!lista_iter_al_final(iteradordeprueba)) lista_iter_avanzar(iteradorreal);
}
destruir_inscripcion((inscripcion_t*)lista_borrar(sesion->inscripciones,iteradorreal));
//destruir_inscripcion((inscripcion_t*)lista_borrar_primero(sesion->inscripciones));
lista_iter_destruir(iteradordeprueba);
lista_iter_destruir(iteradorreal);
return 0;
}
/* 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;
}
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* hash_borrar(hash_t* hash, const char* clave) {
if (!hash_pertenece(hash,clave)) return NULL;
size_t posicion = fhash(clave,hash->tamanio);
lista_iter_t* iter = lista_iter_crear(hash->tabla[posicion]);
nodo_hash_t* nodo = lista_iter_ver_actual(iter);
bool esta = false;
while (!lista_iter_al_final(iter)) {
if (strcmp(nodo->clave,clave) == 0) {
esta = true;
break;
}
lista_iter_avanzar(iter);
nodo = lista_iter_ver_actual(iter);
}
if (esta == false) {
lista_iter_destruir(iter);
return NULL;
}
nodo = (nodo_hash_t*)lista_borrar(hash->tabla[posicion],iter);
void* dato = nodo->dato;
free(nodo->clave);
free(nodo);
lista_iter_destruir(iter);
hash->cantidad --;
return dato;
}
bool preparar_pedidos(vector_t * vectorzonas, vector_t * vectorprecios){
int i, lvacias=0;
pedido_t *pedido;
lista_iter_t *iter;
lista_t* listaaux;
int cantidad=vector_obtener_cantidad(vectorzonas);
for (i=0; i<cantidad; i++){
listaaux= (lista_t*) vector_obtener(vectorzonas, i);
if(lista_esta_vacia(listaaux)==true){
lvacias++;
printf("No hay pedidos en la zona %d\n", i+1);
}
}
if (lvacias==cantidad) return false;
for (i=0; i<cantidad; i++){
listaaux= (lista_t*) vector_obtener(vectorzonas, i);
iter=lista_iter_crear(listaaux);
while (lista_iter_al_final(iter)==false){
pedido=(pedido_t *)(lista_iter_ver_actual(iter));
pedido->preparado=true;
lista_iter_avanzar(iter);
}
lista_iter_destruir(iter);
}
return true;
}
int listar_fabricas(base_t* base,bool imprimir){
int hora,minutos;
fabrica_t* fabrica;
fabrica_t* anterior;
if (lista_esta_vacia(base->fabricasavisitar)){
//creo una lista con las fabricas que voy a visitar
anterior = heap_desencolar(base->cerradofabricas);
lista_insertar_ultimo(base->fabricasavisitar,(void*)anterior);
while (!heap_esta_vacio(base->cerradofabricas)){
fabrica = heap_desencolar(base->cerradofabricas);
if (fabrica->horarioentrada>=anterior->horariosalida){
lista_insertar_ultimo(base->fabricasavisitar,(void*)fabrica);
anterior = fabrica;
}
}
}
if (imprimir){
printf("Cantidad: %zu\n",lista_largo(base->fabricasavisitar));
lista_iter_t* iterador = lista_iter_crear(base->fabricasavisitar);
while(!lista_iter_al_final(iterador)){
fabrica = lista_iter_ver_actual(iterador);
conversion_horario(&hora,&minutos,fabrica->horarioentrada);
printf("%s,%02d:%02d,",fabrica->idfabrica,hora,minutos);
conversion_horario(&hora,&minutos,fabrica->horariosalida);
printf("%02d:%02d\n",hora,minutos);
lista_iter_avanzar(iterador);
}
lista_iter_destruir(iterador);
}
return 0;
}
lista_iter_t* busqueda(lista_t* lista, const char* clave){
lista_iter_t* iter = lista_iter_crear(lista);
daton_t* aux= lista_iter_ver_actual(iter);
while (!lista_iter_al_final(iter) && strcmp(aux->clave, clave) != 0) {
lista_iter_avanzar(iter);
aux= lista_iter_ver_actual(iter);
}
return iter;
}
curso_t* conseguir_curso(char* idc, lista_t* lista){
int i;
int posicion = existe_curso(idc,lista);
lista_iter_t* iterador = lista_iter_crear(lista);
for(i=0;i<posicion;i++) lista_iter_avanzar(iterador);
curso_t* curso = NULL;
curso = lista_iter_ver_actual(iterador);
lista_iter_destruir(iterador);
return curso;
}
int eliminar_curso(char* idc,base_t* basedatos){
int i;
int pos = existe_curso(idc,basedatos->listadecursos);
if (pos==-1) return -1;
lista_iter_t* iterador = lista_iter_crear(basedatos->listadecursos);
for(i=0;i<pos;i++) lista_iter_avanzar(iterador);
destruir_curso((curso_t*)lista_borrar(basedatos->listadecursos,iterador));
lista_iter_destruir(iterador);
return 0;
}
/*
Desencolar y realizar validacion del Documento tipo/numero del votante y no haber votado
Crear pila para ciclo de votacion actual
*/
bool comando_votar_inicio(maquina_votacion_t* maquina) {
#ifdef DEBUG
printf("Comando votar inicio ejecutado.\n");
#endif
// Error handling
if(maquina->estado == CERRADA) { return error_manager(MESA_CERRADA); }
if(maquina->estado == VOTACION) { return error_manager(OTRO); }
if(cola_esta_vacia(maquina->cola)) { return error_manager(NO_VOTANTES); }
votante_t* votante_padron = NULL;
bool enpadronado = false;
votante_t* votante_espera = cola_desencolar(maquina->cola);
if(!votante_espera) return error_manager(OTRO);
#ifdef DEBUG
printf("Votante desencolado: %s, %s\n", votante_espera->documento_tipo, votante_espera->documento_numero);
#endif
pila_t* ciclo_votacion = pila_crear();
lista_iter_t* lista_iter = lista_iter_crear(maquina->padron);
if(!ciclo_votacion || !lista_iter) {
if(ciclo_votacion) pila_destruir(ciclo_votacion, NULL);
if(lista_iter) free(lista_iter);
return error_manager(OTRO);
}
while(!lista_iter_al_final(lista_iter))
{
votante_padron = lista_iter_ver_actual(lista_iter);
if(votante_iguales(votante_padron, votante_espera))
{
enpadronado = true;
break;
}
lista_iter_avanzar(lista_iter);
}
lista_iter_destruir(lista_iter);
votante_destruir(votante_espera);
if(!enpadronado || votante_get_voto_realizado(votante_padron))
{
pila_destruir(ciclo_votacion, NULL);
return enpadronado ? error_manager(VOTO_REALIZADO) : error_manager(NO_ENPADRONADO);
}
votante_set_voto_realizado(votante_padron);
maquina->estado = VOTACION;
maquina->ciclo = ciclo_votacion;
maquina->votando_cargo = PRESIDENTE;
mostrar_menu_votacion(maquina);
return true;
}
int desinscribir(char* padron, char* idc, base_t* basedatos){
int i,posicion;
curso_t* curso = conseguir_curso(idc,basedatos->listadecursos);
if (curso==NULL) return -1;
posicion = alumno_inscripto(padron,curso->inscriptos);
if (posicion==-1) return -2;
lista_iter_t* iterador = lista_iter_crear(curso->inscriptos);
for(i=0;i<posicion;i++) lista_iter_avanzar(iterador);
destruir_inscripto((char*)lista_borrar(curso->inscriptos,iterador));
lista_iter_destruir(iterador);
return 0;
}
int alumno_inscripto(char* padron,lista_t* lista){
int i = 0;
int estainscripto = -1;
char* inscripto;
lista_iter_t* iterador = lista_iter_crear(lista);
while((!lista_iter_al_final(iterador)) && (estainscripto==-1)){
inscripto = (char*) lista_iter_ver_actual(iterador);
if (strcmp(inscripto,padron)==0) estainscripto=i;
lista_iter_avanzar(iterador);
i++;
}
lista_iter_destruir(iterador);
return estainscripto;
}
int sesion_inscribir(char* idc,base_t* basedatos, sesion_t* sesion){
//verifico si hay sesion iniciada
if (strcmp(sesion->padron,"00000")==0) return -3;
//verifico si existe el curso
int pos = existe_curso(idc,basedatos->listadecursos);
if (pos==-1) return -2;
//verifico si ya estaba programada la inscripcion
bool yaanotado = false;
inscripcion_t* inscripcion;
lista_iter_t* iterador = lista_iter_crear(sesion->inscripciones);
while(!lista_iter_al_final(iterador) && !yaanotado){
inscripcion = (inscripcion_t*)lista_iter_ver_actual(iterador);
if (strcmp(inscripcion->curso,idc)==0) yaanotado=true;
lista_iter_avanzar(iterador);
}
lista_iter_destruir(iterador);
if (yaanotado==true) return -4;
//consigo el curso
int i;
iterador = lista_iter_crear(basedatos->listadecursos);
for(i=0;i<pos;i++) lista_iter_avanzar(iterador);
curso_t* curso = (curso_t*) lista_iter_ver_actual(iterador);
lista_iter_destruir(iterador);
//verifico si ya esta anotado en el curso
if (alumno_inscripto(sesion->padron,curso->inscriptos)!=-1) return -1;
//creo la inscripcion
inscripcion = malloc(sizeof(inscripcion_t));
if (inscripcion==NULL) return -5;
//programo la inscripcion
inscripcion->curso = malloc(LIDC*sizeof(char));
strcpy(inscripcion->curso,idc);
((curso->vacantes)>lista_largo(curso->inscriptos)) ? (inscripcion->estado=false) : (inscripcion->estado=true);
lista_insertar_ultimo(sesion->inscripciones,inscripcion);
if (inscripcion->estado) return 1;
return 2;
}
int existe_curso(char* idc,lista_t* lista){
int vuelta = -1;
int i = 0;
lista_iter_t* iterador = lista_iter_crear(lista);
curso_t* curso;
do{
curso = (curso_t*) lista_iter_ver_actual(iterador);
if (curso!=NULL){
if (strcmp(idc,curso->idc)==0) vuelta=i;
}
i++;
}while(lista_iter_avanzar(iterador) && (vuelta==-1));
lista_iter_destruir(iterador);
return vuelta;
}
bool hash_iter_avanzar(hash_iter_t *iter){
if(hash_iter_al_final(iter)) return false;
lista_iter_avanzar(iter->iter_lista);
if (lista_iter_al_final(iter->iter_lista)) {
iter->indice_actual++;
while (iter->indice_actual < iter->hash->largo){
if (iter->hash->tabla[iter->indice_actual]){
lista_iter_destruir(iter->iter_lista);
iter->iter_lista = lista_iter_crear(iter->hash->tabla[iter->indice_actual]);
return true;
}
iter->indice_actual++;
}
}
return true;
}
int valuar_juguetes_total(base_t* base){
int totalsonrisas = 0;
int sonrisasfabricas;
fabrica_t* fabrica;
//if (lista_esta_vacia(base->fabricasavisitar)) return -1; //la lista esta vacia y hay que ver cuales visitar antes
if (lista_esta_vacia(base->fabricasavisitar)) listar_fabricas(base,false); //la lista esta vacia y hay que ver cuales visitar antes
lista_iter_t* iterador = lista_iter_crear(base->fabricasavisitar);
while (!lista_iter_al_final(iterador)){
fabrica = (fabrica_t*)lista_iter_ver_actual(iterador);
sonrisasfabricas = valuar_juguetes(base,fabrica->idfabrica);
totalsonrisas = (totalsonrisas + sonrisasfabricas);
lista_iter_avanzar(iterador);
}
lista_iter_destruir(iterador);
return totalsonrisas;
}
// Itera la lista aplicandole la funcion visitar a cada dato almacenado, pasandole el parametro extra para que esta lo utilice
// Pre: la lista fue creada
void lista_iterar(lista_t *lista, bool (*visitar)(void *dato, void *extra), void *extra)
{
if(!lista || !visitar || !extra)
return;
lista_iter_t *iter = lista_iter_crear(lista);
if(!iter)
return;
while( !lista_iter_al_final(iter) && visitar(lista_iter_ver_actual(iter), extra) )
lista_iter_avanzar(iter);
lista_iter_destruir(iter);
}
void listar_cursos(char* filtro,base_t* basedatos){
lista_iter_t* iterador = lista_iter_crear(basedatos->listadecursos);
curso_t* curso;
int inscriptos;
while(!lista_iter_al_final(iterador)){
curso = lista_iter_ver_actual(iterador);
inscriptos = lista_largo(curso->inscriptos);
if (filtro[0]=='\0'){
fprintf(stdout,"%s: %s (%s) Vacantes: %d Inscriptos: %d\n",curso->idc,curso->descripcion,curso->materia,curso->vacantes,inscriptos);
}else{
if (strcmp(filtro,curso->materia)==0) fprintf(stdout,"%s: %s (%s) Vacantes: %d Inscriptos: %d\n",curso->idc,curso->descripcion,curso->materia,curso->vacantes,inscriptos);
}
lista_iter_avanzar(iterador);
}
lista_iter_destruir(iterador);
}
bool cancelar_pedido(vector_t * vectorzonas, char n[], int cantidad, int zona){
pedido_t *auxpedido;
lista_t* listaaux= (lista_t*) vector_obtener(vectorzonas, (zona-1));
lista_iter_t *iter=lista_iter_crear(listaaux);
while (lista_iter_al_final(iter)==false){
auxpedido=(pedido_t*)(lista_iter_ver_actual(iter));
if ( ( (strcmp (auxpedido->nombre,n)==0)) && auxpedido->cantidad==cantidad){
printf("Se borro el pedido, %s",auxpedido->nombre);
lista_borrar(listaaux, iter);
return true;
}
lista_iter_avanzar(iter);
}
return false;
}
bool hash_iter_avanzar(hash_iter_t* iter) {
//verifico no estar ya al final
if (hash_iter_al_final(iter)) return false;
//avanzo y verifico no estar ahora al final
lista_iter_avanzar(iter->iter);
if (!lista_iter_al_final(iter->iter)) return true;
//como estoy al final de la lista, busco si tengo a donde seguir
if (iter->posicion == (iter->hash->tamanio)-1) return false;
//como lo tengo, busco
size_t posicion = buscar_no_vacia(iter->hash,iter->posicion+1);
if (!lista_esta_vacia(iter->hash->tabla[posicion])) {
lista_iter_destruir(iter->iter);
iter->iter = lista_iter_crear(iter->hash->tabla[posicion]);
iter->posicion = posicion;
return true;
}
return false;
}
void sesion_ver(sesion_t* sesion){
if (strcmp(sesion->padron,"00000")==0){
fprintf(stdout,"Error: no hay una sesion en curso\n");
return;
}
fprintf(stdout,"Padron: %s\n",sesion->padron);
if (lista_largo(sesion->inscripciones)==0){
fprintf(stdout,"No hay inscripciones\n");
return;
}
lista_iter_t* iterador = lista_iter_crear(sesion->inscripciones);
inscripcion_t* inscripcion;
while(!lista_iter_al_final(iterador)){
inscripcion = (inscripcion_t*)lista_iter_ver_actual(iterador);
fprintf(stdout,"%s ",inscripcion->curso);
(inscripcion->estado) ? fprintf(stdout,"(condicional)\n") : fprintf(stdout,"(regular)\n");
lista_iter_avanzar(iterador);
}
lista_iter_destruir(iterador);
}
// Funcion auxiliar que busca la clave en la lista y devuelve el nodo
nodo_hash_t* buscar_clave(lista_t* lista, const char* clave) {
lista_iter_t* iter = lista_iter_crear(lista);
bool esta = false;
nodo_hash_t* nodo;
do {
nodo = (nodo_hash_t*)lista_iter_ver_actual(iter);
if (nodo != NULL) {
if (strcmp(clave,nodo->clave) == 0) {
esta = true;
}
}
} while(lista_iter_avanzar(iter) && !esta);
if (esta == false) {
lista_iter_destruir(iter);
return NULL;
}
lista_iter_destruir(iter);
if (nodo == NULL) return NULL;
return nodo;
}
void mostrar_registrados (vector_t *vectorzonas){
int i;
pedido_t *auxpedido;
lista_t* listaaux;
int cantidad = vector_obtener_cantidad(vectorzonas);
for (i=0; i<cantidad; i++){
listaaux = (lista_t*) vector_obtener(vectorzonas,i);
printf("\n");
lista_iter_t *iter;
iter=lista_iter_crear(listaaux);
printf("Pedidos registrados de la zona %d\n", i+1);
printf("Nombre cantidad zona\n");
while(lista_iter_al_final(iter)==false){
auxpedido=(pedido_t *)(lista_iter_ver_actual(iter));
printf("%s %d %d\n",auxpedido->nombre, auxpedido->cantidad, auxpedido->zona);
if (auxpedido->preparado==true) printf ("Preparado\n");
lista_iter_avanzar(iter);
}
lista_iter_destruir(iter);
}
}
bool modificar_pedido(vector_t * vectorzonas, char n[], int cantidad){
int i;
if (cantidad<0 || cantidad>5) {
printf("La cantidad maxima permitida es de 5 pizzas\n");
return false;
}
bool encontrado=false;
pedido_t *pedido,*pedidoaux;
lista_iter_t *iter;
lista_t * listaaux;
for (i=0;i<vector_obtener_cantidad(vectorzonas);i++){
listaaux= (lista_t*) vector_obtener(vectorzonas, i);
iter=lista_iter_crear(listaaux);
while ( (!lista_iter_al_final(iter)) && (!encontrado) ){
pedidoaux=(pedido_t*) (lista_iter_ver_actual(iter));
if (pedidoaux){
if (strcmp (pedidoaux->nombre,n)==0){
pedido=(lista_iter_ver_actual(iter));
encontrado=true;
}
}
lista_iter_avanzar(iter);
}
lista_iter_destruir(iter);
}
if (encontrado){
pedido->cantidad=cantidad;
return true;
}
return false;
}
int valuar_juguetes(base_t* base,char* idfabrica){
if (!hash_pertenece(base->fabricas,idfabrica)) return -1;
int sonrisas = 0;
int i;
//creo la mochila y la inicializo
int* mochila = calloc(base->capacidad+1,sizeof(int));
fabrica_t* fabrica = hash_obtener(base->fabricas,idfabrica);
//creo el iterador para recorrer los juguetes que tiene la fabrica
lista_iter_t* iterador = lista_iter_crear(fabrica->juguetes);
juguete_t* juguete = lista_iter_ver_actual(iterador);
while(juguete!=NULL){
for(i=base->capacidad;i>0;i--){
if (i-(juguete->peso)>=0){
if (mochila[i]<(mochila[i-juguete->peso]+juguete->valor)) mochila[i]=(mochila[i-juguete->peso]+juguete->valor);
}
}
lista_iter_avanzar(iterador);
juguete = lista_iter_ver_actual(iterador);
}
sonrisas = mochila[base->capacidad];
lista_iter_destruir(iterador);
free(mochila);
return sonrisas;
}
void lista_iterar(lista_t *lista, bool (*visitar)(void *dato, void *extra), void *extra) {
lista_iter_t* iter = lista_iter_crear(lista);
void* dato = lista_iter_ver_actual(iter);
while ((lista_iter_avanzar(iter)) && (visitar(dato, extra))) dato = lista_iter_ver_actual(iter);
lista_iter_destruir(iter);
}
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);
}
/* 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 enviar(vector_t * vectorzonas, pila_t* pila){
lista_iter_t *iter,*iterborrar;
bool primeroencontrado;
int i,canti,cantf,total;
pedido_t *pedidoaux,*primerpedido,*pedidof;
lista_t* listaaux;
for (i=0;i<vector_obtener_cantidad(vectorzonas);i++){
primeroencontrado=true;
while(primeroencontrado)
{
primeroencontrado=false;
canti=0;
cantf=0;
total=0;
pedidof=NULL;
listaaux= (lista_t*) vector_obtener(vectorzonas, i);
iter=lista_iter_crear(listaaux);
while ( !lista_iter_al_final(iter) )
{
pedidoaux=(pedido_t*) (lista_iter_ver_actual(iter));
if (pedidoaux !=NULL)
{
if ( (!primeroencontrado) && (pedidoaux->preparado))
{
primerpedido=pedidoaux; //primer pedido es el primer pedido preparado de esa zona
canti=pedidoaux->cantidad;
primeroencontrado=true;
}
else if (pedidoaux->preparado)
{
cantf=pedidoaux->cantidad;
if ( ((canti + cantf)<=5) && ((canti+cantf)>total) )
{
pedidof=pedidoaux;
total=canti+cantf;
}
}
}
lista_iter_avanzar(iter);
}
lista_iter_destruir(iter);
if ( (primeroencontrado) && (pedidof!=NULL))
printf("Se envio el pedido %s junto con el pedido %s \n",primerpedido->nombre,pedidof->nombre);
else if (primeroencontrado){
printf("Se envio el pedido %s \n",primerpedido->nombre);
}
iterborrar=lista_iter_crear(listaaux);
while (!lista_iter_al_final(iterborrar))
{
if ( primerpedido==lista_iter_ver_actual(iterborrar) )
{
pila_apilar(pila,primerpedido);
lista_borrar(listaaux,iterborrar);
}
else{
if (pedidof==lista_iter_ver_actual(iterborrar))
{
pila_apilar(pila,pedidof);
lista_borrar(listaaux,iterborrar);
}
else lista_iter_avanzar(iterborrar);
}
}
lista_iter_destruir(iterborrar);
}
}
}
