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 posfijo(char *colaE,pila_tipo_dato *pilaOP, char *numactual,int fin_linea ){
char oper='\0'; //auxiliar
int Boolinsert=0;
char sep='#';
if (esOperador(numactual)==0){ //quiere decir que es operando o numero
if (fin_linea==1){ //simbolo terminal
while(pilaOP->cant_element!=0){
char quitar;
pila_desapilar(pilaOP,&quitar);
strcat(colaE,&quitar);
}
}
else{
strcat(colaE,numactual);
strcat(colaE,&sep);
}
}
if(esOperador(numactual)==1)
{
//3.1) Si la pila esta vacía o el operador tiene mayor prioridad
//que el que está en la cima de la pila (o bien es la máxima prioridad),
//se mete en la pila.
if (pilaOP->cant_element>0){
pila_getfrente(pilaOP,&oper);
if (precedencia(numactual)>precedencia(&oper)){
pila_apilar(pilaOP,numactual);
Boolinsert=1;
}
}
if (pilaOP->cant_element==0){
pila_apilar(pilaOP,numactual);
Boolinsert=1;
}
//3.2) Si la prioridad es menor o igual, el operador se saca de la pila,
//se mete en la expresión postfija y se vuelve a hacer la comparación con
//el nuevo elemento de la cima de la pila.
if(Boolinsert==0 && pilaOP->cant_element>0)
{
pila_getfrente(pilaOP,&oper);
while(precedencia(numactual)<=precedencia(&oper)&& pilaOP->cant_element>0 ){
char quitar;
pila_desapilar(pilaOP,&quitar);
strcat(colaE,&quitar);
pila_getfrente(pilaOP,&oper);
}
pila_apilar(pilaOP,numactual);
}
}
}
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);
}
/* 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 (abb_iter_in_al_final(iter)){
return false;
}
nodo_t* nodo = pila_desapilar(iter->pila);
auxiliar_creacion(iter,nodo->nodo_derecho);
return true;
}
void ejecutar(pila_tipo_dato *pilaPos, char *res ){
pila_tipo_dato auxresult;
pila_init(&auxresult);
int error=0;
char elemento[TAM_RES],result1[TAM_RES],result2[TAM_RES],resultOp[TAM_RES];
while(pilaPos->cant_element!=0)
{
//ceramos los vectores
init_array(result1,TAM_RES);
init_array(result2,TAM_RES);
init_array(elemento,TAM_RES);
init_array(resultOp,TAM_RES);
pila_desapilar(pilaPos,elemento);
//vemos si es operador
if (esOperador(elemento)==1)
{
if ((auxresult.cant_element)<2){
res[0]=elemento[0];
strcat(res,"Error!!");
pilaPos->cant_element=0;
error=1;
//ocurrio un error
}
pila_desapilar(&auxresult,result1);
pila_desapilar(&auxresult,result2);
operar(result1, result2,elemento[0],resultOp);
pila_apilar(&auxresult,resultOp);
if(error==0){pila_getfrente(&auxresult,res);}
}
else{
pila_apilar(&auxresult,elemento);
}
}
}
bool abb_iter_in_avanzar(abb_iter_t* iter){
if (abb_iter_in_al_final(iter)) return false;
if (!iter->actual->der)
iter->actual = pila_desapilar(iter->pila);
else{
iter->actual = iter->actual->der;
while (iter->actual->izq){
pila_apilar(iter->pila, iter->actual);
iter->actual = iter->actual->izq;
}
}
return true;
}
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);
}
/* Retroceder la pila de votacion */
bool comando_votar_deshacer(maquina_votacion_t* maquina) {
#ifdef DEBUG
printf("Comando votar deshacer ejecutado \n");
#endif
if(maquina->estado < ABIERTA)
return error_manager(MESA_CERRADA);
if(maquina->estado < VOTACION)
return error_manager(OTRO);
if(maquina->votando_cargo == PRESIDENTE)
return error_manager(NO_DESHACER);
maquina->votando_cargo--;
destruir_voto(pila_desapilar(maquina->ciclo));
return true;
}
// Avanza iterador
bool abb_iter_in_avanzar(abb_iter_t *iter){
if(abb_iter_in_al_final(iter)) return false;
abb_nodo_t* desapilado = pila_desapilar(iter->pila);
if(desapilado->derecha) apilar_nodos(iter, desapilado->derecha);
return true;
}
// 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;
}
