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); } }
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; }
/* Pruebas de guardar y obtener algunos elementos*/ void pruebas_vector_algunos_elementos() { printf("INICIO DE PRUEBAS CON ALGUNOS ELEMENTOS\n"); /* Creo un vector de tamanio 5*/ vector_t* vec2 = vector_crear(5); print_test("crear vec2 con tamanio 5", vec2 != NULL); print_test("obtener tamanio es 5", vector_obtener_tamanio(vec2) == 5); /* Pruebo que guardar en un vector de tamanio 5 funciona para posiciones menores que 5 */ print_test("guardar 20 en vec2[0] es true", vector_guardar(vec2, 0, 20)); print_test("guardar 30 en vec2[1] es true", vector_guardar(vec2, 1, 30)); print_test("guardar 15 en vec2[0] es true", vector_guardar(vec2,0,15)); print_test("guardar 7 en vec2[4] es true", vector_guardar(vec2, 4, 7)); /* Pruebo que guardar en un vector de tamanio 5 no funciona para posiciones mayores o iguales que 5 */ print_test("guardar 35 en vec2[5] es false", !vector_guardar(vec2, 5, 35)); print_test("guardar 40 en vec2[6] es false", !vector_guardar(vec2, 6, 40)); /* Pruebo obtener los valores de un vector previamente guardados */ int valor; print_test("se puede obtener vec2[0]", vector_obtener(vec2, 0, &valor)); print_test("obtener vec2[0] es 15", valor == 15); print_test("se puede obtener vec2[1]", vector_obtener(vec2, 1, &valor)); print_test("obtener vec2[1] es 30", valor == 30); print_test("no se puede obtener vec2[5]", !vector_obtener(vec2, 5, &valor)); print_test("valor no fue modificado", valor == 30); /* Destruyo el vector*/ vector_destruir(vec2); print_test("el vector fue destruido", true); }
/* Pruebas para un vector de tamanio 0*/ void pruebas_vector_nulo() { printf("INICIO DE PRUEBAS CON VECTOR DE TAMANIO 0\n"); /* Declaro las variables a utilizar*/ vector_t* vec = vector_crear(0); /* Inicio de pruebas */ print_test("crear vector con tamanio 0", vec != NULL); print_test("obtener tamanio vector es 0", vector_obtener_tamanio(vec) == 0); /* Pruebo que guardar en un vector de tamanio 0 devuelve false siempre (no se puede guardar) */ print_test("guardar en vec[0] es false", !vector_guardar(vec, 0, 5)); print_test("guardar en vec[1] es false", !vector_guardar(vec, 1, 10)); print_test("guardar en vec[15] es false", !vector_guardar(vec, 15, 0)); /* Pruebo que obtener valores de un vector de tamaño 0 devuelve false */ int valor; print_test("obtener vec[0] es false", !vector_obtener(vec, 0, &valor)); print_test("obtener vec[1] es false", !vector_obtener(vec, 1, &valor)); /* Destruyo el vector*/ vector_destruir(vec); print_test("el vector fue destruido", true); }
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; }
/* Pruebas al redimensionar un vector (agrandar y achicar) */ void pruebas_vector_redimension() { printf("INICIO DE PRUEBAS DE REDIMENSION\n"); /* Creo un vector de tamanio 3*/ vector_t* vec3 = vector_crear(3); /* Pruebo guardar elementos en el vector de tamanio 3*/ print_test("guardar 5 en vec3[0] es true", vector_guardar(vec3, 0, 5)); print_test("guardar 10 en vec3[1] es true", vector_guardar(vec3, 1, 10)); /* Pruebo redimensionar (agrandar) el vector */ print_test("redimensionar a tamanio 10", vector_redimensionar(vec3, 10)); print_test("El nuevo tamanio del vector es 10", vector_obtener_tamanio(vec3) == 10); /* Pruebo que los elementos guardados antes son correctos*/ int valor; print_test("puedo obtener el valor de vec3[0] luego de redimensionar (agrandar)", vector_obtener(vec3, 0, &valor)); print_test("el valor contenido en vec3[0] es 5", valor == 5); print_test("puedo obtener el valor de vec3[1] luego de redimensionar (agrandar)", vector_obtener(vec3, 1, &valor)); print_test("el valor contenido en vec3[1] es 10", valor == 10); /* Pruebo que se pueda agregar ahora en la posicion 5 */ print_test("guardar 50 en vec3[5] es true, luego de redimensionar", vector_guardar(vec3, 5, 50)); print_test("puedo obtener el valor de vec3[5], luego de redimensionar", vector_obtener(vec3, 5, &valor)); print_test("el valor contenido en vec3[5] es 50", valor == 50); /* Pruebo redimensionar (achicar) el vector */ print_test("redimensionar a tamanio 2", vector_redimensionar(vec3, 2)); print_test("El nuevo tamanio del vector es 2", vector_obtener_tamanio(vec3) == 2); /* Pruebo que los elementos de las primeras posiciones sigan estando*/ print_test("puedo obtener el valor de vec3[0] luego de redimensionar (achicar)", vector_obtener(vec3, 0, &valor)); print_test("el valor contenido en vec3[0] es 5", valor == 5); print_test("puedo obtener el valor de vec3[1] luego de redimensionar (achicar)", vector_obtener(vec3, 1, &valor)); print_test("el valor contenido en vec3[1] es 10", valor == 10); /* Pruebo que no puedo leer lo que esta en la posicion 5*/ print_test("no puedo obtener el valor de vec3[5] luego de redimensionar (achicar)", !vector_obtener(vec3, 5, &valor)); /* Puebo que no puedo guardar en la posicion 5*/ print_test("no puedo guardar 0 en vec3[5] luego de redimensionar (achicar)", !vector_guardar(vec3, 5, 0)); /* Destruyo el vector*/ vector_destruir(vec3); print_test("el vector fue destruido", true); }
void definir_precios(vector_t *vectorprecios){ int i; int *precio; for (i=0; i<5; i++){ printf("Ingrese el precio para la zona %d\n", i+1); precio= (int*) vector_obtener(vectorprecios,i); scanf("%d", &(*precio) ); } }
bool agregar_pedido(vector_t *vectorzonas, pedido_t* pedido) { if (pedido==NULL) return false; int i; i=pedido->zona; lista_t* listaaux=vector_obtener(vectorzonas, i-1); lista_insertar_ultimo(listaaux,pedido); printf("Se agrego el pedido %s en la zona %d \n",pedido->nombre,i); return true; }
/* Pruebas del vector al trabajar con un volumen grande de elementos */ void pruebas_vector_volumen() { printf("INICIO DE PRUEBAS DE VOLUMEN\n"); /* Defino el tamanio del vector*/ size_t tam = 10000; /* Creo el vector con ese tamanio*/ vector_t* vec_vol = vector_crear(tam); /* Prueba de correcta creacion del vector */ print_test("crear vec_vol con tamanio grande", vec_vol != NULL); print_test("obtener tamanio vec_vol es el indicado", vector_obtener_tamanio(vec_vol) == tam); /* Pruebo guardar en todas las posiciones */ size_t i; bool ok = true; for (i = 0; i < tam; i++) { // Si algun elemento no se pudo guardar correctamente, ok sera false ok &= vector_guardar(vec_vol, i, i); } print_test("se pudieron guardar todos los elementos", ok); print_test("no se puede guardar un elemento en vec_vol[tam]", !vector_guardar(vec_vol, tam, 10)); /* Pruebo que lo guardado sea correcto */ ok = true; int valor; for (i = 0; i < tam; i++) { ok &= vector_obtener(vec_vol, i, &valor); ok &= (valor == i); } print_test("se pudieron obtener todos los elementos", ok); print_test("no se puede obtener el valor de vec_vol[tam]", !vector_obtener(vec_vol, tam, &valor)); /* Destruyo el vector*/ vector_destruir(vec_vol); print_test("el vector fue destruido", true); }
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; }
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); } }
void registrar_pedido(vector_t* vectorzonas){ bool resultado; pedido_t *pedido=malloc(sizeof(pedido_t)); lista_t *listaaux; if (pedido==NULL){ printf("Ocurrio un error, pruebe de vuelta\n"); return; }; int cantidad=vector_obtener_cantidad(vectorzonas); printf("Ingrese la zona del cliente:\n"); scanf("%d", &(pedido->zona)); while ((pedido->zona)<1 || (pedido->zona)> cantidad){ printf ("la zona tiene que se del 1 al %d. Ingresela de vuelta\n",cantidad); scanf("%d", &(pedido->zona)); } printf("A continuacion ingrese el nombre del cliente:\n"); scanf("%s", pedido->nombre); printf("Ahora ingrese la cantidad de pizzas pedidas:\n"); scanf("%d", &(pedido->cantidad)); while ((pedido->cantidad)<1 || (pedido->cantidad)> 5){ printf ("la cantidad tiene que se del 1 al 5. Ingresela de vuelta\n"); scanf("%d", &(pedido->cantidad)); } pedido->preparado=false; listaaux = (lista_t*) vector_obtener(vectorzonas,pedido->zona-1); resultado=lista_insertar_ultimo(listaaux, pedido); if (resultado==false){ printf("Error al ingresar pedido\n"); }else { printf("Se agrego el pedido correctamente\n"); } }
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; }
void enviar(vector_t * vectorzonas, pila_t* pila){ lista_iter_t *iter,*iterborrar; bool primeroencontrado; int i,canti,cantf,total; pedido_t *pedidoaux,*primerpedido,*pedidof; lista_t* listaaux; for (i=0;i<vector_obtener_cantidad(vectorzonas);i++){ primeroencontrado=true; while(primeroencontrado) { primeroencontrado=false; canti=0; cantf=0; total=0; pedidof=NULL; listaaux= (lista_t*) vector_obtener(vectorzonas, i); iter=lista_iter_crear(listaaux); while ( !lista_iter_al_final(iter) ) { pedidoaux=(pedido_t*) (lista_iter_ver_actual(iter)); if (pedidoaux !=NULL) { if ( (!primeroencontrado) && (pedidoaux->preparado)) { primerpedido=pedidoaux; //primer pedido es el primer pedido preparado de esa zona canti=pedidoaux->cantidad; primeroencontrado=true; } else if (pedidoaux->preparado) { cantf=pedidoaux->cantidad; if ( ((canti + cantf)<=5) && ((canti+cantf)>total) ) { pedidof=pedidoaux; total=canti+cantf; } } } lista_iter_avanzar(iter); } lista_iter_destruir(iter); if ( (primeroencontrado) && (pedidof!=NULL)) printf("Se envio el pedido %s junto con el pedido %s \n",primerpedido->nombre,pedidof->nombre); else if (primeroencontrado){ printf("Se envio el pedido %s \n",primerpedido->nombre); } iterborrar=lista_iter_crear(listaaux); while (!lista_iter_al_final(iterborrar)) { if ( primerpedido==lista_iter_ver_actual(iterborrar) ) { pila_apilar(pila,primerpedido); lista_borrar(listaaux,iterborrar); } else{ if (pedidof==lista_iter_ver_actual(iterborrar)) { pila_apilar(pila,pedidof); lista_borrar(listaaux,iterborrar); } else lista_iter_avanzar(iterborrar); } } lista_iter_destruir(iterborrar); } } }