ACE/apps/JAWS2/JAWS/Jaws_IO.h

   1 /* -*- c++ -*- */
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Jaws_IO.h
   6  *
   7  *  @author James Hu
   8  */
   9 //=============================================================================
  10
  11
  12 #ifndef JAWS_IO_H
  13 #define JAWS_IO_H
  14
  15 #include "ace/ACE.h"
  16
  17 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  18 # pragma once
  19 #endif /* ACE_LACKS_PRAGMA_ONCE */
  20
  21 #include "ace/Asynch_IO.h"
  22 #include "ace/SOCK_Stream.h"
  23 #include "ace/Singleton.h"
  24 #include "ace/Synch_Traits.h"
  25
  26 #include "JAWS/Export.h"
  27
  28 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  29 class ACE_Message_Block;
  30 ACE_END_VERSIONED_NAMESPACE_DECL
  31
  32 class JAWS_IO_Handler;
  33 class JAWS_IO_Acceptor;
  34
  35 /**
  36  * @class JAWS_IO
  37  *
  38  * @brief This class defines the abstract interface for an I/O class in
  39  * the context of Web-likes servers
  40  *
  41  * An I/O class should have the following interface. Derived
  42  * classes will define the exactly how the I/O will take place
  43  * (Asynchronous, Synchronous, Reactive)
  44  */
  45 class JAWS_Export JAWS_IO
  46 {
  47 public:
  48   JAWS_IO (void);
  49   virtual ~JAWS_IO (void);
  50
  51   //  void acceptor (JAWS_IO_Acceptor *acceptor);
  52   //  void handler (JAWS_IO_Handler *handler);
  53   //  void handle (ACE_HANDLE h);
  54   //  ACE_HANDLE handle (void);
  55
  56   // James, please add documentation here.
  57
  58   /// accept a passive connection
  59   virtual void accept (JAWS_IO_Handler *ioh,
  60                        ACE_Message_Block *mb = 0,
  61                        unsigned int size = 0) = 0;
  62
  63   /// read from the handle size bytes into the message block.
  64   virtual void read (JAWS_IO_Handler *ioh,
  65                      ACE_Message_Block *mb,
  66                      unsigned int size) = 0;
  67
  68   /// send header, filename, trailer to the handle.
  69   virtual void transmit_file (JAWS_IO_Handler *ioh,
  70                               ACE_HANDLE file,
  71                               const char *header,
  72                               unsigned int header_size,
  73                               const char *trailer,
  74                               unsigned int trailer_size) = 0;
  75
  76   /// send header, filename, trailer to the handle.
  77   virtual void transmit_file (JAWS_IO_Handler *ioh,
  78                               const char *filename,
  79                               const char *header,
  80                               unsigned int header_size,
  81                               const char *trailer,
  82                               unsigned int trailer_size) = 0;
  83
  84   /// read data from the handle and store in filename.
  85   virtual void receive_file (JAWS_IO_Handler *ioh,
  86                              const char *filename,
  87                              void *initial_data,
  88                              unsigned int initial_data_length,
  89                              unsigned int entire_length) = 0;
  90
  91   /// send a confirmation message to the handle.
  92   virtual void send_confirmation_message (JAWS_IO_Handler *ioh,
  93                                           const char *buffer,
  94                                           unsigned int length) = 0;
  95
  96   /// send an error message to the handle.
  97   virtual void send_error_message (JAWS_IO_Handler *ioh,
  98                                    const char *buffer,
  99                                    unsigned int length) = 0;
 100
 101 protected:
 102   ACE_HANDLE handle_;
 103   JAWS_IO_Handler *handler_;
 104   ACE_INET_Addr *inet_addr_;
 105   JAWS_IO_Acceptor *acceptor_;
 106 };
 107
 108 /**
 109  * @class JAWS_Synch_IO
 110  *
 111  * @brief This class defines the interface for a Synchronous I/O class.
 112  */
 113 class JAWS_Export JAWS_Synch_IO : public JAWS_IO
 114 {
 115 public:
 116   JAWS_Synch_IO (void);
 117
 118   virtual ~JAWS_Synch_IO (void);
 119
 120   virtual void accept (JAWS_IO_Handler *ioh,
 121                        ACE_Message_Block *mb = 0,
 122                        unsigned int size = 0);
 123
 124   virtual void read (JAWS_IO_Handler *ioh,
 125                      ACE_Message_Block *mb,
 126                      unsigned int size);
 127
 128   virtual void transmit_file (JAWS_IO_Handler *ioh,
 129                               ACE_HANDLE handle,
 130                               const char *header,
 131                               unsigned int header_size,
 132                               const char *trailer,
 133                               unsigned int trailer_size);
 134
 135   virtual void transmit_file (JAWS_IO_Handler *ioh,
 136                               const char *filename,
 137                               const char *header,
 138                               unsigned int header_size,
 139                               const char *trailer,
 140                               unsigned int trailer_size);
 141
 142   virtual void receive_file (JAWS_IO_Handler *ioh,
 143                              const char *filename,
 144                              void *initial_data,
 145                              unsigned int initial_data_length,
 146                              unsigned int entire_length);
 147
 148   virtual void send_confirmation_message (JAWS_IO_Handler *ioh,
 149                                           const char *buffer,
 150                                           unsigned int length);
 151
 152   virtual void send_error_message (JAWS_IO_Handler *ioh,
 153                                    const char *buffer,
 154                                    unsigned int length);
 155
 156 protected:
 157   virtual void send_message (JAWS_IO_Handler *ioh,
 158                              const char *buffer,
 159                              unsigned int length);
 160 };
 161
 162 typedef ACE_Singleton<JAWS_Synch_IO, ACE_SYNCH_MUTEX>
 163         JAWS_Synch_IO_Singleton;
 164
 165 // This only works on asynch I/O-capable systems.
 166 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
 167
 168 /**
 169  * @class JAWS_Asynch_IO
 170  *
 171  * @brief This class defines the interface for a Asynchronous I/O class.
 172  */
 173 class JAWS_Export JAWS_Asynch_IO : public JAWS_IO
 174 {
 175 public:
 176   JAWS_Asynch_IO (void);
 177
 178   virtual ~JAWS_Asynch_IO (void);
 179
 180   virtual void accept (JAWS_IO_Handler *ioh,
 181                        ACE_Message_Block *mb = 0,
 182                        unsigned int size = 0);
 183
 184   virtual void read (JAWS_IO_Handler *ioh,
 185                      ACE_Message_Block *mb,
 186                      unsigned int size);
 187
 188   virtual void transmit_file (JAWS_IO_Handler *ioh,
 189                               ACE_HANDLE handle,
 190                               const char *header,
 191                               unsigned int header_size,
 192                               const char *trailer,
 193                               unsigned int trailer_size);
 194
 195   virtual void transmit_file (JAWS_IO_Handler *ioh,
 196                               const char *filename,
 197                               const char *header,
 198                               unsigned int header_size,
 199                               const char *trailer,
 200                               unsigned int trailer_size);
 201
 202   virtual void receive_file (JAWS_IO_Handler *ioh,
 203                              const char *filename,
 204                              void *initial_data,
 205                              unsigned int initial_data_length,
 206                              unsigned int entire_length);
 207
 208   virtual void send_confirmation_message (JAWS_IO_Handler *ioh,
 209                                           const char *buffer,
 210                                           unsigned int length);
 211
 212   virtual void send_error_message (JAWS_IO_Handler *ioh,
 213                                    const char *buffer,
 214                                    unsigned int length);
 215
 216 #ifdef ACE_LYNXOS_MAJOR
 217 #ifdef ERROR_MESSAGE
 218 #undef ERROR_MESSAGE
 219 #endif /* ERROR_MESSAGE */
 220 #endif /* ACE_LYNXOS_MAJOR */
 221
 222   enum Message_Types
 223   {
 224     CONFIRMATION,
 225     ERROR_MESSAGE
 226   };
 227
 228 protected:
 229
 230   virtual void send_message (JAWS_IO_Handler *ioh,
 231                              const char *buffer,
 232                              unsigned int length,
 233                              long act);
 234 };
 235
 236 typedef ACE_Singleton<JAWS_Asynch_IO, ACE_SYNCH_MUTEX>
 237         JAWS_Asynch_IO_Singleton;
 238
 239 /**
 240  * @class JAWS_Asynch2_IO
 241  This version of Asynch_IO has a do nothing accept() implementation.
 242  */
 243 class JAWS_Export JAWS_Asynch2_IO : public JAWS_Asynch_IO
 244 {
 245 public:
 246   /// does nothing
 247   virtual void accept (JAWS_IO_Handler *ioh,
 248                        ACE_Message_Block *mb = 0,
 249                        unsigned int size = 0);
 250
 251 };
 252
 253 typedef ACE_Singleton<JAWS_Asynch2_IO, ACE_SYNCH_MUTEX>
 254         JAWS_Asynch2_IO_Singleton;
 255
 256 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */
 257
 258 #endif /* JAWS_IO_H */