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);
}
}
}
