int main(){
no *inicio, *fim, *novo;
//Inclusao na lista do primeiro elemento
inicio = (no*) malloc(sizeof(no));
inicio->ant = NULL;
inicio->prox = NULL;
printf("Entre com o valor do primeiro elemento: ");
scanf("%d",&inicio->valor);
fim = novo = inicio;
while(novo->valor != -1){
novo = (no*) malloc(sizeof(no));
fim->prox = novo;
novo->ant = fim;
novo->prox = NULL;
fim = novo;
printf("Entre com o novo valor: ");
scanf("%d", &novo->valor);
}
//Consulta Lista
consultar(inicio);
remover(3, &inicio);
remover(1, &inicio);
consultar(inicio);
system("pause>null");
}
int consultar(arvore *aux,int numero,int achou){
if(aux!=NULL && achou==0){
if(aux->info==numero){
achou=1;
}
else if(numero < aux->info)
achou=consultar(aux->esq,numero,achou);
else
achou=consultar(aux->dir,numero,achou);
}
return achou;
}//método de consulta na árvore
void tela_produto::buscar_informacoes_his_saida(int id){
conexao_bd conexao;
QSqlDatabase bd;
int id_venda;
int quantidade;
double valor_venda_uni;
QString data;
std::vector< his_saidas * > aux_his;
//realiza conexão ao banco de dados
if (conexao.conetar_bd()){
//Retorna o banco de dados
bd = conexao.retorna_bd();
//Declara a variável que irá fazer a consulta
QSqlQuery consultar(bd);
//realiza a consulta
consultar.exec("SELECT l.`id_venda`, l.`quantidade`, l.`valor_venda_uni`, c.`data_venda` FROM lista_venda l,venda c WHERE l.id_venda=c.id_venda AND l.id_produto = "+QString::number(id)+";");
while(consultar.next()){
id_venda = consultar.value(0).toString().toInt();
quantidade = consultar.value(1).toString().toInt();
valor_venda_uni = consultar.value(2).toString().toDouble();
data = consultar.value(3).toString();
aux_his.push_back(new his_saidas(id_venda,quantidade,valor_venda_uni,data));
}
consultar.clear();
bd.close();
conexao.fechar_conexao();
}
mostrar_informacoes_his_saida(aux_his);
}
Clase operator[](const unsigned indice) const
{
Clase e;
e=consultar(indice);
return e;
}
//funcao para inserir em ordem crescente
void inserir_crescente(PLista *l, char *palavra)
{
PLista p, q, r;
p = ((Lista *)malloc(sizeof(Lista)));
p->palavra = malloc(strlen(palavra));
r = *l;
if(consultar(*l, palavra) == 1)
return;
if(r == NULL) //lista vazia
{
strcpy(p->palavra, palavra);
p->prox = NULL;
*l = p;
}
else
{
for(q = NULL, r = *l; (r); q = r, r = r->prox)
{
if((strcmp(palavra, r->palavra) > 0) && (r->prox == NULL)) //final da lista
{
strcpy(p->palavra, palavra);
//printf("ordenada %s\n", p->palavra);
p->prox = NULL;
r->prox = p;
return;
}
else
{
if((strcmp(palavra, r->palavra) < 0) && (q == NULL)) //inicio da lista
{
strcpy(p->palavra, palavra);
//printf("ordenada %s\n", p->palavra);
p->prox = r;
*l = p;
return;
}
else
{
if((strcmp(palavra, r->palavra) < 0) && (q)) //meio da lista
{
strcpy(p->palavra, palavra);
//printf("ordenada %s\n", p->palavra);
q->prox = p;
p->prox = r;
return;
}
}
}
}
}
}
bool ConjuntoRestaurantes::procesarVisitante(Visitante* visitante,
string nombreRestaurante) {
Restaurante *restaurante;
if (consultar(nombreRestaurante, restaurante)) {
if (visitanteCabeEnRestaurante(restaurante,
visitante->getComensales())) {
restaurante->reajustarComensales(-visitante->getComensales());
restaurante->hacerReserva(visitante);
return true;
}
}
return false;
}
/**
* Função principal
*
* @param argc
* @param argv
* @return
*/
int main(int argc, char *argv[]) {
char nome[20], operacao;
int idade, chave;
// Criação de lista de reinserção de elementos
node *LISTA = (node *) malloc(sizeof (node));
if (!LISTA) {
// fprintf(stderr, "memória insuficiente para criar lista \n");
} else {
inicia(LISTA);
}
// Criação de arquivo
if ((arquivo_hashing = fopen(ARQUIVO, "rb")) == NULL) {
// inicializa tabela hash
inicializar();
// cria arquivo para inserção da tabela hash
criar_arquivo();
}
// Verifica qual operação será executada
scanf("%c", &operacao);
do {
switch (operacao) {
case 'i':
scanf("%d", &chave);
// scanf lendo string com espaços em branco
scanf(" %[^\n]s", &nome);
// fflush(stdin);
scanf("%d", &idade);
inserir_chave(chave, nome, idade);
break;
case 'c':
// fprintf(stderr, "CONSULTAR\n");
scanf("%d", &chave);
consultar(chave, 0);
break;
case 'r':
// fprintf(stderr, "REMOVER\n");
scanf("%d", &chave);
int result = consultar(chave, 1);
if (result != -1) {
// fprintf(stderr, "indíce para remover: %d\n", result);
// remoção
remover(chave);
} else {
fprintf(stderr, "chave nao encontrada: %d", chave);
}
break;
case 'p':
// fprintf(stderr, "IMPRIMIR\n");
imprimir();
break;
case 'm':
// fprintf(stderr, "MEDIA DE ACESSOS\n");
media_acessos();
break;
case 'e':
return 0;
break; //exit
default:
break;
}
// limpa caracter do buffer antes do próximo loop
operacao = getchar();
} while (operacao != 'e');
// fclose(arquivo_hashing);
return 0;
}
/**
* Remove chave
* @param chave a ser removida
* @return
*/
void remover(int chave) {
int salto, index_aux, pai_index;
registro cleaner;
cleaner.apontador = -1;
cleaner.chave = -1;
cleaner.idade = -1;
cleaner.index_father = -1;
strcpy(cleaner.nome, "");
// inicializa lista
node *LISTA = (node *) malloc(sizeof (node));
if (!LISTA) {
// fprintf(stderr, "Sem memória disponivel!\n");
exit(1);
} else {
inicia(LISTA);
}
// arquivo binário
if ((arquivo_hashing = fopen(ARQUIVO, "rb+")) == NULL) {
// fprintf(stderr, "\nErro ao abrir arquivo!");
// printf("\nErro ao abrir arquivo!");
return;
}
// consultar índice a ser removido
int indice_remove = consultar(chave, 1);
// pode ser 0 até TAMANHO_ARQUIVO
if (indice_remove != -1) {
// lê o registro da posição a ser removido
fseek(arquivo_hashing, ((indice_remove + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
// verifica se corresponde a chave a ser removida
if (tabela_h.chave == chave) {
// salva índice para pai
pai_index = tabela_h.index_father;
// salva índice original
index_aux = indice_remove;
salto = h2(tabela_h.chave) * tabela_h.apontador + index_aux;
if (salto >= TAMANHO_ARQUIVO)
salto -= TAMANHO_ARQUIVO;
while (tabela_h.apontador != -1) {
fseek(arquivo_hashing, ((salto + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
insereFim(LISTA, tabela_h.chave, tabela_h.nome, tabela_h.idade);
index_aux = salto;
salto = h2(tabela_h.chave) * tabela_h.apontador + salto;
if (salto >= TAMANHO_ARQUIVO)
salto -= TAMANHO_ARQUIVO;
// limpa_registro(index_aux);
remove_registro(index_aux);
}
// remove índice
// limpa_registro(indice_remove);
remove_registro(indice_remove);
limpa_apontador_pai(pai_index);
reinsere_lista(LISTA);
}
}
}
/**
* Calcula média de acessos as chaves inseridas
*/
void media_acessos() {
float count_jumps = 0, qtd_chaves = 0;
// int count_jumps = 0, qtd_chaves = 0;
node *LISTA = (node *) malloc(sizeof (node));
if (!LISTA) {
exit(1);
} else {
inicia(LISTA);
}
if ((arquivo_hashing = fopen(ARQUIVO, "rb+")) == NULL) {
printf("\nErro ao abrir arquivo!");
return;
}
// int i;
// contar as chaves inseridas, salvar em uma lista e consultar até o final da lista
for (int i = 0; i < TAMANHO_ARQUIVO; i++) {
fseek(arquivo_hashing, ((i + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
// insere todas as chaves do arquivo na lista
if (tabela_h.chave != -1) {
insereFim(LISTA, tabela_h.chave, tabela_h.nome, tabela_h.idade);
qtd_chaves++;
}
}
if (vazia(LISTA)) {
// return;
}
node *tmp;
tmp = LISTA->prox;
//loop para contar os acessos
while (tmp != NULL) {
int indice_elemento = consultar(tmp->chave, 1);
int exit = 0;
// retirar depois
// printf("Chave: %d %s %d\n", tmp->chave, tmp->nome, tmp->idade);
// consultar todos os pais
while (exit == 0) {
fseek(arquivo_hashing, (indice_elemento + 1) * sizeof (struct REGISTRO), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
// fprintf(stderr, "jumps %f\n", count_jumps);
//saída do loop dos pais
if (tabela_h.index_father == -1) {
exit = 1;
// fprintf(stderr, "cj %d", count_jumps);
} else
indice_elemento = tabela_h.index_father;
// incrementa contador
count_jumps++;
}
// seleciona próximo da lista
tmp = tmp->prox;
}
if (qtd_chaves != 0) {
float media_acessos = count_jumps / qtd_chaves;
fprintf(stderr, "%.1f", media_acessos);
} else {
fprintf(stderr, "0.0");
}
// media = acessos / TAMANHO_ARQUIVO
fclose(arquivo_hashing);
}
/**
* Inserir registro na tabela hash
* @param nome
* @param idade
* @param chave
*/
void inserir_chave(int chave, char nome[20], int idade) {
int aux, indice = 0, salto, count_jumps = 0, go_to_index, index_aux, index_before_jump;
registro register_aux, register_jump;
indice = (int) h1(chave);
// se já não existir, insere
// if (!check_key(chave)) {
// não existe
if (consultar(chave, 1) == -1) {
register_aux.chave = chave;
strcpy(register_aux.nome, nome);
register_aux.index_father = -1;
register_aux.idade = idade;
register_aux.apontador = -1;
if ((arquivo_hashing = fopen(ARQUIVO, "rb+")) == NULL) {
printf("\nErro ao abrir arquivo!");
return;
}
rewind(arquivo_hashing);
fseek(arquivo_hashing, ((indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
// SEM colisão
if (tabela_h.chave == -1) {
fseek(arquivo_hashing, ((indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fwrite(®ister_aux, sizeof (struct REGISTRO), 1, arquivo_hashing);
}//
else {
// verificar se o que está na posição está no seu home adress
if (h1(tabela_h.chave) == indice) {
// está no homeAdress
if (tabela_h.apontador == -1) {
//NÃO tem sucessor. Salta para o sucessor
salto = h2(tabela_h.chave);
fseek(arquivo_hashing, ((salto + indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_jump, sizeof (struct REGISTRO), 1, arquivo_hashing);
index_aux = indice; //salva o índice atual
// CASO BASE
if (tabela_jump.chave == -1) {
// salva o novo registro
fseek(arquivo_hashing, ((salto + indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
// salva o indice do pai
register_aux.index_father = indice;
fwrite(®ister_aux, sizeof (struct REGISTRO), 1, arquivo_hashing);
// lê registro para salvar apontador para sucessor
fseek(arquivo_hashing, ((indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
count_jumps++;
tabela_h.apontador = count_jumps;
// salva apontador para sucessor
fseek(arquivo_hashing, ((indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fwrite(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
}
// posição ocupada - pular de h2 em h2 até achar uma disponível
if (tabela_jump.chave != -1) {
// index_aux++;
go_to_index = salto + index_aux;
// loop de busca de posição vazia
do {
fseek(arquivo_hashing, ((go_to_index + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_jump, sizeof (struct REGISTRO), 1, arquivo_hashing);
count_jumps++;
if (tabela_jump.chave != -1) {
// posição ocupada, procurar nova posição
// count_jumps++; //acerta apontador de saltos do home adress
// index_aux++;
index_aux = go_to_index + salto;
// go_to_index = salto + index_aux;
go_to_index = go_to_index + salto;
if (go_to_index >= TAMANHO_ARQUIVO)
go_to_index -= TAMANHO_ARQUIVO;
} else {
// salva o registro
fseek(arquivo_hashing, ((go_to_index + 1) * sizeof (struct REGISTRO)), SEEK_SET);
// salva o indice do pai
register_aux.index_father = indice;
fwrite(®ister_aux, sizeof (struct REGISTRO), 1, arquivo_hashing);
// acertando o apontador de sucessores
tabela_h.apontador = count_jumps; //acerta o apontador de saltos
fseek(arquivo_hashing, ((indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fwrite(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
}
} while (tabela_jump.chave != -1 && go_to_index != indice);
}
} else {
// TEM SUCESSORE(S). É uma cadeia
salto = (h2(tabela_h.chave) * tabela_h.apontador) + indice;
if (salto >= TAMANHO_ARQUIVO)
salto -= TAMANHO_ARQUIVO;
// guarda o indice atual para saber onde acertar o apontador
int new_index = salto;
fseek(arquivo_hashing, ((salto + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_jump, sizeof (struct REGISTRO), 1, arquivo_hashing);
count_jumps++;
while (tabela_jump.apontador != -1 && new_index != indice) {
salto = (h2(tabela_jump.chave) * tabela_jump.apontador) + new_index;
if (salto >= TAMANHO_ARQUIVO)
salto -= TAMANHO_ARQUIVO;
new_index = salto;
// salva o índice anterior ao salto
index_before_jump = new_index;
count_jumps++; //salva o número de saltos p/ register_aux
fseek(arquivo_hashing, ((new_index + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_jump, sizeof (struct REGISTRO), 1, arquivo_hashing);
}
// saiu pq achou o último da cadeia
if (new_index != indice) {
// salta pelo h2 até achar uma vaga ou terminar o arquivo
index_before_jump = new_index; // salva o índice a ser atualizado
salto = h2(tabela_jump.chave) + new_index;
int index_h2 = h2(tabela_jump.chave);
do {
fseek(arquivo_hashing, ((salto + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_jump, sizeof (struct REGISTRO), 1, arquivo_hashing);
if (tabela_jump.chave == -1) {
fseek(arquivo_hashing, ((salto + 1) * sizeof (struct REGISTRO)), SEEK_SET);
// salva o indice do pai
register_aux.index_father = index_before_jump;
// register_aux.index_father = indice;
fwrite(®ister_aux, sizeof (struct REGISTRO), 1, arquivo_hashing);
// acertar o apontador
fseek(arquivo_hashing, ((index_before_jump + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_jump, sizeof (struct REGISTRO), 1, arquivo_hashing);
tabela_jump.apontador = count_jumps;
// salva saltos para pai
fseek(arquivo_hashing, ((index_before_jump + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fwrite(&tabela_jump, sizeof (struct REGISTRO), 1, arquivo_hashing);
register_aux = tabela_jump;
fseek(arquivo_hashing, ((index_before_jump + 1) * sizeof (struct REGISTRO)), SEEK_SET);
// fwrite(&tabela_jump, sizeof (struct REGISTRO), 1, arquivo_hashing);
fwrite(®ister_aux, sizeof (struct REGISTRO), 1, arquivo_hashing);
// fclose(arquivo_hashing);
// previnir loop infinito
return;
} else {
// saltando de h2 em h2 até encontrar uma posição
new_index = salto;
salto += index_h2;
if (salto >= TAMANHO_ARQUIVO)
salto -= TAMANHO_ARQUIVO;
}
count_jumps++;
} while (tabela_jump.apontador != -1 || salto != indice);
}
}
}// NÃO ESTÁ NO HOME ADRESS
else {
// retira ele e os seus sucessores e os reinsere
int pai = tabela_h.index_father;
// inicializa lista
node *LISTA = (node *) malloc(sizeof (node));
if (!LISTA) {
// fprintf(stderr, "Sem memória disponivel!\n");
exit(1);
} else {
inicia(LISTA);
}
// NÃO TEM SUCESSORES - APENAS 1 A SER REINSERIDO
if (tabela_h.apontador == -1) {
int key = tabela_h.chave, age = tabela_h.idade;
char name[20];
strcpy(name, tabela_h.nome);
// salva na lista para reinserção
insereFim(LISTA, tabela_h.chave, tabela_h.nome, tabela_h.idade);
// insere no lugar deste o registro
fseek(arquivo_hashing, ((indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fwrite(®ister_aux, sizeof (struct REGISTRO), 1, arquivo_hashing);
fclose(arquivo_hashing);
// ACERTA APONTADOR DO PAI
limpa_apontador_pai(pai);
// reinsere o elemento
reinserir_chave(key, name, age);
// REINICIA A LISTA
inicia(LISTA);
return;
}// tem que reinserir todos até o final da cadeia
else {
int jump_to;
// LOOP até encontrar o final da cadeia
while (tabela_h.apontador != -1) {
// salva na lista para reinserção
insereFim(LISTA, tabela_h.chave, tabela_h.nome, tabela_h.idade);
// calcula salto para o próximo para inserir
jump_to = (h2(tabela_h.chave) * tabela_h.apontador) + indice;
if (jump_to >= TAMANHO_ARQUIVO)
jump_to -= TAMANHO_ARQUIVO;
// MARCAR POSIÇÃO COMO VÁLIDA
limpa_registro(indice);
// lê o próximo da cadeia
fseek(arquivo_hashing, ((jump_to + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
}
// insere o último da cadeia
insereFim(LISTA, tabela_h.chave, tabela_h.nome, tabela_h.idade);
// MARCAR POSIÇÃO COMO VÁLIDA
limpa_registro(jump_to);
// após inserir antigos na lista, insere novo
fseek(arquivo_hashing, ((indice + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fwrite(®ister_aux, sizeof (struct REGISTRO), 1, arquivo_hashing);
fclose(arquivo_hashing);
// ACERTA APONTADOR DO PAI
limpa_apontador_pai(pai);
//reinsere os da lista
reinsere_lista(LISTA);
// reinicia a lista
inicia(LISTA);
}
// exibe(LISTA);
}
}
fclose(arquivo_hashing);
} else {
fprintf(stderr, "Chave ja existente\n");
}
// imprimir()
}
template <class C, class I> I ABC<C, I>::consultar(C pclau) {
return consultar(pclau, &arrel);
}
void tela_restaurar_produto::buscar_produtos(void){
conexao_bd conexao;
QSqlDatabase bd;
custo_total = 0;
int aux_id;
QString aux_nome;
QString aux_fabricante;
QString aux_desc_utilizacao;
QString aux_cod_barras;
QString aux_tipo;
int aux_id_imagem;
int aux_soma_total = 0;
float aux_valor_venda;
float aux_valor_compra;
float aux_total_disponivel;
float custo_medio_cada_produto = 0;
lista_produtos.clear();
//realiza conexão ao banco de dados
if (conexao.conetar_bd()){
//Retorna o banco de dados
bd = conexao.retorna_bd();
//Declara a variável que irá fazer a consulta
QSqlQuery consultar(bd);
QSqlQuery consultar_his_balanco_estoque(bd);
//realiza a consulta
consultar.exec("SELECT id_produto,nome,fabricante,desc_utilizacao,cod_barras,tipo,id_imagem,valor_venda FROM produto WHERE removido=1 ORDER BY nome;");
while(consultar.next()){
aux_id = consultar.value(0).toInt();
aux_nome = consultar.value(1).toString();
aux_fabricante = consultar.value(2).toString();
aux_desc_utilizacao = consultar.value(3).toString();
aux_cod_barras = consultar.value(4).toString();
aux_tipo = consultar.value(5).toString();
aux_id_imagem = consultar.value(6).toInt();
aux_valor_venda = consultar.value(7).toInt();
//realiza a consulta
consultar_his_balanco_estoque.exec("SELECT valor_compra,total_disponivel FROM his_balanco_estoque WHERE id_produto = "+QString::number(aux_id)+";");
while(consultar_his_balanco_estoque.next()){
aux_valor_compra = consultar_his_balanco_estoque.value(0).toFloat();
aux_total_disponivel = consultar_his_balanco_estoque.value(1).toString().toInt();
custo_medio_cada_produto = custo_medio_cada_produto+(aux_valor_compra*aux_total_disponivel);
aux_soma_total = aux_soma_total+aux_total_disponivel;
}
custo_total = custo_total+custo_medio_cada_produto;
custo_medio_cada_produto = custo_medio_cada_produto/aux_soma_total;
lista_produtos.push_back(new produto(aux_id,aux_nome,aux_fabricante,aux_desc_utilizacao,aux_cod_barras,aux_tipo,aux_id_imagem,aux_valor_venda,custo_medio_cada_produto,aux_soma_total));
aux_soma_total=0;
custo_medio_cada_produto = 0;
}
consultar.clear();
tela_restaurar_produto::mostrar_lista_produtos();
bd.close();
conexao.fechar_conexao();
}
}
int main() {
short size;
int sair = 0;
int opcao;
opcao = 10;
if(!(file_especie = fopen("arquivos/especie.txt", "r+"))) {
file_especie = fopen("arquivos/especie.txt", "w+");
}
if(!(file_individuo = fopen("arquivos/individuo.txt", "r+"))) {
file_individuo = fopen("arquivos/individuo.txt", "w+");
}
if(!(file_capturado = fopen("arquivos/capturado.data", "rb+"))) {
file_capturado = fopen("arquivos/capturado.data", "wb+");
}
while(sair == 0){
desenhaMenu();
while((opcao!=0) &&(opcao!=1) &&(opcao!=2) &&(opcao!=3) &&(opcao!=4) &&(opcao!=5) &&(opcao!=6) &&(opcao!=7)){
opcao = pedeOpcao();
}
switch(opcao){
case 0:
sair = 1;
break;
case 1:
adicionar();
opcao = 10;
break;
case 2:
consultar();
opcao = 10;
break;
case 3:
remover();
opcao = 10;
break;
case 4:
consultaPre();
opcao = 10;
break;
case 5:
importar();
opcao = 10;
break;
case 6:
reescrever();
rewriteArvore(file_especie);
opcao = 10;
break;
case 7:
printTree();
printf("\n> Arvore B exportada para: output/pages.txt\n");
sleep(1);
opcao = 10;
break;
}
}
fclose(file_especie);
fclose(file_individuo);
fclose(file_capturado);
return 0;
}
bool fornecedor::salvar_dados_fornecedor(void){
conexao_bd conexao;
QSqlDatabase bd;
QString id_fornecedor;
//realiza conexão ao banco de dados
if (conexao.conetar_bd()){
//Retorna o banco de dados
bd = conexao.retorna_bd();
bd.transaction();
//Declara as variáves que irão inserir os dados no banco de dados.
QSqlQuery salvar_dados_fornecedor(bd);
QSqlQuery salvar_dados_telefone_fornecedor(bd);
QSqlQuery salvar_dados_email_fornecedor(bd);
//Declara a variável que irá fazer a consulta para determinar o id do fornecedor;
QSqlQuery consultar(bd);
//Insere os dados no cadastro dos fornecedors
salvar_dados_fornecedor.prepare("INSERT INTO fornecedor(cnpj,razao_social,nome,comentario,cep,rua,bairro,ponto_referencia,cidade,uf,numero,estado) VALUES(:cnpj, :razao_social, :nome, :comentario, :numero_cep, :nome_rua, :nome_bairro, :ponto_referencia, :nome_cidade,:sigla_estado, :numero_residencia, :nome_estado)");
salvar_dados_fornecedor.bindValue(":cnpj",cnpj);
salvar_dados_fornecedor.bindValue(":razao_social",razao_social);
salvar_dados_fornecedor.bindValue(":nome",nome);
salvar_dados_fornecedor.bindValue(":comentario",comentario);
salvar_dados_fornecedor.bindValue(":numero_cep",numero_cep);
salvar_dados_fornecedor.bindValue(":nome_rua",nome_rua);
salvar_dados_fornecedor.bindValue(":nome_bairro",nome_bairro);
salvar_dados_fornecedor.bindValue(":ponto_referencia",ponto_referencia);
salvar_dados_fornecedor.bindValue(":nome_cidade",nome_cidade);
salvar_dados_fornecedor.bindValue(":sigla_estado",sigla_estado);
salvar_dados_fornecedor.bindValue(":numero_residencia",numero_residencia);
salvar_dados_fornecedor.bindValue(":nome_estado",nome_estado);
salvar_dados_fornecedor.exec();
//realiza a consulta para determinar o id do fornecedor.
consultar.exec("SELECT id_fornecedor FROM fornecedor");
if(consultar.last()){
id_fornecedor = consultar.value(0).toString();
}
//Insere os números de telefone no cadastro dos fornecedors
for (int i=0;i<int(lista_telefone.size());i++){
salvar_dados_telefone_fornecedor.prepare("INSERT INTO tel_fornecedor(id_fornecedor,telefone,operadora) VALUES(:id_fornecedor, :telefone, :operadora)");
salvar_dados_telefone_fornecedor.bindValue(":id_fornecedor",id_fornecedor);
salvar_dados_telefone_fornecedor.bindValue(":telefone",QString::fromStdString(lista_telefone[i]));
salvar_dados_telefone_fornecedor.bindValue(":operadora",QString::fromStdString(lista_operadora[i]));
salvar_dados_telefone_fornecedor.exec();
}
//Insere os emails no cadastro dos fornecedors
for (int i=0;i<int(lista_email.size());i++){
salvar_dados_email_fornecedor.prepare("INSERT INTO email_fornecedor(id_fornecedor,e_mail) VALUES(:id_fornecedor, :email)");
salvar_dados_email_fornecedor.bindValue(":id_fornecedor",id_fornecedor);
salvar_dados_email_fornecedor.bindValue(":email",QString::fromStdString(lista_email[i]));
salvar_dados_email_fornecedor.exec();
}
//Verifica se os dados podem ser salvos, caso sim realiza o Commite, do contrário o Rollback.
if((salvar_dados_fornecedor.lastError().number()<=0)&&(salvar_dados_telefone_fornecedor.lastError().number()<=0)&&(salvar_dados_email_fornecedor.lastError().number()<=0)){
//Finaliza a inserçao dos dados.
bd.commit();
//Gera mensagem de que tudo ocorreu direito.
QPixmap icone_janela(":img/img/arquivo_50.png");
QMessageBox msg(0);
msg.setIconPixmap(icone_janela);
msg.setWindowIcon(logomarca);
msg.setWindowTitle("Cadastro");
msg.addButton("OK", QMessageBox::AcceptRole);
msg.setFont(QFont ("Calibri", 11,QFont::Normal, false));
msg.setText("\nCadastro efetuado com sucesso!!!!");
msg.exec();
//Fecha a conexão com o banco de dados
bd.close();
conexao.fechar_conexao();
return true;
}
else{
//Desfaz as alterações no banco de dados.
bd.rollback();
//Gera a mensagem de erro.
QPixmap icone_janela(":img/img/arquivo_erro_50.png");
QMessageBox msg(0);
msg.setIconPixmap(icone_janela);
msg.setWindowIcon(logomarca);
msg.setWindowTitle("Cadastro");
msg.addButton("OK", QMessageBox::AcceptRole);
msg.setFont(QFont ("Calibri", 11,QFont::Normal, false));
msg.setText("\nNão foi possível efetuar o cadastro do fornecedor!!!!");
msg.exec();
//Fecha a conexão com o banco de dados
bd.close();
conexao.fechar_conexao();
return false;
}
}
else{
return false;
}
}
int main()
{
clock_t Ticks[2];
FILE *texto; //Arquivo com texto para indexação.
FILE *consulta; //Arquivo que contém as palavras para consulta.
FILE *saida; //Arquivo para saida dos resultados
char palavra[25] = {' '} ;
char ch;
int i = 0, linha = 1;
int *ok = 0;
pNodoA *raiz = NULL;
pNodoA* a = raiz;
TipoPtNo *lista=NULL;
TNodoA *achou = NULL;
// Abre os arquivos para leitura e escrita
texto = fopen("in.txt","r");
consulta = fopen("find.txt","r");
saida = fopen("out.txt","w");
if((texto != NULL) && (consulta != NULL))
{
// Se deu tudo certo com os arquivos
printf("Arquivos ok..\n");
while((ch=fgetc(texto))!= EOF)
{
// Comparações dentro do arquivo, para reconhecer so' as palavras e nao pegar simbolos juntos
if(ch == ' ' || ch == '.' || ch == ',' || ch == ';' || ch == '!' || ch == '?' || ch == '"' || ch == '@' || ch == '#' || ch == '$' || ch == '%' || ch == '=' || ch == '&' || ch == '|')
{
i=0;
// Inserindo na AVL
raiz = InsereAVL(raiz, palavra, &ok,linha);
// Zera o array palavra
memset(palavra,(char)0,sizeof(char)*25);
}
else
{
// Se encontra quebra de linha, incrementa o contador de linhas
if(ch == '\n')
{
linha++;
}
// Deixando todas letras minusculas para fazer as comparacoes
ch = tolower(ch);
// Salvando o que está achando no texto no vetor de caracteres(palavra)
palavra[i] = ch;
i++;
}
}
Ticks[0] = clock(); // Iniciando o contador de tempo
// Vai fazendo comparacoes até chegar no final do arquivo aberto
while((ch=fgetc(consulta))!= EOF)
{
i=0;
while(ch != '\n')
{
ch = tolower(ch);
palavra[i] = ch;
// Comparacao direta, sem uso de estrutura auxiliar para fazer comparacoes, fazendo economia de tempo
ch=fgetc(consulta);
i++;
}
palavra[i] = '\0'; //String deve ser terminada com \0
// achou recebe o retorno da palavra consultada
achou = consultar(raiz,palavra);
if(achou)
{
achou->dir = NULL;
achou->esq = NULL;
imprimeAVL(achou,saida);
}
else
{
// Em caso de percorrer todo o arquivo a palavra procurada
fprintf(saida,"Consulta: %-10s Palavra não encontrada\n",palavra);
}
// Zera o vetor de caracteres (palavra)
memset(palavra,(char)0,sizeof(char)*25);
}
// Fecha o contador de tempo
Ticks[1] = clock();
double Tempo = (Ticks[1] - Ticks[0]) * 1000.0 / CLOCKS_PER_SEC;
// Exibe o tempo gasto com a consulta
fprintf(saida," \n Tempo gasto: %g ms.", Tempo);
// Fechamento dos arquivos utilizados ao longo da execução do programa
fclose(consulta);
fclose(texto);
fclose(saida);
// Desalocando a memória utilizada pela árvore
DestroiAvl(raiz);
}
else
{
// Em caso de nao conseguir ler os arquvios do disco
printf("Erro ao realizar a leitura dos arquivos...\n");
}
return(0);
}
void tela_listar_clientes::on_btn_buscar_clicked()
{
conexao_bd conexao;
QSqlDatabase bd;
funcoes_extras funcao;
std::vector< std::string > lista_id;
std::vector< std::string > lista_nomes;
std::vector< std::string > lista_cpfs;
std::vector< std::string > lista_rgs;
std::vector< std::string > lista_comentario;
std::vector< std::string > lista_cep;
std::vector< std::string > lista_rua;
std::vector< std::string > lista_bairro;
std::vector< std::string > lista_ponto_referencia;
std::vector< std::string > lista_cidade;
std::vector< std::string > lista_uf;
std::vector< std::string > lista_numero;
std::vector< std::string > lista_estado;
std::vector< std::string > aux_lista_email;
std::vector< std::string > aux_lista_telefone;
std::vector< std::string > aux_lista_operadora;
QString campos_consulta;
QString id_cliente;
QString nome_cliente;
std::string telefone;
int ta_string_telefone;
telefone = ui->le_telefone->text().toStdString();
id_cliente = ui->le_codigo->text();
nome_cliente = ui->le_nome->text();
lista_clientes.clear();
if (((id_cliente.toStdString()!="")&&(id_cliente.toStdString()!=" "))||((nome_cliente.toStdString()!="")&&(nome_cliente.toStdString()!=" "))||(telefone!="()-")){
campos_consulta = "c.id_cliente, c.nome, c.rg, c.cpf, c.comentario,c.cep, c.rua, c.bairro, c.ponto_referencia, c.cidade, c.uf, c.numero, c.estado";
if(telefone == "()-"){
telefone = "";
}
else{
ta_string_telefone = telefone.size();
if(int(ta_string_telefone) < 13){
if(ta_string_telefone <= 5){
telefone = telefone.substr(0,ta_string_telefone-1);
telefone = telefone.substr(0,ta_string_telefone-2);
}
else{
if ((ta_string_telefone > 5)&&(ta_string_telefone <= 10)){
if((funcao.determinar_posicao_caractere(telefone,"-")+1)==ta_string_telefone){
telefone = telefone.substr(0,ta_string_telefone-1);
}
}
}
}
}
//realiza conexão ao banco de dados
if (conexao.conetar_bd()){
//Retorna o banco de dados
bd = conexao.retorna_bd();
//Declara a variável que irá fazer a consulta
QSqlQuery consultar(bd);
//realiza a consulta
consultar.exec("SELECT DISTINCT "+campos_consulta+" FROM cliente c,tel_cliente tc WHERE c.id_cliente LIKE '%"+id_cliente+"%' AND c.nome LIKE '%"+nome_cliente+"%' AND tc.telefone LIKE '%"+QString::fromStdString(telefone)+"%' AND tc.id_cliente = c.id_cliente ORDER BY c.nome ASC;");
while(consultar.next()){
lista_id.push_back(consultar.value(0).toString().toStdString());
lista_nomes.push_back(consultar.value(1).toString().toStdString());
lista_rgs.push_back(consultar.value(2).toString().toStdString());
lista_cpfs.push_back(consultar.value(3).toString().toStdString());
lista_comentario.push_back(consultar.value(4).toString().toStdString());
lista_cep.push_back(consultar.value(5).toString().toStdString());
lista_rua.push_back(consultar.value(6).toString().toStdString());
lista_bairro.push_back(consultar.value(7).toString().toStdString());
lista_ponto_referencia.push_back(consultar.value(8).toString().toStdString());
lista_cidade.push_back(consultar.value(9).toString().toStdString());
lista_uf.push_back(consultar.value(10).toString().toStdString());
lista_numero.push_back(consultar.value(11).toString().toStdString());
lista_estado.push_back(consultar.value(12).toString().toStdString());
}
modelo = new QStandardItemModel(int(lista_id.size()),3,this);
modelo->clear();
modelo->setHorizontalHeaderItem(0, new QStandardItem(QString("Código:")));
modelo->setHorizontalHeaderItem(1, new QStandardItem(QString("Nome:")));
modelo->setHorizontalHeaderItem(2, new QStandardItem(QString("Telefone:")));
for (int i=0;i<int(lista_id.size());i++){
consultar.exec("SELECT telefone,operadora FROM tel_cliente WHERE id_cliente = "+QString::fromStdString(lista_id[i])+";");
while(consultar.next()){
aux_lista_telefone.push_back(consultar.value(0).toString().toStdString());
aux_lista_operadora.push_back(consultar.value(1).toString().toStdString());
}
consultar.exec("SELECT e_mail FROM email_cliente WHERE id_cliente = "+QString::fromStdString(lista_id[i])+";");
while(consultar.next()){
aux_lista_email.push_back(consultar.value(0).toString().toStdString());
}
lista_clientes.push_back(new cliente(QString::fromStdString(lista_id[i]).toInt(),QString::fromStdString(lista_nomes[i]),
QString::fromStdString(lista_rgs[i]),QString::fromStdString(lista_cpfs[i]),
QString::fromStdString(lista_comentario[i]),aux_lista_email,aux_lista_telefone,
aux_lista_operadora,QString::fromStdString(lista_uf[i]),QString::fromStdString(lista_estado[i]),
QString::fromStdString(lista_cidade[i]),QString::fromStdString(lista_bairro[i]),
QString::fromStdString(lista_rua[i]),QString::fromStdString(lista_cep[i]),
QString::fromStdString(lista_numero[i]).toInt(),QString::fromStdString(lista_ponto_referencia[i])));
modelo->setItem(i,0,new QStandardItem(QString::fromStdString(lista_id[i])));
modelo->setItem(i,1,new QStandardItem(QString::fromStdString(lista_nomes[i])));
modelo->setItem(i,2,new QStandardItem(QString::fromStdString(aux_lista_telefone[aux_lista_telefone.size()-1]+" "+aux_lista_operadora[aux_lista_operadora.size()-1])));
aux_lista_telefone.clear();
aux_lista_operadora.clear();
aux_lista_email.clear();
}
ui->tv_clientes->setSelectionMode(QAbstractItemView::SingleSelection);
ui->tv_clientes->setSelectionBehavior(QAbstractItemView::SelectRows);
ui->tv_clientes->setEditTriggers(QAbstractItemView::NoEditTriggers);
ui->tv_clientes->setModel(modelo);
ui->tv_clientes->resizeColumnToContents(0);
ui->tv_clientes->resizeColumnToContents(2);
bd.close();
conexao.fechar_conexao();
}
}
}
int main(void){
arvore *raiz=NULL;
int op,achou,num;
do{
printf("\nMENU");
printf("\n1 - Insere na Arvore");
printf("\n2 - Consultar um no da Arvore");
printf("\n3 - Consultar toda Arvore em pre-ordem");
printf("\n4 - Consultar toda Arvore em ordem");
printf("\n5 - Consultar toda Arvore em pos-ordem");
printf("\n6 - Excluir um no da Arvore");
printf("\n7 - Esvaziar toda Arvore");
printf("\n8 - Sair");
printf("\nOpcao: ");
scanf("%i",&op);
if(op==1){
printf("\nNumero a inserir na Arvore: ");
scanf("%i",&num);
raiz=insere(raiz,num);
printf("\nNumero inserido!");
}//opção insere
if(op==2){
if(raiz==NULL)
printf("\nArvore vazia!");
else{
printf("\nNumero a ser consultado: ");
scanf("%i",&num);
achou=0;
achou=consultar(raiz,num,achou);
if(achou==1)
printf("\nNumero existente na Arvore!");
else
printf("\nNumero nao existente na Arvore!");
}
}//opção busca numero
if(op==3){
if(raiz==NULL)
printf("\nArvore vazia!");
else{
printf("\nListando em pre-ordem\n");
preordem(raiz);
}
}//opçao listar preordem
if(op==4){
if(raiz==NULL)
printf("\nArvore vazia!");
else{
printf("\nListando em ordem\n");
emordem(raiz);
}
}//opçao listar em ordem
if(op==5){
if(raiz==NULL)
printf("\nArvore vazia!");
else{
printf("\nListando em pos-ordem\n");
posordem(raiz);
}
}//opçao listar pos ordem
if(op==6){
if(raiz==NULL)
printf("\nArvore vazia!");
else{
printf("\nInforme o numero a ser removido: ");
scanf("%i",&num);
achou=0;
achou=consultar(raiz,num,achou);
//verifica se o nó existe
if(achou==0)
printf("\nNumero nao existente na Arvore!");
else{
raiz=remover(raiz,num);
printf("\nNumero removido!");
}
}
}//opçao remoção
if(op==7){
if(raiz==NULL)
printf("\nArvore vazia!");
else{
raiz=desalocar(raiz);
printf("\nArvore desalocada!");
}
}//opçao desaloca
printf("\n************************************************************\n");
getc(stdin);
}while(op>0 && op<9 && op!=8);
return 0;
}
template <class C, class I> I ABC<C, I>::consultar(C pclau, Node **node) {
if(*node == NULL) throw "consultar: element no trobat";
if((*node)->clau > pclau) return consultar(pclau, &(*node)->fesq);
if((*node)->clau < pclau) return consultar(pclau, &(*node)->fdre);
return (*node)->info;
}
