ACE/apps/JAWS3/jaws3/Asynch_IO.cpp

   1 #ifndef JAWS_BUILD_DLL
   2 #define JAWS_BUILD_DLL
   3 #endif /*JAWS_BUILD_DLL*/
   4
   5 #include "ace/config-lite.h"
   6
   7 #include "jaws3/Jaws_IO.h"
   8 #include "jaws3/Asynch_IO.h"
   9 #include "jaws3/Event_Completer.h"
  10 #include "jaws3/Event_Result.h"
  11
  12 #if defined (ACE_HAS_AIO_CALLS) || defined (ACE_HAS_WIN32_OVERLAPPED_IO)
  13
  14 #include "jaws3/Asynch_IO_Helpers.h"
  15
  16 void
  17 JAWS_Asynch_IO::send ( ACE_HANDLE handle
  18                      , ACE_Message_Block *mb
  19                      , JAWS_Event_Completer *completer
  20                      , void *act
  21                      )
  22 {
  23   JAWS_EC_AH_Adapter *jecaha;
  24   jecaha = JAWS_EC_AH_Adapter::make (completer);
  25
  26   ACE_Asynch_Write_Stream asynch_write_stream;
  27
  28   if (jecaha == 0
  29       || asynch_write_stream.open (*jecaha, handle) == -1
  30       || asynch_write_stream.write (*mb, mb->length (), act) == -1)
  31     {
  32       delete jecaha;
  33       JAWS_Event_Result io_result ( 0
  34                                   , JAWS_Event_Result::JE_ERROR
  35                                   , JAWS_Event_Result::JE_SEND_FAIL
  36                                   );
  37
  38       if (completer)
  39         completer->output_complete (io_result, act);
  40     }
  41 }
  42
  43
  44 void
  45 JAWS_Asynch_IO::recv ( ACE_HANDLE handle
  46                      , ACE_Message_Block *mb
  47                      , JAWS_Event_Completer *completer
  48                      , void *act
  49                      )
  50 {
  51   JAWS_EC_AH_Adapter *jecaha;
  52   jecaha = JAWS_EC_AH_Adapter::make (completer);
  53
  54   ACE_Asynch_Read_Stream asynch_read_stream;
  55
  56   if (jecaha == 0
  57       || asynch_read_stream.open (*jecaha, handle) == -1
  58       || asynch_read_stream.read (*mb, mb->space (), act) == -1)
  59     {
  60       delete jecaha;
  61       JAWS_Event_Result io_result ( 0
  62                                   , JAWS_Event_Result::JE_ERROR
  63                                   , JAWS_Event_Result::JE_RECV_FAIL
  64                                   );
  65
  66       if (completer)
  67         completer->output_complete (io_result, act);
  68     }
  69 }
  70
  71
  72 void
  73 JAWS_Asynch_IO::transmit ( ACE_HANDLE handle
  74                          , ACE_HANDLE source
  75                          , JAWS_Event_Completer *completer
  76                          , void *act
  77                          , ACE_Message_Block *header
  78                          , ACE_Message_Block *trailer
  79                          )
  80 {
  81   JAWS_EC_AH_Adapter *jecaha;
  82   jecaha = JAWS_EC_AH_Adapter::make (completer);
  83
  84   ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer = 0;
  85   header_and_trailer =
  86     new ACE_Asynch_Transmit_File::Header_And_Trailer ( header
  87                                                      , header->length ()
  88                                                      , trailer
  89                                                      , trailer->length ()
  90                                                      );
  91
  92   ACE_Asynch_Transmit_File asynch_transmit_file;
  93
  94   if (source == ACE_INVALID_HANDLE
  95       || jecaha == 0
  96       || header_and_trailer == 0
  97       || asynch_transmit_file.open (*jecaha, handle) == -1
  98       || asynch_transmit_file.transmit_file ( source
  99                                             , header_and_trailer
 100                                             , 0
 101                                             , 0
 102                                             , 0
 103                                             , 0
 104                                             , 0
 105                                             , act
 106                                             ) == -1)
 107     {
 108       delete jecaha;
 109       delete header_and_trailer;
 110       JAWS_Event_Result io_result ( 0
 111                                   , JAWS_Event_Result::JE_ERROR
 112                                   , JAWS_Event_Result::JE_TRANSMIT_FAIL
 113                                   );
 114
 115       if (completer)
 116         completer->output_complete (io_result, act);
 117     }
 118 }
 119
 120
 121 JAWS_EC_AH_Adapter *
 122 JAWS_EC_AH_Adapter::make (JAWS_Event_Completer *completer)
 123 {
 124   return new JAWS_EC_AH_Adapter (completer);
 125 }
 126
 127 void
 128 JAWS_EC_AH_Adapter
 129 ::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
 130 {
 131   JAWS_Event_Result io_result;
 132
 133   io_result = this->make_io_result ( result
 134                                    , JAWS_Event_Result::JE_RECV_OK
 135                                    , JAWS_Event_Result::JE_RECV_FAIL
 136                                    );
 137   // More useful diagnostics not implemented yet.
 138
 139   void *act = const_cast<void *> (result.act ());
 140
 141   this->completer_->input_complete (io_result, act);
 142   delete this;
 143 }
 144
 145 void
 146 JAWS_EC_AH_Adapter
 147 ::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
 148 {
 149   JAWS_Event_Result io_result;
 150
 151   io_result = this->make_io_result ( result
 152                                    , JAWS_Event_Result::JE_SEND_OK
 153                                    , JAWS_Event_Result::JE_SEND_FAIL
 154                                    );
 155   // More useful diagnostics not implemented yet.
 156
 157   void *act = const_cast<void *> (result.act ());
 158
 159   this->completer_->output_complete (io_result, act);
 160   delete this;
 161 }
 162
 163 void
 164 JAWS_EC_AH_Adapter
 165 ::handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result)
 166 {
 167   JAWS_Event_Result io_result;
 168
 169   io_result = this->make_io_result ( result
 170                                    , JAWS_Event_Result::JE_TRANSMIT_OK
 171                                    , JAWS_Event_Result::JE_TRANSMIT_FAIL
 172                                    );
 173   // More useful diagnostics not implemented yet.
 174   // Watch out for files not opened in overlapped IO mode.
 175
 176   void *act = const_cast<void *> (result.act ());
 177
 178   this->completer_->output_complete (io_result, act);
 179   delete this;
 180 }
 181
 182 JAWS_Event_Result
 183 JAWS_EC_AH_Adapter
 184 ::make_io_result ( const ACE_Asynch_Result &result
 185                  , JAWS_Event_Result::JE_REASON reason_ok
 186                  , JAWS_Event_Result::JE_REASON reason_fail
 187                  )
 188 {
 189   size_t bytes = result.bytes_transferred ();
 190
 191   JAWS_Event_Result::JE_STATUS status;
 192   JAWS_Event_Result::JE_REASON reason;
 193
 194   if (result.success ())
 195     {
 196       status = JAWS_Event_Result::JE_OK;
 197       reason = reason_ok;
 198     }
 199   else
 200     {
 201       status = JAWS_Event_Result::JE_ERROR;
 202       reason = reason_fail;
 203     }
 204
 205   JAWS_Event_Result io_result (bytes, status, reason);
 206
 207   return io_result;
 208 }
 209
 210 #else /* EMULATE AIO WITH REACTOR */
 211
 212 #include "jaws3/Reactive_IO.h"
 213
 214 void
 215 JAWS_Asynch_IO::send ( ACE_HANDLE handle
 216                      , ACE_Message_Block *mb
 217                      , JAWS_Event_Completer *completer
 218                      , void *act
 219                      )
 220 {
 221   JAWS_Reactive_IO::instance ()->send (handle, mb, completer, act);
 222 }
 223
 224
 225 void
 226 JAWS_Asynch_IO::recv ( ACE_HANDLE handle
 227                      , ACE_Message_Block *mb
 228                      , JAWS_Event_Completer *completer
 229                      , void *act
 230                      )
 231 {
 232   JAWS_Reactive_IO::instance ()->recv (handle, mb, completer, act);
 233 }
 234
 235
 236 void
 237 JAWS_Asynch_IO::transmit ( ACE_HANDLE handle
 238                          , ACE_HANDLE source
 239                          , JAWS_Event_Completer *completer
 240                          , void *act
 241                          , ACE_Message_Block *header
 242                          , ACE_Message_Block *trailer
 243                          )
 244 {
 245   JAWS_Reactive_IO::instance ()->transmit ( handle
 246                                           , source
 247                                           , completer
 248                                           , act
 249                                           , header
 250                                           , trailer
 251                                           );
 252 }
 253
 254 #endif /* ACE_HAS_AIO_CALLS || ACE_HAS_WIN32_OVERLAPPED_IO */
 255
 256 // For now, we will simulate timed Asynch IO with timed Reactive IO.
 257 // In the future, we will implement the timed Asynch IO with timers
 258 // and Asynch IO cancelation.
 259
 260 #include "jaws3/Reactive_IO.h"
 261
 262 void
 263 JAWS_Asynch_IO::send ( ACE_HANDLE handle
 264                      , ACE_Message_Block *mb
 265                      , JAWS_Event_Completer *completer
 266                      , const ACE_Time_Value &tv
 267                      , void *act
 268                      )
 269 {
 270   JAWS_Reactive_IO::instance ()->send (handle, mb, completer, tv, act);
 271 }
 272
 273
 274 void
 275 JAWS_Asynch_IO::recv ( ACE_HANDLE handle
 276                      , ACE_Message_Block *mb
 277                      , JAWS_Event_Completer *completer
 278                      , const ACE_Time_Value &tv
 279                      , void *act
 280                      )
 281 {
 282   JAWS_Reactive_IO::instance ()->recv (handle, mb, completer, tv, act);
 283 }
 284
 285
 286 void
 287 JAWS_Asynch_IO::transmit ( ACE_HANDLE handle
 288                          , ACE_HANDLE source
 289                          , JAWS_Event_Completer *completer
 290                          , const ACE_Time_Value &tv
 291                          , void *act
 292                          , ACE_Message_Block *header
 293                          , ACE_Message_Block *trailer
 294                          )
 295 {
 296   JAWS_Reactive_IO::instance ()->transmit ( handle
 297                                           , source
 298                                           , completer
 299                                           , tv
 300                                           , act
 301                                           , header
 302                                           , trailer
 303                                           );
 304 }
 305