/* 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* 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 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 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; }
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; }
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; }
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; }
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; }
// 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; }
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; }
bool printear(const char* clave, void* lista, void* extra){ printf("Clave: %s\n Datos en lista: ", clave); lista_iter_t* iter_lista = lista_iter_crear(lista); int i =0; while (i <lista_largo(lista)){ printf("%s ", (char*)lista_iter_ver_actual(iter_lista)); i++; } puts("\n"); lista_iter_destruir(iter_lista); return true; }
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; }
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 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; }
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; }
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 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 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 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; }
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); }
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); } }
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; }
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; }