text: /* -*- C++ -*- */
  // $Id$
  
  #ifndef _CONSUMER_ROUTER_H
  #define _CONSUMER_ROUTER_H
  
  #include "ace/SOCK_Acceptor.h"
  
  #if !defined (ACE_LACKS_PRAGMA_ONCE)
  # pragma once
  #endif /* ACE_LACKS_PRAGMA_ONCE */
  
  #include "ace/UPIPE_Acceptor.h"
  #include "ace/Svc_Handler.h"
  #include "ace/RW_Thread_Mutex.h"
  #include "Peer_Router.h"
  
  class Consumer_Router : public Peer_Router
  {
    // = TITLE
    //     Provides the interface between one or more Consumers and the
    //     Event Server <ACE_Stream>.
    //
    // = DESCRIPTION
    //     This class normally sits on "top" of the Stream and routes
    //     messages coming from "downstream" to all the Consumers
    //     connected to it via its "read" <Task>.  Normally, the messages
    //     flow up the stream from <Supplier_Router>s.  However, if
    //     Consumers transmit data to the <Consumer_Router>, we dutifully
    //     push it out to the Suppliers via the <Supplier_Router>.
    //
    //     When used on the "reader" side of a Stream, the
    //     <Consumer_Router> simply forwards all messages up the stream.
    //     When used on the "writer" side, the <Consumer_Router> queues
    //     up outgoing messages to suppliers and sends them down to the
    //     <Supplier_Router> in a separate thread.  The reason for this
    //     is that it's really an "error" for a <Consumer_Router> to
    //     send messages to Suppliers, so we don't expect this to happen
    //     very much.  When it does we use a separate thread to avoid
    //     taxing the main thread, which processes "normal" messages.
    //
    //     All of the methods in this class except the constructor are
    //     called via base class pointers by the <ACE_Stream>.
    //     Therefore, we can put them in the protected section.
  public:
    Consumer_Router (Peer_Router_Context *prc);
    // Initialization method.
  
  protected:
    // = ACE_Task hooks.
    virtual int open (void *a = 0);
    // Called by the Stream to initialize the router.
  
    virtual int close (u_long flags = 0);
    // Called by the Stream to shutdown the router.
  
    virtual int put (ACE_Message_Block *msg, ACE_Time_Value * = 0);
    // Called by the <Peer_Handler> to pass a message to the
    // <Consumer_Router>.  The <Consumer_Router> queues up this message,
    // which is then processed in the <svc> method in a separate thread.
  
    virtual int svc (void);
    // Runs in a separate thread to dequeue messages and pass them up
    // the stream.
  
    // = Dynamic linking hooks.
    virtual int info (ACE_TCHAR **info_string, size_t length) const;
    // Returns information about this service.
  };
  
  #endif /* _CONSUMER_ROUTER_H */
  