Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on Jul 11th, 2012  |  syntax: None  |  size: 7.53 KB  |  hits: 40  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. ~#include "genericLL.h"
  2. #include "genericHash.h"
  3. #include "user.h"
  4. #include "lugar.h"
  5.  
  6. #define MAX_LINHA_LUGAR 150
  7. #define MAX_LINHA_USER 350
  8.  
  9. void limpabuff() {
  10.         int flush;
  11.         while ((flush=getchar()) != EOF && flush != '\n');
  12. }
  13.  
  14. // Dada a posição no inicio da linha do ficheiro, insere um utilizador na hash de utilizadores
  15. // 9000011000,Jon Yang,9000011000@foursquareUM.com,3761 N. 14th St
  16. int carrega_users(FILE *fp, Hash *hash){
  17.         /* Utilizar fora desta função
  18.        
  19.         if ((fp = fopen("utilizadoresFSQ_UM.csv", "r")) == NULL)
  20.                 fprintf(stderr, "Cannot open %s\n", "utilizadoresFSQ_UM.csv");
  21.         */
  22.        
  23.         Lista *aux;
  24.         User *user = (User*) malloc(sizeof(User));
  25.         char linha[MAX_LINHA_USER];
  26.        
  27.         user = NULL;
  28.        
  29.         while(!feof(fp)){
  30.                
  31.                 fgets(linha, MAX_LINHA_USER, fp);
  32.                 user = cria_user(linha);  
  33.              
  34.                 if((*hash)[fhash(user -> nickname)] == NULL ){
  35.                
  36.                         aux = init(sizeof(user), &comparatorUsers);
  37.                         init_hash_list(hash, aux, user -> nickname);
  38.                         insere_hash(hash, aux, user, user -> nickname);
  39.                 }else{
  40.                
  41.                         insere_hash(hash, aux, user, user -> nickname);
  42.                 }
  43.         }
  44.        
  45.         return 1;
  46. }
  47.  
  48. // Dada a posição no inicio da posição no inicio da linha do ficheiro, insere um lugar na hash de lugares
  49. // 1:Praia de Porto Chão:39.4:-9.25:(acrescentar pontos)
  50. int carrega_lugares(FILE *fp, Hash *hash){
  51.  
  52.         /* Utilizar fora desta função
  53.        
  54.         if ((fp = fopen("coordenadas.txt", "r")) == NULL)
  55.                 fprintf(stderr, "Cannot open %s\n", "coordenadas.txt");
  56.         */
  57.        
  58.         Lista *aux;
  59.         Lugar *lugar = (Lugar*) malloc(sizeof(Lugar));
  60.         char linha[MAX_LINHA_LUGAR], buffer[10];
  61.        
  62.         int flush;
  63.  
  64.        
  65.         printf("Premir para carregar lugares\n");
  66.         getchar();
  67.        
  68.         while(fgets(linha, MAX_LINHA_LUGAR, fp)!= NULL/*!feof(fp)*/){
  69.                
  70.                 printf("->%s<- \n",linha);
  71.                
  72.                
  73.                 //printf("%s\n",linha);
  74.                 lugar = cria_lugar(lugar, linha);
  75.                        
  76.                 sprintf(buffer, "%d", lugar -> codigo);
  77.                
  78.                 if((*hash)[fhash(buffer)] == NULL ){
  79.                
  80.                         aux = init(sizeof(Lugar), &comparatorLugares);
  81.                         init_hash_list(hash, aux, buffer);
  82.                         insere_hash(hash, aux, lugar, buffer);
  83.                        
  84.                
  85.                 }
  86.                 else{
  87.                         insere_hash(hash, aux, lugar, buffer);
  88.                 }
  89.                
  90.                 printf("PROCURA:%d\n",procura((*hash)[fhash(buffer)],lugar));
  91.                
  92.                 printf("->%s<-\n",lugar->nome);
  93.                 limpabuff();
  94.         }
  95.        
  96.         return 1;
  97. }
  98.  
  99. /*
  100. // Dada a posição no inicio da linha do ficheiro, insere uma relação de amizade no grafo de amigos
  101. int carrega_amigos(FILE *fp, Grafo *g){
  102.  
  103.         return 1;
  104. }
  105.  
  106. // Dada a posição no inicio da linha do ficheiro, insere uma relação de lugares no grafo de lugares
  107. int carrega_caminhos(FILE *fp, Grafo *g){
  108.  
  109.         return 1;
  110. }*/
  111.  
  112. /*
  113. // Dado o ficheiro e o grafo de amigos, insere todas as relações de amizade num ficheiro
  114. int guardar_amigos(FILE *fp, Grafo *g){
  115.        
  116.         return 1;
  117. }
  118.  
  119. // Dado o ficheiro e o grafo de lugares, insere todas as relações de lugares num ficheiro
  120. int guardar_lug_adj(FILE *fp, Grafo *g){
  121.  
  122.         return 1;
  123. }*/
  124.  
  125. // Dado o ficheiro e a Hash de utilizadores, guarda a informação toda em ficheiro.
  126. int guardar_utilizadores(FILE *fp, Hash *hash){
  127.  
  128.         /* Utilizar fora desta função
  129.        
  130.         if ((fp = fopen("utilizadoresFSQ_UM.csv", "r")) == NULL)
  131.                 fprintf(stderr, "Cannot open %s\n", "utilizadoresFSQ_UM.csv");
  132.         */
  133.  
  134.         Lista* lista_aux;// = (Lista *) malloc(sizeof(Lista));
  135.         Nodo* nodo_aux;// = (Nodo *) malloc(sizeof(Nodo));
  136.         User* user_aux;// = (User *) malloc(sizeof(User));
  137.        
  138.         int i = 0;
  139.         char buffer[5];
  140.  
  141.         for(i = 0; i < HASH_SIZE; i++){
  142.  
  143.         lista_aux = (*hash)[i];
  144.         nodo_aux = lista_aux -> root;
  145.         user_aux = nodo_aux -> dados;
  146.        
  147.                 while(nodo_aux != NULL){
  148.                        
  149.                         fputs(user_aux -> nickname, fp);
  150.                         fputs(",", fp);
  151.                        
  152.                         fputs(user_aux -> nome, fp);
  153.                         fputs(",", fp);
  154.                        
  155.                         fputs(user_aux -> email, fp);
  156.                         fputs(",", fp);
  157.                        
  158.                         fputs(user_aux -> morada, fp);
  159.                         fputs(",", fp);
  160.                        
  161.                         sprintf(buffer, "%d", user_aux -> pontos);
  162.                         fputs(buffer, fp);
  163.                         fputs("\n", fp);
  164.                
  165.                         nodo_aux = nodo_aux -> proximo;
  166.                 }
  167.        
  168.         }
  169.  
  170.         purge_hash(hash);
  171.  
  172.         return 1;
  173. }
  174.  
  175. int guardar_lugares(FILE *fp, Hash *hash){
  176.  
  177.         /* Utilizar fora desta função
  178.        
  179.         if ((fp = fopen("coordenadas.txt", "r")) == NULL)
  180.                 fprintf(stderr, "Cannot open %s\n", "coordenadas.txt");
  181.         */
  182.  
  183.         Lista* lista_aux;// = (Lista *) malloc(sizeof(Lista));
  184.         Nodo* nodo_aux;// = (Nodo *) malloc(sizeof(Nodo));
  185.         Lugar* lugar_aux;// = (Lugar *) malloc(sizeof(Lugar));
  186.        
  187.         int i = 0;
  188.         char buffer[5];
  189.  
  190.         for(i = 0; i < HASH_SIZE; i++){
  191.  
  192.                 lista_aux = (*hash)[i];
  193.                 nodo_aux = lista_aux -> root;
  194.                 lugar_aux = nodo_aux -> dados;
  195.        
  196.                 while(nodo_aux!= NULL){
  197.                
  198.                         sprintf(buffer, "%d", lugar_aux -> codigo);
  199.                         fputs(buffer, fp);
  200.                         fputs(":", fp);
  201.                        
  202.                         fputs(lugar_aux -> nome, fp);
  203.                         fputs(":", fp);
  204.                        
  205.                         sprintf(buffer, "%d", lugar_aux -> latitude.graus);
  206.                         fputs(buffer, fp);
  207.                         fputs(".", fp);
  208.                        
  209.                         sprintf(buffer, "%d", lugar_aux -> latitude.minutos);
  210.                         fputs(buffer, fp);
  211.                         fputs(":", fp);
  212.                        
  213.                         sprintf(buffer, "%d", lugar_aux -> longitude.graus);
  214.                         fputs(buffer, fp);
  215.                         fputs(".", fp);
  216.                        
  217.                         sprintf(buffer, "%d", lugar_aux -> longitude.graus);
  218.                         fputs(buffer, fp);
  219.                         fputs(":", fp);
  220.                        
  221.                         sprintf(buffer, "%d", lugar_aux -> pontos_checkin);
  222.                         fputs(buffer, fp);
  223.                         fputs("\n", fp);
  224.                        
  225.                         nodo_aux = nodo_aux -> proximo;
  226.                 }
  227.        
  228.         }
  229.  
  230.         free(lugar_aux);
  231.         free(nodo_aux);
  232.         free(lista_aux);
  233.        
  234.         purge_hash(hash);
  235.  
  236.         return 1;
  237. }
create a new version of this paste RAW Paste Data