Página principal   Módulos   Lista de namespaces   Hierarquia de classes   Lista de componentes   Lista de ficheiros   Membros do namespace   Componentes membro   Ficheiros membro   Páginas relacionadas  

Referência à classe IPC::Mensageiro
[Mensageiros entre processos]

Classe cuja única instância (em cada processo) representa um mensageiro entre o processo em causa e um outro na mesma máquina. Mais...

#include <IPC++/mensageiro.H>

Mostrar lista completa dos membros

Membros públicos

 Mensageiro (key_t const chave=getuid())
 Contrói um novo mensageiro.

 ~Mensageiro ()
 Destrói o mensageiro, destruindo a caixa do correio criada se for o último mensageiro em existência.

std::string meuIdentificador () const
 Devolve um identificador único para o processo, que consiste no nome do utilizador seguido do número do processo.

std::string identificadorDoOutro () const
 Devolve o identificador único do outro processo, com o qual o corrente está emparelhado através do mensageiro.

void leMensagem ()
 Lê uma nova mensagem vinda do "outro".

template<typename Tipo> Tipo const mensagemLida () const
 Devolve a mensagem lida na forma de um valor do tipo Tipo.

template<typename Tipo> void envia (Tipo &mensagem) const
 Envia uma mensagem correspondente a um valor do tipo Tipo (versão para variáveis).

template<typename Tipo> void envia (Tipo const &mensagem) const
 Envia uma mensagem correspondente a um valor do tipo Tipo (versão para constantes e valores temporários).

template<typename Char> void envia (Char *&mensagem) const
 Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para ponteiros simples).

template<typename Char> void envia (Char const *&mensagem) const
 Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para ponteiros para caracteres constantes).

template<typename Char> void envia (Char *const &mensagem) const
 Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para ponteiros constantes).

template<typename Char> void envia (Char const *const &mensagem) const
 Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para ponteiros constantes para caracteres constantes).

template<typename Char, int dimensao> void envia (Char const(&mensagem)[dimensao]) const
 Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para matrizes de caracteres).

Descrição detalhada

Classe cuja única instância (em cada processo) representa um mensageiro entre o processo em causa e um outro na mesma máquina.

Esta classe é um solitão! A ideia é que um processo com uma instância desta classe fica em comunicação com outro com outra instância da mesma classe. A selecção do outro processo é feita automaticamente, de acordo com as disponibilidades. A ideia é permitir a comunicação entre dois processos do mesmo jogo, sendo que os jogadores não têm controlo sobre que será o seu opositor.

Nas descrições usa-se o termo "eu" para indicar o processo corrente, e "outro" para indicar o processo a que o "eu" está emparelhado pelo mensageiro.

A comunicação faz-se enviando e recebendo mensagens. As mensagens enviadas e recebidas são de qualquer tipo para o qual:

  1. estejam definido os operadores << e >> para ostream e istream, respectivamente;
  2. tenham definido um construtor por omissão; e
  3. tenham definido um cnstrutor por cópia.

Não existe, para já, nenhuma forma de indagar se há alguma mensagem disponível para ser recebida e muito menos saber o seu tipo. O protocolo entre os processos é que tem de garantir que os processos recebem tantas mensagens quantas as enviadas pelo outro, enviam tantas mensagens quantas as recebidas pelo outro, e que as mensagens enviadas e recebidas têm tipos compatíveis.

A classe é simples de usar. Por exemplo, suponha que se pretendia fazer um pequeno jogo em que ganha quem gerar um número aleatório maior. Poder-se-ia escrever o seguinte programa: 

#include <iostream>
#include <cstdlib>
#include <ctime>

#include <IPC++/mensageiro.H>

using namespace std;
using namespace IPC;

int main() 
{
    // Se não se fizer isto os jogadores geram sempre o mesmo número
    // aleatório...
    srand(time(0));

    try {
        // Construir mensageiro:
        Mensageiro mensageiro;
        
        // Escrever identificações:
        cout << "Eu sou o " << mensageiro.meuIdentificador() << endl;
        cout << "Ele é o " << mensageiro.identificadorDoOutro() << endl;
        
        // Gerar número aleatório:
        int meu = rand();
        
        // Enviá-lo ao adversário:
        mensageiro.envia(meu);
        
        // Receber número do adeversário:

        mensageiro.leMensagem();
        int dele = mensageiro.mensagemLida<int>();
        
        // Verificar resultado:
        if(meu < dele)
            cout << "Perdi " << meu << " contra " << dele << "..." 
                 << endl;
        else if(meu > dele)
            cout << "Ganhei " << meu << " contra " << dele << '!' 
                 << endl;
        else
            cout << "Empatámos " << meu << " a " << dele << '.' 
                 << endl;
    } catch(IPC::Erro& erro) {
        cerr << string(erro) << endl;
    }
}

Invariante:
meu_PID = int(getpid()) e meu_UID = int(getuid()) e PID_do_outro = PID do "outro" e UID_do_outro = UID do "outro" e 0 <= identificador_da_caixa_do_correio e 0 <= identificador_do_semaforo.

Definido na linha 89 do ficheiro mensageiro.H.

Documentação dos Construtores & Destrutor

IPC::Mensageiro::Mensageiro (  key_t const    chave = getuid() ) 
 

Contrói um novo mensageiro.

Podem-se criar mensageiros de dois tipos: restritos ou não restritos. O primeiro tipo consegue-se não passando qualquer argumento ao construtor e restringe o emparelhamento dos processos a processos do mesmo utilizador. O segundo tipo é mais geral, pois permite o emparelhamento de processos de utilizadores arbitrários da mesma máquina, mas exige a passagem de uma chave ipc que deve ser única para cada tipo de aplicação prevista (por uma questão de compatibilidade de protocolos de comunicação).

Precondição:
V.
Poscondição:
O mensageiro está construído e ligado a um mensageiro de outro processo.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

Definido na linha 11 do ficheiro mensageiro.C.

IPC::Mensageiro::~Mensageiro (    ) 
 

Destrói o mensageiro, destruindo a caixa do correio criada se for o último mensageiro em existência.

Precondição:
V.

Definido na linha 76 do ficheiro mensageiro.C.

Documentação dos métodos

std::string IPC::Mensageiro::meuIdentificador (    )  const [inline]
 

Devolve um identificador único para o processo, que consiste no nome do utilizador seguido do número do processo.

Precondição:
V.
Poscondição:
meuIdentificador = "UN + (PID)", onde UN é o nome do utilizador e PID é o número do processo.

Definido na linha 26 do ficheiro mensageiro_impl.H.

std::string IPC::Mensageiro::identificadorDoOutro (    )  const [inline]
 

Devolve o identificador único do outro processo, com o qual o corrente está emparelhado através do mensageiro.

Precondição:
O processo do "outro" tem de existir.
Poscondição:
identificadorDoOutro = "UN + (PID)", onde UN é o nome do utilizador do "outro" e PID é o número do processo do "outro".

Definido na linha 34 do ficheiro mensageiro_impl.H.

void IPC::Mensageiro::leMensagem (    )  [inline]
 

Lê uma nova mensagem vinda do "outro".

Espera pela mensagem a ler se não estiver nenhuma mensagem disponível.

Precondição:
V.
Poscondição:
Há uma mensagem lida.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

Definido na linha 42 do ficheiro mensageiro_impl.H.

std::string const IPC::Mensageiro::mensagemLida< std::string > (    )  const [inline]
 

Devolve a mensagem lida na forma de um valor do tipo Tipo.

É um erro se o tipo indicado não corresponder ao tipo do valor enviado pelo "outro".

Precondição:
Há uma mensagem lida.
Poscondição:
mensagemLida = mensagem enviada pelo "outro".
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos ou no caso de o tipo especificado ser incompatível com a mensagem lida.

Definido na linha 49 do ficheiro mensageiro_impl.H.

template<typename Tipo>
void IPC::Mensageiro::envia (  Tipo &    mensagem )  const [inline]
 

Envia uma mensagem correspondente a um valor do tipo Tipo (versão para variáveis).

Precondição:
V.
Poscondição:
Está disponível para o "outro" uma nova mensagem.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

Definido na linha 77 do ficheiro mensageiro_impl.H.

Referenciado por envia().

template<typename Tipo>
void IPC::Mensageiro::envia (  Tipo const &    mensagem )  const [inline]
 

Envia uma mensagem correspondente a um valor do tipo Tipo (versão para constantes e valores temporários).

Precondição:
V.
Poscondição:
Está disponível para o "outro" uma nova mensagem.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

Definido na linha 90 do ficheiro mensageiro_impl.H.

template<typename Char>
void IPC::Mensageiro::envia (  Char *&    mensagem )  const [inline]
 

Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para ponteiros simples).

Precondição:
V.
Poscondição:
Está disponível para o "outro" uma nova mensagem.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

Definido na linha 121 do ficheiro mensageiro_impl.H.

Referências envia().

template<typename Char>
void IPC::Mensageiro::envia (  Char const *&    mensagem )  const [inline]
 

Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para ponteiros para caracteres constantes).

Precondição:
V.
Poscondição:
Está disponível para o "outro" uma nova mensagem.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

Definido na linha 103 do ficheiro mensageiro_impl.H.

Referências envia().

template<typename Char>
void IPC::Mensageiro::envia (  Char *const &    mensagem )  const
 

Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para ponteiros constantes).

Precondição:
V.
Poscondição:
Está disponível para o "outro" uma nova mensagem.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

template<typename Char>
void IPC::Mensageiro::envia (  Char const *const &    mensagem )  const [inline]
 

Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para ponteiros constantes para caracteres constantes).

Precondição:
V.
Poscondição:
Está disponível para o "outro" uma nova mensagem.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

Definido na linha 109 do ficheiro mensageiro_impl.H.

Referências envia().

template<typename Char, int dimensao>
void IPC::Mensageiro::envia (  Char const &    mensagem[dimensao] )  const [inline]
 

Envia uma mensagem correspondente a um valor do tipo cadeia clássica de caracteres (versão para matrizes de caracteres).

Precondição:
V.
Poscondição:
Está disponível para o "outro" uma nova mensagem.
Excepções:
IPC::Erro no caso de haver erro na API de comunicação entre processos.

Definido na linha 128 do ficheiro mensageiro_impl.H.

Referências envia().

A documentação para esta classe foi gerada a partir dos seguintes ficheiros:
Gerado em Tue Dec 3 15:19:36 2002 para Pacotes por doxygen1.3-rc1