pila_t* mostrar_enviados(pila_t* pila, vector_t *vectorzonas, vector_t* vectorprecios){
pedido_t* pedido;
pila_t * pila_nueva=pila_crear();
pila_t *pila_aux=pila_crear();
int recaudado=0;
printf ("\n");
printf ("Los pedidos que fueron enviados, en orden del mas reciente al mas antiguo, son: \n");
printf ("\n");
while (!pila_esta_vacia(pila)){
pedido=pila_desapilar(pila);
int* precio= (int*) vector_obtener(vectorprecios, pedido->zona-1);
recaudado+=( (*precio) *(pedido->cantidad));
pila_apilar(pila_aux, pedido);
printf("Pedido: %s Cantidad: %d Zona: %d \n",pedido->nombre,pedido->cantidad,pedido->zona);
}
printf("\n\n");
printf("Lo recaudado en total en los ultimos envios: $ %d\n", recaudado);
while (!pila_esta_vacia(pila_aux)){
pila_apilar(pila_nueva, pila_desapilar(pila_aux));
}
pila_destruir(pila_aux);
pila_t *piladestruir=pila;
if (piladestruir)
pila_destruir(piladestruir);
return pila_nueva;
}
void pruebas_cola_de_pilas() {
printf("\nINICIO DE PRUEBAS CON COLA DE PILAS\n");
/* Declaro las variables a utilizar*/
cola_t* cola = cola_crear();
pila_t* pila = pila_crear();
pila_t* pila2 = pila_crear();
int a = 1, b = 2, c = 3, d = 4, e = 5;
int* p_a = &a;
int* p_b = &b;
int* p_c = &c;
int* p_d = &d;
int* p_e = &e;
/* Inicio de pruebas */
// Apilo todos los elementos
pila_apilar(pila, p_a);
pila_apilar(pila, p_b);
pila_apilar(pila, p_c);
pila_apilar(pila2, p_d);
pila_apilar(pila2, p_e);
// Encolo las pilas
print_test("Prueba encolar pila 1", cola_encolar(cola, pila));
print_test("Prueba encolar pila 2", cola_encolar(cola, pila2));
/* Destruyo la cola */
cola_destruir(cola, pila_destruir_wrapper);
print_test("La cola fue destruida", true);
}
// Crea iterador
abb_iter_t *abb_iter_in_crear(const abb_t *abb){
abb_iter_t* iter = malloc(sizeof(abb_iter_t));
if (!iter) return NULL;
iter->abb = abb;
iter->pila = pila_crear();
if (abb->cantidad_nodos == 0) return iter;
apilar_nodos(iter, abb->raiz);
return iter;
}
/*
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;
}
abb_iter_t *abb_iter_in_crear(const abb_t *arbol){
// Si el arbol no existe
if (!arbol) return NULL;
abb_iter_t* iter = malloc(sizeof(abb_iter_t));
iter->pila = pila_crear();
abb_nodo_t* nodo = arbol->raiz;
if (arbol->raiz){
while (nodo->izq){
pila_apilar(iter->pila, nodo);
nodo = nodo->izq;
}
}
iter->actual = nodo;
return iter;
}
abb_iter_t *abb_iter_in_crear(const abb_t *arbol){
abb_iter_t* iter = malloc(sizeof(abb_iter_t));
if (iter == NULL){
return NULL;
}
iter->pila = pila_crear();
if (iter->pila == NULL){
free(iter);
return NULL;
}
iter->arbol = arbol;
auxiliar_creacion(iter,arbol->raiz);
return iter;
}
abb_iter_t *abb_iter_in_crear(const abb_t *arbol) {
if(!arbol) return NULL;
abb_iter_t* iter = malloc(sizeof(abb_iter_t));
if(!iter) return NULL;
iter->pila = NULL;
if(!arbol->raiz) return iter;
pila_t* pila = pila_crear();
if(!pila)
{
free(iter);
return NULL;
}
apilar_de_mayor_a_menor(pila, arbol->raiz);
iter->pila = pila;
return iter;
}
/* Pruebas */
void prueba_tipos() {
// Declaro de variables
vector_t *vector;
lista_t* lista;
pedido_t* pedido1;
pedido_t* pedido2;
pedido_t* pedido3;
pedido_t* pedido4;
pedido_t* pedido5;
pila_t* pila;
// las inicializo
vector = vector_crear();
pila=pila_crear();
char a[20]="agustin";
char b[20]="bernardo";
char c[20]="carlos";
char d[20]="damian";
char e[20]="esteban";
printf("---------------------------PRUEBAS---------------------------\n");
//Creo un vector
vector=vector_crear(vector);
print_test("Creo un vector", vector!=NULL );
//Creo 5 pedidos
pedido1=pedido_crear(a,1,2);
pedido2=pedido_crear(b,2,3);
pedido3=pedido_crear(c,3,2);
pedido4=pedido_crear(d,4,3);
pedido5=pedido_crear(e,5,2);
//Agrego los 4 primeros pedidos
print_test("Agrego pedido 1", vector_agregar_pedido(vector,pedido1) );
print_test("Agrego pedido 2", vector_agregar_pedido(vector,pedido2) );
print_test("Agrego pedido 3", vector_agregar_pedido(vector,pedido3) );
print_test("Agrego pedido 4", vector_agregar_pedido(vector,pedido4) );
printf("asd");
mostrar_registrados (vector);
/*
//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);
*/
}
