Author: James CE Johnson

ACE Tutorial 015
Building a protocol stream

The implementation of the Client object. Only the open() method really does any work. The other methods simply delegate their function to the Protocol_Stream.

    // page04.html,v 1.13 1999/04/03 21:56:29 jcej Exp

    #include "Client_i.h"
    #include "ace/Message_Block.h"
    #include "ace/INET_Addr.h"
    #include "ace/SOCK_Connector.h"

    // Simple constructor just remembers the endpoint information for use by open.
    Client::Client( u_short _port, const char * _server)
            : port_(_port), server_(_server)
    {
        ;
    }

    /* Do nothing.  This should probably call close() if we can make sure
       that it's OK to close() multiple times.
    */
    Client::~Client(void)
    {
        ;
    }

    /* Open the connection to the server.  This is traditional ACE.  We
       simply construct an endpoint and use a connector to establish the
       link.
    */
    int Client::open( void )
    {
        ACE_INET_Addr addr(port_,server_);
        ACE_SOCK_Connector con;

        if( con.connect(peer(),addr) == -1 )
        {
            ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_SOCK_Connector::connect()"), -1);
        }

            // Something new here...  We have to use the protocol stream
            // to ensure that our data is in the correct format when
            // received by the server.  Thus, we open the stream and
            // transfer ownership of the peer.
        return stream().open( peer() );
    }

    // The remainder of the functions just delegate to the stream.

    int Client::close( void )
    {
        return stream().close();
    }

    int Client::put( ACE_Message_Block * _message )
    {
        return stream().put(_message,0);
    }

    int Client::get( ACE_Message_Block * & _response )
    {
        return stream().get(_response);
    }

Ok, that's it for the client. We've seen a very simple main() followed by an equally simple Client object.

For a quick look back:

- client Makefile
- client.cpp
- Client_i.h
- Client_i.cpp

Now we'll move on and examine the server counter-part of our client.

[Tutorial Index] [Continue This Tutorial]