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;
}
/* Cerrar ciclo de votacion y procesar resultados */
bool comando_votar_fin(maquina_votacion_t* maquina) {
#ifdef DEBUG
printf("Comando votar fin ejecutado \n");
#endif
if(maquina->estado < ABIERTA)
return error_manager(MESA_CERRADA);
if(maquina->estado < VOTACION)
return error_manager(OTRO);
if(maquina->votando_cargo < FIN)
return error_manager(FALTA_VOTAR);
while(!pila_esta_vacia(maquina->ciclo))
{
voto_t* voto = pila_desapilar(maquina->ciclo);
lista_iterar(maquina->listas, votar_partido, voto);
destruir_voto(voto);
}
// Reset de variables.
#ifdef DEBUG
if(pila_esta_vacia(maquina->ciclo)) printf("Pila vacia\n");
#endif
pila_destruir(maquina->ciclo, free);
maquina->ciclo = NULL;
maquina->estado = ABIERTA;
return true;
}
bool abb_iter_in_avanzar(abb_iter_t *iter) {
if(!iter || !iter->pila || pila_esta_vacia(iter->pila)) return false;
pila_desapilar(iter->pila);
return true;
}
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);
}
}
void abb_iter_in_destruir(abb_iter_t* iter){
while(!pila_esta_vacia(iter->pila)){
pila_desapilar(iter->pila);
}
pila_destruir(iter->pila);
free(iter);
}
// Destruye la pila.
// Pre: la pila fue creada.
// Post: se eliminaron todos los elementos de la pila.
void pila_destruir(pila_t *pila){
bool puedodestruir;
puedodestruir=pila_esta_vacia(pila);
if (puedodestruir){
free(pila->datos);
free(pila);
pila=NULL;
}else{
printf("no pude destruir la pila\n");
}
}
void pila_destruir(pila_t *pila , void destruir_dato(void *))
{
if (pila->datos != NULL) {
while (!pila_esta_vacia(pila)){
void* desapilado;
desapilado = pila_desapilar(pila);
if (destruir_dato)
destruir_dato(desapilado);
}
}
free(pila->datos);
free(pila);
}
bool abb_iter_in_al_final(const abb_iter_t *iter) {
if(!iter || !iter->pila) return true;
return pila_esta_vacia(iter->pila);
}
const char *abb_iter_in_ver_actual(const abb_iter_t *iter) {
if(!iter || !iter->pila || pila_esta_vacia(iter->pila)) return NULL;
abb_nodo_t* nodo = pila_ver_tope(iter->pila);
return nodo->clave;
}
bool abb_iter_in_al_final(const abb_iter_t *iter){
return pila_esta_vacia(iter->pila);
}
// Obtiene el valor del tope de la pila. Si la pila tiene elementos,
// se devuelve el valor del tope. Si está vacía devuelve NULL.
// Pre: la pila fue creada.
// Post: se devolvió el valor del tope de la pila, cuando la pila no está
// vacía, NULL en caso contrario.
void* pila_ver_tope(const pila_t *pila){
if (pila_esta_vacia(pila)) return NULL;
return pila->datos[pila->cantidad-1];
}
// Destruye la pila.
// Pre: la pila fue creada.
// Post: se eliminaron todos los elementos de la pila.
void pila_destruir(pila_t *pila){
while(!pila_esta_vacia(pila)) pila_desapilar(pila);
free(pila->datos);
free(pila);
pila=NULL;
}
