superSimpleComm.cpp

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
/*! \file superSimpleComm.cpp
 *  \brief This file provides an example of how to use comm. This is about as simple as it gets...
 *  \author  $Author: rsharo $
 *  \version $Revision: 1.1 $
 *  \date    $Date: 2004/08/04 04:07:03 $
 *//////////////////////////////////////////////////////////////////////////////

#include <stdio.h>

#include "ace/ACE.h"
#include "Utils/SystemProperties.h"
#include "Comm/CommFactory.h"
#include "Comm/MessageClient.h"
#include "Comm/MessageServer.h"



//
// This class talks over the network.  Objects of this class get any messages
// sent to their address. The address is specified when the object is created.
// This is because the address is passed into the constructor.
class SomeMessageClient : public MessageClient
{
public:
        //
        // The constructor establishes this client's ID field.
        // Messages with this ID will be read by this client.
        // We're also registering with the Comm system right out 
        // of the constructor for this example.
        SomeMessageClient(int myID, MessageServer *pMsgSvr)
                : MessageClient(myID)
        {
                Register(pMsgSvr);
        }

        //
        // All clients must implement this method.  This is the one that
        // is called when the client gets a message.
        // If this method ever returns -1, then the client is disconncted
        // and won't receive any more messages. Its a good idea to make this
        // method return -1 when the client has outlived its usefulness.
        // Clients can be reconnected later with another call to Register().
        virtual int ReceiveMessage(const char *msg, size_t len)
        {
                printf("SomeMessageClient just got: %s\n", msg);

                return 0;
        }

        //
        // This method just takes in a string, figures out how many bytes
        // make up that string, and use the base class' method to send it out.
        int SendMessage(const char *msg, u_int dest)
        {
                //
                // Call the method from the MessageClient class that actually sends
                // out the message.  The first argument is the message to be sent. 
                // The second argument is the number of bytes that make up the message.
                // For strings, this is always the number of characters in the string
                // plus one (the extra one is the "null" character that marks the end
                // of the string).  The third argument is the address to which the
                // message will be sent.
                return MessageClient::SendMessage(msg, strlen(msg)+1, dest);
        }
};





int main()
{
        //
        // Disable some debug messages that clutter the console.
        {
                u_long mask =
                        ACE_Log_Msg::instance()->priority_mask(ACE_Log_Msg::PROCESS);

                ACE_Log_Msg::instance()->priority_mask(mask & ~LM_INFO,
                        ACE_Log_Msg::PROCESS);
        }

        printf("*** Code is running.\n");

        //
        // Load the system configuration from an INI-style
        // config file.
        SystemProperties *props = SystemProperties::Instance("System.config");

        //
        // All you need to do to set up comm is construct a factory
        // and tell it to open. Then all the clients can use
        // the factory to connect to the network.
        PropertyBasedCommFactory commFact;

        //
        // This tells the factory to get its properties from the
        // section of the config file labeled "Typhon\Comm".
        // If this fails, the program gives up and quits.
        if (commFact.Open(*props, "Typhon\\Comm") == -1)
        {
                printf("Comm setup failed.\n");
                exit(-1);
        }

        //
        // Get the message server from our factory. We use this to connect
        // our clients to the network.
        MessageServer *pMsgSvr = commFact.GetMessageServer();

        //
        // Construct the first client. It will receive any messages 
        // sent to address 100.
        SomeMessageClient client1(100, pMsgSvr);

        //
        // Construct the second client. It will receive any messages 
        // sent to address 101.
        SomeMessageClient client2(101, pMsgSvr);


        //
        // Send a message from client1 to client2.  Client2 will print
        // the message on the screen. The first argument is the message
        // being sent. The second argument is the address to send to
        // (in this case, 101 sends
        // it to client2).
        client1.SendMessage("Hello there!", 101);

        //
        // Send a message from client2 to client1.  Client1 will print
        // the message on the screen. The first argument is the message
        // being sent.  The second argument is the address to send to
        // (in this case, 100 sends it to client1).
        client2.SendMessage("Hello yourself!", 100);
        

        //
        // Wait a second before shutting down. This gives the clients
        // plenty of time to process the messages.
        ACE_OS::sleep(1);

        printf("*** Code is done.\n");
        
                
        return 0;
        
}



// Do not change the comments below - they will be added automatically by CVS
/*****************************************************************************
*       $Log: superSimpleComm.cpp,v $
*       Revision 1.1  2004/08/04 04:07:03  rsharo
*       Initial version.  This is an example of how to use the comm code that
*       doesn't depend on any other Whorl code.  "No hardware needed."
*
*
*       
*
******************************************************************************/

---