diff options
Diffstat (limited to 'ACE/apps/JAWS2/JAWS/IO_Handler.h')
-rw-r--r-- | ACE/apps/JAWS2/JAWS/IO_Handler.h | 318 |
1 files changed, 318 insertions, 0 deletions
diff --git a/ACE/apps/JAWS2/JAWS/IO_Handler.h b/ACE/apps/JAWS2/JAWS/IO_Handler.h new file mode 100644 index 00000000000..6b67fdbaa12 --- /dev/null +++ b/ACE/apps/JAWS2/JAWS/IO_Handler.h @@ -0,0 +1,318 @@ +/* -*- c++ -*- */ +// Hey, Emacs! This is a C++ file! +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// jaws +// +// = FILENAME +// IO.h +// +// = AUTHOR +// James Hu +// +// ============================================================================ + +#ifndef JAWS_IO_HANDLER_H +#define JAWS_IO_HANDLER_H + +#include "ace/Asynch_IO.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "ace/Singleton.h" +#include "ace/Synch_Traits.h" +#include "ace/RW_Thread_Mutex.h" + +#include "JAWS/Export.h" + +// #include "JAWS/IO.h" +class JAWS_IO; +class JAWS_Synch_IO; +class JAWS_Asynch_IO; +class JAWS_IO_Handler; +class JAWS_IO_Handler_Factory; +class JAWS_Data_Block; +class JAWS_Pipeline_Handler; +class JAWS_Waiter; + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL +class ACE_Message_Block; +ACE_END_VERSIONED_NAMESPACE_DECL + +class JAWS_Export JAWS_Abstract_IO_Handler + // = TITLE + // + // This class defines the abstract interface for an I/O handler + // class in the context of Web-likes servers + // + // = DESCRIPTION +{ +public: + virtual ~JAWS_Abstract_IO_Handler (void); + + virtual void task (JAWS_Pipeline_Handler *ph) = 0; + virtual JAWS_Pipeline_Handler *task (void) = 0; + + virtual void message_block (JAWS_Data_Block *mb) = 0; + virtual JAWS_Data_Block *message_block (void) = 0; + + virtual void accept_complete (ACE_HANDLE handle) = 0; + // This method is called by the IO class when new passive connection has + // been established. + + virtual void accept_error (void) = 0; + // This method is called by the IO class when new passive connection has + // been established. + +#if 0 + virtual void connect_complete (ACE_Message_Block *) = 0; + // This method is called by the IO class when new active connection has + // been established. + + virtual void connect_error (ACE_Message_Block *) = 0; + // This method is called by the IO class when new active connection has + // been established. +#endif + + virtual void read_complete (ACE_Message_Block *data) = 0; + // This method is called by the IO class when new client data shows + // up. + + virtual void read_error (void) = 0; + // This method is called by the IO class when there was an error in + // reading new data from the client. + + virtual void transmit_file_complete (void) = 0; + // This method is called by the IO class when the requested file has + // been successfully transmitted to the client. + + virtual void transmit_file_error (int result) = 0; + // This method is called by the IO class when there was an error in + // transmitting the requested file to the client. + + virtual void receive_file_complete (void) = 0; + // This method is called by the IO class when the requested file has + // been successfully received from the client. + + virtual void receive_file_error (int result) = 0; + // This method is called by the IO class when there was an error in + // receiving the requested file from the client. + + virtual void write_error (void) = 0; + // This method is called by the IO class when there was an error in + // writing data to the client. + + virtual void confirmation_message_complete (void) = 0; + // This method is called by the IO class when the confirmation + // message has been delivered to the client. + + virtual void error_message_complete (void) = 0; + // This method is called by the IO class when the error message has + // been delivered to the client. + + virtual JAWS_IO_Handler_Factory *factory (void) = 0; + // Returns the factory for this IO handler + + virtual ACE_HANDLE handle (void) const = 0; + // Returns the socket handle for this handler + + virtual void done (void) = 0; + // Cleans up the handler. + + virtual int status (void) = 0; + // Returns the status of the handler + + virtual void idle (void) = 0; + // puts handler in an idle state + + enum { IDLE = 0, IDLE_A = 1, + ACCEPT_OK = 2, ACCEPT_OK_A = 3, + ACCEPT_ERROR = 4, ACCEPT_ERROR_A = 5, + READ_OK = 6, READ_OK_A = 7, + READ_ERROR = 8, READ_ERROR_A = 9, + WRITE_OK = 10, WRITE_OK_A = 11, + WRITE_ERROR = 12, WRITE_ERROR_A = 13, + TRANSMIT_OK = 14, TRANSMIT_OK_A = 15, + TRANSMIT_ERROR = 16, TRANSMIT_ERROR_A = 17, + RECEIVE_OK = 18, RECEIVE_OK_A = 19, + RECEIVE_ERROR = 20, RECEIVE_ERROR_A = 21 }; + // The different states of the handler + +}; + +#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined(ACE_HAS_AIO_CALLS) + +// Forward reference. +class JAWS_Asynch_IO_Handler; + +class JAWS_Export JAWS_Asynch_Handler : public ACE_Service_Handler +{ +public: + JAWS_Asynch_Handler (void); + virtual ~JAWS_Asynch_Handler (void); + + virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result + &result); + // This method will be called when an asynchronous read completes on + // a stream. + + virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result + &result); + // This method will be called when an asynchronous write completes + // on a stream. + + virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result + &result); + // This method will be called when an asynchronous transmit file + // completes. + + virtual void handle_accept (const ACE_Asynch_Accept::Result &result); + // This method will be called when an asynchronous accept completes. + + virtual void handler (JAWS_Asynch_IO_Handler *ioh); + virtual JAWS_Asynch_IO_Handler * handler (void); + + virtual void dispatch_handler (void); + + virtual void open (ACE_HANDLE h, ACE_Message_Block &mb); + // Call back entry point for ACE_Asynch_Acceptor + + virtual void act (const void *act_ref); + // Receives the ACT. + + //virtual ACE_HANDLE handle (void) const; + +private: + JAWS_Asynch_IO_Handler *ioh_; +}; +#endif /* defined(ACE_HAS_WIN32_OVERLAPPED_IO) || defined(ACE_HAS_AIO_CALLS) */ + + +class JAWS_Export JAWS_IO_Handler : public JAWS_Abstract_IO_Handler +{ +public: + JAWS_IO_Handler (JAWS_IO_Handler_Factory *factory); + virtual ~JAWS_IO_Handler (void); + + // Inherited from JAWS_IO_Handler + + virtual void accept_complete (ACE_HANDLE handle); + virtual void accept_error (void); + virtual void read_complete (ACE_Message_Block *data); + virtual void read_error (void); + virtual void transmit_file_complete (void); + virtual void transmit_file_error (int result); + virtual void receive_file_complete (void); + virtual void receive_file_error (int result); + virtual void write_error (void); + virtual void confirmation_message_complete (void); + virtual void error_message_complete (void); + + virtual JAWS_IO_Handler_Factory *factory (void); + virtual ACE_HANDLE handle (void) const; + + virtual void done (void); + virtual int status (void); + virtual void idle (void); + + virtual void acquire (void); + virtual void lock (void); + virtual void release (void); + + virtual void task (JAWS_Pipeline_Handler *ph); + virtual JAWS_Pipeline_Handler *task (void); + + virtual void message_block (JAWS_Data_Block *mb); + virtual JAWS_Data_Block *message_block (void); + +protected: + int status_; + // The state of the handler. + + JAWS_Data_Block *mb_; + // This maintains the state of the request. + + ACE_HANDLE handle_; + // The socket handle returned from accept. + + JAWS_Pipeline_Handler *task_; + // This is a reference to the next stage of the pipeline when the IO + // request completes. + + JAWS_IO_Handler_Factory *factory_; + // The reference to the handler's factory. +}; + +class JAWS_Export JAWS_IO_Handler_Factory +{ +public: + virtual ~JAWS_IO_Handler_Factory (void); + // Destructor + + virtual JAWS_IO_Handler *create_io_handler (void); + // This creates a new JAWS_IO_Handler + + virtual void destroy_io_handler (JAWS_IO_Handler *handler); + // This deletes a JAWS_IO_Handler +}; + +typedef JAWS_IO_Handler JAWS_Synch_IO_Handler; +typedef JAWS_IO_Handler_Factory JAWS_Synch_IO_Handler_Factory; + +typedef ACE_Singleton<JAWS_Synch_IO_Handler_Factory, ACE_SYNCH_MUTEX> + JAWS_Synch_IO_Handler_Factory_Singleton; + +#if defined(ACE_HAS_WIN32_OVERLAPPED_IO) || defined(ACE_HAS_AIO_CALLS) + +class JAWS_Export JAWS_Asynch_IO_Handler_Factory : public JAWS_IO_Handler_Factory +{ +public: + virtual ~JAWS_Asynch_IO_Handler_Factory (void); + // Destructor + + virtual JAWS_IO_Handler *create_io_handler (void); + // This creates a new JAWS_IO_Handler + + virtual void destroy_io_handler (JAWS_IO_Handler *handler); + // This deletes a JAWS_IO_Handler +}; + +class JAWS_Export JAWS_Asynch_IO_Handler : public JAWS_IO_Handler +{ +friend class JAWS_Asynch_Handler; +friend class JAWS_Asynch_IO_Handler_Factory; +friend class JAWS_Waiter; + + // Provide implementations for the common functions. +public: + explicit JAWS_Asynch_IO_Handler (JAWS_Asynch_IO_Handler_Factory *factory); + virtual ~JAWS_Asynch_IO_Handler (void); + + virtual ACE_Handler *handler (void); + + virtual void acquire (void); + virtual void lock (void); + virtual void release (void); + +protected: + + JAWS_Asynch_Handler *handler_; + ACE_SYNCH_RW_MUTEX count_; +}; + +#else + +typedef JAWS_IO_Handler JAWS_Asynch_IO_Handler; +typedef JAWS_IO_Handler_Factory JAWS_Asynch_IO_Handler_Factory; + +#endif /* defined(ACE_HAS_WIN32_OVERLAPPED_IO) || defined(ACE_HAS_AIO_CALLS) */ + +typedef ACE_Singleton<JAWS_Asynch_IO_Handler_Factory, ACE_SYNCH_MUTEX> + JAWS_Asynch_IO_Handler_Factory_Singleton; + +#endif /* JAWS_IO_HANDLER_H */ |