ACE/protocols/ace/INet/StreamHandler.h

   1 /**
   2  * @file StreamHandler.h
   3  *
   4  * @author Martin Corino <mcorino@remedy.nl>
   5  */
   6
   7 #ifndef ACE_IOS_STREAM_HANDLER_H
   8 #define ACE_IOS_STREAM_HANDLER_H
   9
  10 #include /**/ "ace/pre.h"
  11
  12 #include /**/ "ace/config-all.h"
  13
  14 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  15 # pragma once
  16 #endif /* ACE_LACKS_PRAGMA_ONCE */
  17
  18 #include "ace/Svc_Handler.h"
  19 #include "ace/Reactor_Notification_Strategy.h"
  20
  21 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  22
  23 namespace ACE
  24   {
  25     namespace IOS
  26       {
  27         /**
  28         * @class ACE_IOS_StreamHandler
  29         *
  30         * @brief Encapsulates streamed connection.
  31         *
  32         * This class provides the connection point for the
  33         * ACE Acceptor and Connector based patterns and the
  34         * ACE Reactor framework to C++ standard streams
  35         * based classes.
  36         */
  37         template <ACE_PEER_STREAM_1, ACE_SYNCH_DECL>
  38         class StreamHandler
  39           : public ACE_Svc_Handler<ACE_PEER_STREAM, ACE_SYNCH_USE>
  40           {
  41             public:
  42               // useful traits
  43               typedef StreamHandler<ACE_PEER_STREAM, ACE_SYNCH_USE> this_type;
  44               typedef ACE_Svc_Handler<ACE_PEER_STREAM, ACE_SYNCH_USE> base_type;
  45               typedef ACE_Message_Queue<ACE_SYNCH_USE> mq_type;
  46
  47               /// Constructor
  48               StreamHandler (const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults,
  49                              ACE_Thread_Manager *thr_mgr = 0,
  50                              mq_type *mq = 0,
  51                              ACE_Reactor *reactor = ACE_Reactor::instance ());
  52
  53               /// Destructor
  54               virtual ~StreamHandler ();
  55
  56               /// Activate the connection
  57               virtual int open (void * = 0);
  58
  59               /// Close the connection
  60               virtual int close (u_long flags = 0);
  61
  62               /// Called to handle incoming data when using StreamHandler in
  63               /// reactive mode
  64               virtual int handle_input (ACE_HANDLE);
  65
  66               /// Called to handle outgoing data when using StreamHandler in
  67               /// reactive mode
  68               virtual int handle_output (ACE_HANDLE);
  69
  70               /// Called by streambuffer to read/receive new data from peer
  71               int read_from_stream (void * buf, size_t length, size_t char_size);
  72
  73               /// Called by streambuffer to send new data to peer
  74               int write_to_stream (const void * buf, size_t length, size_t char_size);
  75
  76               /// Returns true as long as the connection to peer is active
  77               bool is_connected () const;
  78
  79               /// Returns true if StreamHandler has been configured for reactive mode
  80               bool using_reactor () const;
  81
  82             private:
  83               enum
  84                 {
  85                   MAX_INPUT_SIZE = 4096
  86                 };
  87
  88               /// Attempts to receive data from peer and queue it.
  89               /// Called either from handle_input in reactive mode or
  90               /// directly from read_from_stream when non-reactive.
  91               int handle_output_i (ACE_Time_Value* timeout = 0);
  92
  93               /// Attempts to send queued data to peer.
  94               /// Called either from handle_output in reactive mode
  95               /// or directly from write_to_stream when non-reactive.
  96               int handle_input_i (size_t rdlen, ACE_Time_Value* timeout = 0);
  97
  98               /// processes queued input
  99               int process_input (char* buf,
 100                                  size_t& char_length,
 101                                  size_t char_size,
 102                                  ACE_Time_Value* timeout);
 103
 104               /// Returns true if a timeout is to be used on IO operations.
 105               bool use_timeout () const;
 106
 107               /// Returns true is the queued data contains at least char_size bytes.
 108               bool char_in_queue (size_t char_size);
 109
 110               bool connected_;
 111               ACE_Synch_Options sync_opt_;
 112               bool send_timeout_;
 113               bool receive_timeout_;
 114               ACE_Reactor_Notification_Strategy notification_strategy_;
 115
 116               class NotificationStrategyGuard
 117                 {
 118                   public:
 119                     NotificationStrategyGuard (this_type& queue_owner,
 120                                                ACE_Reactor_Notification_Strategy* ns)
 121                       : queue_owner_ (queue_owner)
 122                       {
 123                         this->queue_owner_.msg_queue ()->notification_strategy (ns);
 124                       }
 125                     ~NotificationStrategyGuard ()
 126                       {
 127                         this->queue_owner_.msg_queue ()->notification_strategy (0);
 128                       }
 129                   private:
 130                     this_type& queue_owner_;
 131                 };
 132           };
 133
 134         typedef StreamHandler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>  SockStreamHandler;
 135       }
 136   }
 137
 138 ACE_END_VERSIONED_NAMESPACE_DECL
 139
 140 #include "ace/INet/StreamHandler.cpp"
 141
 142 #include /**/ "ace/post.h"
 143 #endif /* ACE_IOS_STREAM_HANDLER_H */