---

mensageiro.H

Ir para a documentação deste ficheiro.

#ifndef IPC_MENSAGEIRO_H
#define IPC_MENSAGEIRO_H

#include <string>

#include <Erros/erros.H>
#include <Utilitarios/cadeia.H>

extern "C" {
    #include <sys/msg.h>
    #include <sys/sem.h>
    #include <unistd.h>
    #include <pwd.h>
}

namespace IPC {

    class Erro : public Erros::Erro {
    public:
        Erro(std::string const& mensagem);

        Erro();

    private:
        std::string mensagem;
    };

    class Mensageiro {
    public:
        Mensageiro(key_t const chave = getuid());

        ~Mensageiro();

        std::string meuIdentificador() const;

        std::string identificadorDoOutro() const;

        void leMensagem();

        template <typename Tipo>
        Tipo const mensagemLida() const;

        template <typename Tipo>
        void envia(Tipo& mensagem) const;

        template <typename Tipo>
        void envia(Tipo const& mensagem) const;

        template <typename Char>
        void envia(Char*& mensagem) const;

        template <typename Char>
        void envia(Char const*& mensagem) const;

        template <typename Char>
        void envia(Char* const& mensagem) const;

        template <typename Char>
        void envia(Char const* const& mensagem) const;

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

    private:
        std::string tipo_dos_dados;
        std::string mensagem;
        int meu_PID;
        int PID_do_outro;
        int meu_UID;
        int UID_do_outro;
        int identificador_da_caixa_do_correio;
        int identificador_do_semaforo;
        bool sou_um_servidor;
        static bool existe_instancia;

        // Assim ninguém pode invocar o construtor por cópia...
        Mensageiro(Mensageiro const&);

        // ...nem a atribuição por cópia:
        Mensageiro& operator =(Mensageiro const&);

        // Lê uma mensagem consistindo num inteiro, sem verificação do tipo e
        // com ou sem espera, consoante o valor do argumento.  É uma rotina
        // dois em um, mas é usada apenas internamente.  O tipo é o tipo usado
        // para discriminar entre filas de espera da caixa do correio.
        int leBasicoInt(int const tipo, bool const deve_esperar = true) const;

        // Lê uma mensagem nua (i.e., lê uma cadeia de caracteres
        // directamente, sem interpretação), com ou sem espera, consoante o
        // valor do argumento.  É uma rotina dois em um, mas é usada apenas
        // internamente.  O tipo é o tipo usado para discriminar entre filas
        // de espera da caixa do correio.
        std::string leBasico(int const tipo, 
                             bool const deve_esperar = true) const;

        // Escreve uma mensagem consistindo simplemente num inteiro, sem
        // indicação do tipo.  O tipo é o tipo usado para discriminar entre
        // filas de espera da caixa do correio.
        void escreveBasicoInt(int const tipo, int const valor);

        // Escreve uma mensagem nua.  O tipo é o tipo usado para discriminar
        // entre filas de espera da caixa do correio.
        void escreveBasico(int const tipo, std::string const& mensagem) const;

        // Estabelece uma nova nova caixa do correio (ou liga-se a uma caixa
        // do correio existente).  Usa a chave IPC dada.
        void estabeleceCaixaDoCorreio(key_t const chave);

        // Remove a caixa do correio.
        void removeCaixaDoCorreio();

        // Estabelece o semáforo de acesso à caixa do correio (ou liga-se um
        // semáforo já existente).  Usa a chave IPC dada.
        void estabeleceSemaforoDeAcesso(key_t const chave);

        // Inicia um período de acesso exclusivo à caixa do correio.  Útil
        // durante o protocolo de início de conversação entre os mensageiros.
        void entraEmAcessoExclusivo() const;

        // Termina um período de acesso exclusivo à caixa do correio.  Útil
        // durante o protocolo de início de conversação entre os mensageiros.
        void saiDeAcessoExclusivo() const;

        bool cumpreInvariante() const;
    };
}

#include <IPC++/mensageiro_impl.H>

#endif //IPC_MENSAGEIRO_H

---