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
 122 JAWS_EC_AH_Adapter *
 123 JAWS_EC_AH_Adapter::make (JAWS_Event_Completer *completer)
 124 {
 125   return new JAWS_EC_AH_Adapter (completer);
 126 }
 127
 128 void
 129 JAWS_EC_AH_Adapter
 130 ::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
 131 {
 132   JAWS_Event_Result io_result;
 133
 134   io_result = this->make_io_result ( result
 135                                    , JAWS_Event_Result::JE_RECV_OK
 136                                    , JAWS_Event_Result::JE_RECV_FAIL
 137                                    );
 138   // More useful diagnostics not implemented yet.
 139
 140   void *act = const_cast<void *> (result.act ());
 141
 142   this->completer_->input_complete (io_result, act);
 143   delete this;
 144 }
 145
 146 void
 147 JAWS_EC_AH_Adapter
 148 ::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
 149 {
 150   JAWS_Event_Result io_result;
 151
 152   io_result = this->make_io_result ( result
 153                                    , JAWS_Event_Result::JE_SEND_OK
 154                                    , JAWS_Event_Result::JE_SEND_FAIL
 155                                    );
 156   // More useful diagnostics not implemented yet.
 157
 158   void *act = const_cast<void *> (result.act ());
 159
 160   this->completer_->output_complete (io_result, act);
 161   delete this;
 162 }
 163
 164 void
 165 JAWS_EC_AH_Adapter
 166 ::handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result)
 167 {
 168   JAWS_Event_Result io_result;
 169
 170   io_result = this->make_io_result ( result
 171                                    , JAWS_Event_Result::JE_TRANSMIT_OK
 172                                    , JAWS_Event_Result::JE_TRANSMIT_FAIL
 173                                    );
 174   // More useful diagnostics not implemented yet.
 175   // Watch out for files not opened in overlapped IO mode.
 176
 177   void *act = const_cast<void *> (result.act ());
 178
 179   this->completer_->output_complete (io_result, act);
 180   delete this;
 181 }
 182
 183 JAWS_Event_Result
 184 JAWS_EC_AH_Adapter
 185 ::make_io_result ( const ACE_Asynch_Result &result
 186                  , JAWS_Event_Result::JE_REASON reason_ok
 187                  , JAWS_Event_Result::JE_REASON reason_fail
 188                  )
 189 {
 190   size_t bytes = result.bytes_transferred ();
 191
 192   JAWS_Event_Result::JE_STATUS status;
 193   JAWS_Event_Result::JE_REASON reason;
 194
 195   if (result.success ())
 196     {
 197       status = JAWS_Event_Result::JE_OK;
 198       reason = reason_ok;
 199     }
 200   else
 201     {
 202       status = JAWS_Event_Result::JE_ERROR;
 203       reason = reason_fail;
 204     }
 205
 206   JAWS_Event_Result io_result (bytes, status, reason);
 207
 208   return io_result;
 209 }
 210
 211 #else /* EMULATE AIO WITH REACTOR */
 212
 213 #include "jaws3/Reactive_IO.h"
 214
 215 void
 216 JAWS_Asynch_IO::send ( ACE_HANDLE handle
 217                      , ACE_Message_Block *mb
 218                      , JAWS_Event_Completer *completer
 219                      , void *act
 220                      )
 221 {
 222   JAWS_Reactive_IO::instance ()->send (handle, mb, completer, act);
 223 }
 224
 225
 226 void
 227 JAWS_Asynch_IO::recv ( ACE_HANDLE handle
 228                      , ACE_Message_Block *mb
 229                      , JAWS_Event_Completer *completer
 230                      , void *act
 231                      )
 232 {
 233   JAWS_Reactive_IO::instance ()->recv (handle, mb, completer, act);
 234 }
 235
 236
 237 void
 238 JAWS_Asynch_IO::transmit ( ACE_HANDLE handle
 239                          , ACE_HANDLE source
 240                          , JAWS_Event_Completer *completer
 241                          , void *act
 242                          , ACE_Message_Block *header
 243                          , ACE_Message_Block *trailer
 244                          )
 245 {
 246   JAWS_Reactive_IO::instance ()->transmit ( handle
 247                                           , source
 248                                           , completer
 249                                           , act
 250                                           , header
 251                                           , trailer
 252                                           );
 253 }
 254
 255 #endif /* ACE_HAS_AIO_CALLS || ACE_HAS_WIN32_OVERLAPPED_IO */
 256
 257 // For now, we will simulate timed Asynch IO with timed Reactive IO.
 258 // In the future, we will implement the timed Asynch IO with timers
 259 // and Asynch IO cancelation.
 260
 261 #include "jaws3/Reactive_IO.h"
 262
 263 void
 264 JAWS_Asynch_IO::send ( ACE_HANDLE handle
 265                      , ACE_Message_Block *mb
 266                      , JAWS_Event_Completer *completer
 267                      , const ACE_Time_Value &tv
 268                      , void *act
 269                      )
 270 {
 271   JAWS_Reactive_IO::instance ()->send (handle, mb, completer, tv, act);
 272 }
 273
 274
 275 void
 276 JAWS_Asynch_IO::recv ( ACE_HANDLE handle
 277                      , ACE_Message_Block *mb
 278                      , JAWS_Event_Completer *completer
 279                      , const ACE_Time_Value &tv
 280                      , void *act
 281                      )
 282 {
 283   JAWS_Reactive_IO::instance ()->recv (handle, mb, completer, tv, act);
 284 }
 285
 286
 287 void
 288 JAWS_Asynch_IO::transmit ( ACE_HANDLE handle
 289                          , ACE_HANDLE source
 290                          , JAWS_Event_Completer *completer
 291                          , const ACE_Time_Value &tv
 292                          , void *act
 293                          , ACE_Message_Block *header
 294                          , ACE_Message_Block *trailer
 295                          )
 296 {
 297   JAWS_Reactive_IO::instance ()->transmit ( handle
 298                                           , source
 299                                           , completer
 300                                           , tv
 301                                           , act
 302                                           , header
 303                                           , trailer
 304                                           );
 305 }
 306