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;
}
// Devuelve el puntero al dato alacenado en la posicion que se encuentra el iterador
// Pre: el iterador fue creado
// Post: Se devolvio un puntero al dato o NULL
void* lista_iter_ver_actual(const lista_iter_t *iter)
{
if(!iter || lista_iter_al_final(iter))
return NULL;
return iter->nodo_act->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;
}
/* 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;
}
// Elimina un elemento de la lista en la posicion actual del iterador
// Pre: el iterador y la lista fueron creados
// Post: devuelve un puntero al dato del nodo que fue borrado o NULL si algun parametro no es correcto
void* lista_borrar(lista_t *lista, lista_iter_t *iter)
{
if(!lista || !iter || lista_iter_al_final(iter) || lista_esta_vacia(lista))
return NULL;
nodo_t *nodo = iter->nodo_act;
void *dato = nodo->dato;
// Caso 1: Iter al principio de la lista
if(iter->nodo_ant == NULL)
{
lista->primero = iter->nodo_act->siguiente;
iter->nodo_act = lista->primero;
}
else
{
iter->nodo_ant->siguiente = iter->nodo_act->siguiente;
iter->nodo_act = iter->nodo_ant->siguiente;
}
free(nodo);
lista->largo--;
if(lista_largo(lista)==1)
lista->ultimo = lista->primero;
return dato;
}
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;
}
// Borra de la lista el elemento en donde se encuentra el iterador y
// devuelve su valor. Devuelve NULL en caso de estar al final de la lista
// o que la lista esté vacía.
// Pre: la lista y el iterador fueron creados
// Post: Se elminó un elemento de la lista y se devolvió su valor.
void *lista_borrar(lista_t *lista, lista_iter_t *iter)
{
/* Retornamos NULL si esta al final de la lista */
if (lista_iter_al_final(iter) || lista_esta_vacia(lista))
return NULL;
/* Retornamos lista_borrar_primero si el iterador está al comienzo
* de la lista */
if (!iter->anterior){
iter->actual = lista->primero->prox;
return lista_borrar_primero(lista);
}
/* Creamos variables auxiliares para guardar su dato y liberarla */
nodo_t* nodo_aux = iter->actual;
void* dato_aux = nodo_aux->dato;
/* Ubicamos el iterador en su nueva posicion actual */
iter->actual = iter->actual->prox;
iter->anterior->prox = iter->actual;
if (!iter->actual)
lista->ultimo = iter->anterior;
lista->cantidad--;
free(nodo_aux);
return dato_aux;
}
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;
}
void *lista_borrar(lista_t *lista, lista_iter_t *iter) {
void* dato_borrado;
// Si la lista está vacía o recorrí toda la lista
if (lista_esta_vacia(lista) || lista_iter_al_final(iter)) return NULL;
// Si estoy en la primera posición del iterador
else if (!iter->anterior) {
dato_borrado = lista_borrar_primero(lista);
iter->actual = lista->inicio;
}
// Si estoy en cualquier otra posición del iterador
else {
nodo_t *nodo_a_borrar = iter->actual;
dato_borrado = nodo_a_borrar->valor;
// Si estoy al final de la lista
if (!iter->actual->siguiente) {
iter->anterior->siguiente = NULL;
iter->actual = NULL;
lista->fin = iter->anterior;
}
// Si estoy en cualquier otra posición
else {
iter->anterior->siguiente = nodo_a_borrar->siguiente;
iter->actual = nodo_a_borrar->siguiente;
}
free(nodo_a_borrar);
lista->largo--;
}
return dato_borrado;
}
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;
}
// Inserta en una lista en la posicion actual del iterador
// Pre: el iterador y la lista fueron creados
// Post: devuelve NULL si algun parametro no es correcto
bool lista_insertar(lista_t *lista, lista_iter_t *iter, void *dato)
{
if(!lista || !iter || !dato)
return false;
// Caso 1: Iter al principio de la lista
if(!iter->nodo_ant)
{
if(!lista_insertar_primero(lista, dato))
return false;
iter->nodo_act = lista->primero;
iter->nodo_ant = NULL;
return true;
}
nodo_t* nodo = malloc(sizeof(nodo_t));
if(nodo == NULL) return false;
nodo->dato = dato;
// Caso 2: Iter al final
if(lista_iter_al_final(iter))
{
nodo->siguiente = NULL;
lista->ultimo = nodo;
}
else // Caso 3: Iter entre dos nodos
nodo->siguiente = iter->nodo_act;
iter->nodo_ant->siguiente = nodo;
iter->nodo_act = nodo;
lista->largo++;
return true;
}
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;
}
// Avanza el iterador al siguiente nodo en la lista
// Pre: el iterador fue creado
bool lista_iter_avanzar(lista_iter_t *iter)
{
if(!iter || lista_iter_al_final(iter))
return false;
iter->nodo_ant = iter->nodo_act;
iter->nodo_act = iter->nodo_act->siguiente;
return true;
}
/*
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;
}
bool hash_pertenece(const hash_t *hash, const char *clave){
unsigned long indice = fh(clave, hash->largo);
if (!hash->tabla[indice]) return false;
lista_iter_t* iter_l = busqueda(hash->tabla[indice], clave);
if (lista_iter_al_final(iter_l)) {
lista_iter_destruir(iter_l);
return false;
}
lista_iter_destruir(iter_l);
return true;
}
/* Obtiene el valor de un elemento del hash, si la clave no se encuentra
* devuelve NULL.
* Pre: La estructura hash fue inicializada
*/
void *hash_obtener(const 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_ver_actual(iter_l);
void* dato_salida = aux->dato;
lista_iter_destruir(iter_l);
return dato_salida;
}
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;
}
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);
}
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);
}
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;
}
void *lista_iter_borrar(lista_iter_t *iter){
if (lista_iter_al_final(iter)) return NULL ;
void* dato_salida = iter->actual->dato;
if (iter->actual == iter->lista->primero) {
iter->actual = iter->lista->primero->siguiente;
return lista_borrar_primero(iter->lista);
}
if (!iter->actual->siguiente) iter->lista->ultimo = iter->anterior;
iter->anterior->siguiente = iter->actual->siguiente;
free(iter->actual);
iter->actual = iter->anterior->siguiente;
iter->lista->largo-- ;
return dato_salida;
}
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);
}
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;
}
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 lista_iter_insertar(lista_iter_t *iter, void *dato){
bool res;
if (iter->actual == iter->lista->primero){
res = lista_insertar_primero(iter->lista, dato);
iter->actual = iter->lista->primero ;
return res;
}
if(lista_iter_al_final(iter)){
res = lista_insertar_ultimo(iter->lista, dato);
iter->actual = iter->lista->ultimo;
return res;
}
nodo_t* nodo = nodo_crear(dato);
if (!nodo) return false;
nodo->siguiente = iter->actual;
iter->actual = nodo;
iter->anterior->siguiente = nodo;
iter->lista->largo++ ;
return true;
}
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);
}
// Elimina el elemento de la lista sobre el cual se encuentra posicionado
// el iterador.
// PRE: 'lista' es una lista existente; 'iter' es un iterador existente
// y perteneciente a 'lista'; 'dato' es un puntero a la variable que
// recibirá el dato.
// POST: 'dato' contiene el dato de la posición que se eliminó. El itera
// dor avanzó hacia el siguiente elemento de la lista. En caso de ser
// exitosa la acción se devuelve true o false en caso contrario.
bool lista_borrar(lista_t *lista, lista_iter_t *iter, lista_dato_t *dato) {
// Verificamos si el iterador se encuentra al final de la lista
if(lista_iter_al_final(iter)) return false;
// Enviamos el dato a la variable de salida 'dato'
nodo_lista_t* nodo_act = iter->act;
*dato = nodo_act->dato;
// Movemos el iterador al siguiente elemento
iter->act = nodo_act->sig;
// Desvinculamos el nodo y lo liberamos
if(nodo_act == lista->primero) lista->primero = nodo_act->sig;
if(nodo_act == lista->ultimo) lista->ultimo = iter->ant;
if(iter->ant) iter->ant->sig = iter->act;
lista->largo--;
free(nodo_act);
return true;
}
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 almacenar(hash_t* hash, lista_t** tabla, daton_t* paquete, unsigned long largo){
bool resu;
unsigned long indice = fh(paquete->clave, largo );
if (!tabla[indice]){
tabla[indice] = lista_crear();
}
lista_iter_t* iter_l = busqueda(tabla[indice], paquete->clave);
if (lista_iter_al_final(iter_l)) { //no lo encontro
resu = lista_insertar_primero(tabla[indice], paquete);
hash->tam++;
lista_iter_destruir(iter_l);
return resu;
}
daton_t* aux = lista_iter_borrar(iter_l);
free(aux->clave);
if (hash->destruir_dato) hash->destruir_dato(aux->dato);
free(aux);
resu = lista_insertar_ultimo(tabla[indice], paquete);
lista_iter_destruir(iter_l);
return resu;
}
