Implementação dos tipos de dados

Vamos discutir como implementar os tipos de dados definidos para a aplicação usando a linguagem de definição de interfaces para RPC e depois como estas definições são implementadas usando a linguagem C. A seguir apresentamos o código necessário para manipular estas estruturas de dados. 

Definição da interface:

O protocolo XRD é usado para converter os dados do formato específico de cada máquina para um formato único antes de transmiti-los pela rede. Desta forma não precisamos nos preocupar de maneira nenhuma com conversão de dados entre estações.

O arquivo contendo todas as definições do servidor é o  trec.x. É bom que se tenha muito cuidado ao manusear este arquivo, pois quaiquer modificações nele quando compiladas podem impedir a correta utilização do servidor.

Para a implementação deste servidor criamos os seguintes tipos de dados básicos:

typedef int documento;
typedef int termo;
typedef float idf;
typedef short frequencia;
typedef float norma;
typedef string texto<>;

Além destes tipos básicos foram criados tipos estruturados para implementar as definições apresentadas. A principal observação é o fato de que não existe uma estrutura para representar conjuntos em C. Usando RPC podemos criar vetores (arrays) ilimitados que foram usados como mecanismo para implementar os conjuntos. O exemplo abaixo define o tipo lista invertida (lista_inv):

/* tipo da tupla (documento, frequencia) */
struct doc_freq{
  documento d;
  frequencia f;
};
typedef struct doc_freq ldf<>; /* vetor ilimitado de tuplas */

/* tipo lista_inv */
struct lista_inv_{
 termo t;    /* identificador do termo */
 ldf lista;  /* lista de ocorrencias do termo */
};
typedef struct lista_inv_ lista_inv;

Como usar vetores ilimitados com RPC

O código gerado para implementar os vetores ilimitados em C é um tanto obscuro e precisa ser bem compreendido. Vamos ilustrar dois exemplos: a lista de termos, que é um caso típico.

Lista de termos

struct lista_ter{
 termo t<>;
};

typedef struct lista_ter lista_ter<>;

Vamos analisar agora o código C gerado, que efetivamente será manipulado por nossos programas.

struct lista_ter {
  struct {
    u_int t_len;
    termo *t_val;
  } t;
};
typedef struct lista_ter lista_ter;

Como escrever e como ler num vetor ilimitado:

Precisamos de uma variável ponteiro do tipo termo para "percorrer" o campo t_val. O trecho de código a seguir preenche hipoteticamente uma lista com n termos:
termo *t;
lista_ter lt;

/* inicializando a lista */
lt.t_len = n;                                 /* quantidade de elementos na lista */
lt.t_val = (termo *)malloc(n * sizeof(termo)); /* tamanho da lista */
t = lt.t_val;    /* t aponta para o primeiro termo dentro da lista */
...
for(i=0; i<n; i++){
     escreve (*t);                       /* escrita do valor do termo */
  t++;                    /* avanca para o proximo termo na lista */
}
 

Para ler o conteúdo de uma lista de termos fazemos um procedimento análogo:
 
termo *t;
lista_ter lt;

n = lt.t_len;           /* pega a quantidade de elementos da lista */
t = lt.t_val;    /* t aponta para o primeiro termo dentro da lista */
...
for(i=0; i<n; i++){
    le(*t);                        /* leitura do valor de um termo */
    t++;                  /* avanca para o proximo termo da lista */
}

• Note que não é necessário inicializar uma estrutura quando a recebemos através de uma chamada ao servidor. O código embutido já faz esse trabalho para nós.
• As estruturas que são passadas para e recebidas do servidor são sempre referenciadas através de ponteiros então deve-se observar atentamente quando usar o operador . e quando usar o operador ->.

Código de acesso às estruturas

Veja como pegar e utilizar estes e outros arquivos.