MessageClient.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
/*! \file MessageClient.h
*  \brief Declares the base classes used by the application to communicate.
*  \author $Author: rsharo $
*  \version $Revision: 1.1 $
*  \date    $Date: 2004/04/07 13:45:04 $
*///////////////////////////////////////////////////////////////////////////////
#ifndef MESSAGE_CLIENT_H
#define MESSAGE_CLIENT_H

#include "Comm/MessageServer.h"

//
// This is the base class for consumers of network messages.
//
// Users of this class must perform the following:
// 1) Implement the ReceiveMessage() method in their derived class.
// 2) Supply a client ID at construction time.
// 3) Call Register() with a pointer to a valid MessageServer.
//
// As long as the message server keeps running, any messages sent
// to the specified client ID will be presented to the client.
// If the client returns (-1) from ReceiveMessage(), the server
// will deregister the client and it will no longer receive messages.
class MessageClient
{
public:
        //
        // Note that the MessageServer class has control of the m_pServer
        // member.
        friend class MessageServer;

        //
        // Constructs a MessageClient.  The derived class must supply
        // a client identifier at the time of construction.
        MessageClient(u_int id) : m_id(id), m_pServer(NULL) {}

        //
        // Virtual destructor. Default behavior is to deregister
        // with the message server (if any).
        virtual ~MessageClient()
        {
                if (m_pServer != NULL)
                        Deregister();
        }


        //
        // Returns the identifier for this client.  The identifier was
        // specified at construction time.
        u_int id() const { return m_id; }


        //
        // Handles an incoming message. The derived class must implement
        // this pure-virtual method.
        // Note that if this method returns a -1, the server will
        // automatically deregister this client for the given ID.
        virtual int ReceiveMessage(const char *msg, size_t len) = 0;

        //
        // Registers this client with a message server.
        // Returns 0 on success and -1 on failure.
        virtual int Register(MessageServer *pServer);

        //
        // Deregisters this client with its message server.
        // Returns 0 on success and -1 on failure.
        virtual int Deregister();

protected:
        //
        // If registered with a message server, this method
        // sends a message to another client. 
        // It returns -1 on error and the number of bytes sent on success.
        int SendMessage(const void *msg, size_t len, u_int dest)
        {
                if (m_pServer == NULL)
                {
                        ACE_ERROR_RETURN((LM_ERROR,
                                "(%N:%l) Attempt to send a message from an unregistered "
                                "message client.\n"),-1);
                }

                return m_pServer->SendMessage(m_id, msg, len, dest);
        }

        //
        // Returns a pointer to the client's message server.
        // If not registered, this method returns NULL.
        MessageServer * Server() { return m_pServer; }

private:
        //
        // The identifier by which this client is known.
        const u_int             m_id;

        //
        // The server with which this client is registered.
        // NOTE: This member is set and cleared exclusively by the
        // server class itself.  This class should not change this member.
        MessageServer * m_pServer;
};



//
// This is a base class for clients that wish to handle messages
// to many client IDs from a single object.
class MultiMessageClient
{
public:
        //
        // Constructs a multi-message client.
        MultiMessageClient(u_int *id, u_int numIDs);

        //
        // Virtual destructor for the multi-message client.
        virtual ~MultiMessageClient();

        //
        // This pure virtual method is called any time a message is received
        // for any of the registered IDs.
        // NOTE: if this method returns -1, then the client is deregistered
        // for the specific ID for which this method was called.
        virtual int ReceiveMessage(u_int destinationID,
                const char *msg, size_t len) = 0;

        //
        // If registered with a message server with the given origination ID,
        // this method sends a message to another client.
        // It returns -1 on error and the number of bytes sent on success.
        int SendMessage(u_int originator, const void *msg, size_t len, u_int dest);

        //
        // Registers this client with a message server.
        // Returns 0 if all IDs successfully register and -1 on any failure.
        virtual int Register(MessageServer *pServer);

        //
        // Deregisters this client with its message server.
        // Returns 0 if all IDs successfully deregister and -1 on any failure.
        virtual int Deregister();

private:
        //
        // This inner class routes its messages to the parent MultiMessageClient.
        class MC : public MessageClient
        {
        public:
                // Constructs this specialized message client.
                MC(u_int id, MultiMessageClient *pParent)
                        : MessageClient(id), m_pParent(pParent) {}

                // Makes SendMessage public to the MultiMessageClient can call it.
                int SendMessage(const void *msg, size_t len, u_int dest)
                        { return MessageClient::SendMessage(msg, len, dest); }

                // Forwards a message to the MultiMessageClient.
                virtual int ReceiveMessage(const char *msg, size_t len)
                        { return m_pParent->ReceiveMessage(id(), msg, len); }

        private:
                MultiMessageClient *m_pParent;

        };

private:
        //
        // The array of MessageClients -- one per ID.
        MC **m_ppChildren;

        //
        // The number of MessageClients in the array.
        u_int m_numChildren;

};

#endif // MESSAGE_CLIENT_H

---