Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_Sig_Adapter Class Reference

Provide an adapter that transforms various types of signal handlers into the scheme used by the ACE_Reactor. More...

#include <Sig_Adapter.h>

Inheritance diagram for ACE_Sig_Adapter:

Inheritance graph
[legend]
Collaboration diagram for ACE_Sig_Adapter:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_Sig_Adapter (ACE_Sig_Action &, int sigkey)
 ACE_Sig_Adapter (ACE_Event_Handler *, int sigkey)
 ACE_Sig_Adapter (ACE_Sig_Handler_Ex, int sigkey=0)
 ~ACE_Sig_Adapter (void)
int sigkey (void)
virtual int handle_signal (int, siginfo_t *, ucontext_t *)
 Called by the to dispatch the signal handler.


Private Types

enum  { ACE_HANDLER, SIG_ACTION, C_FUNCTION }
 Is this an external handler or an ACE handler? More...


Private Attributes

int sigkey_
 Key for this signal handler (used to remove it).

enum ACE_Sig_Adapter:: { ... }  type_
 Is this an external handler or an ACE handler?

ACE_Sig_Action sa_
 This is an external handler (ugh).

ACE_Event_Handler * eh_
 This is an ACE hander.

ACE_Sig_Handler_Ex sig_func_
 This is a normal C function.

Detailed Description

Provide an adapter that transforms various types of signal handlers into the scheme used by the ACE_Reactor.

Definition at line 35 of file Sig_Adapter.h.

Member Enumeration Documentation

anonymous enum [private]
 

Is this an external handler or an ACE handler?

Enumeration values:
ACE_HANDLER  We're just wrapping an ACE_Event_Handler.
SIG_ACTION  An ACE_Sig_Action.
C_FUNCTION  A normal C function.

Definition at line 55 of file Sig_Adapter.h. 

00056   {
00057     /// We're just wrapping an ACE_Event_Handler.
00058     ACE_HANDLER,
00059     /// An ACE_Sig_Action.
00060     SIG_ACTION,
00061     /// A normal C function.
00062     C_FUNCTION
00063   } type_;

Constructor & Destructor Documentation

ACE_Sig_Adapter::ACE_Sig_Adapter (  ACE_Sig_Action &  ,
int  sigkey
) 
 

Definition at line 8 of file Sig_Adapter.cpp. 

00009   : sigkey_ (sigkey),
00010     type_ (SIG_ACTION),
00011     sa_ (sa)
00012 {
00013   // ACE_TRACE ("ACE_Sig_Adapter::ACE_Sig_Adapter");
00014 }

ACE_Sig_Adapter::ACE_Sig_Adapter (  ACE_Event_Handler *  ,
int  sigkey
) 
 

Definition at line 16 of file Sig_Adapter.cpp. 

00018   : sigkey_ (sigkey),
00019     type_ (ACE_HANDLER),
00020     eh_ (eh)
00021 {
00022   // ACE_TRACE ("ACE_Sig_Adapter::ACE_Sig_Adapter");
00023 }

ACE_Sig_Adapter::ACE_Sig_Adapter (  ACE_Sig_Handler_Ex  ,
int  sigkey = 0
) 
 

Definition at line 25 of file Sig_Adapter.cpp.

References ACE_Sig_Handler_Ex. 

00027   : sigkey_ (sigkey),
00028     type_ (C_FUNCTION),
00029     sig_func_ (sig_func)
00030 {
00031   // ACE_TRACE ("ACE_Sig_Adapter::ACE_Sig_Adapter");
00032 }

ACE_Sig_Adapter::~ACE_Sig_Adapter (  void   ) 
 

Definition at line 34 of file Sig_Adapter.cpp. 

00035 {
00036 }

Member Function Documentation

int ACE_Sig_Adapter::handle_signal (  int  ,
siginfo_t *  ,
ucontext_t * 
)  [virtual]
 

Called by the to dispatch the signal handler.

Reimplemented from ACE_Event_Handler.

Definition at line 46 of file Sig_Adapter.cpp.

References ACE_HANDLER, ACE_Sig_Handler_Ex, ACE_TRACE, C_FUNCTION, ACE_Event_Handler::handle_signal(), ACE_Sig_Action::register_action(), SIG_ACTION, sig_func_, and ucontext_t. 

00049 {
00050   ACE_TRACE ("ACE_Sig_Adapter::handle_signal");
00051 
00052   switch (this->type_)
00053     {
00054     case SIG_ACTION:
00055       {
00056         // We have to dispatch a handler that was registered by a
00057         // third-party library.
00058 
00059         ACE_Sig_Action old_disp;
00060 
00061         // Make sure this handler executes in the context it was
00062         // expecting...
00063         this->sa_.register_action (signum, &old_disp);
00064 
00065         ACE_Sig_Handler_Ex sig_func = ACE_Sig_Handler_Ex (this->sa_.handler ());
00066 
00067         (*sig_func) (signum, siginfo, ucontext);
00068         // Restore the original disposition.
00069         old_disp.register_action (signum);
00070         break;
00071       }
00072     case ACE_HANDLER:
00073       this->eh_->handle_signal (signum, siginfo, ucontext);
00074       break;
00075     case C_FUNCTION:
00076       (*this->sig_func_) (signum, siginfo, ucontext);
00077       break;
00078     }
00079   return 0;
00080 }

int ACE_Sig_Adapter::sigkey (  void   ) 
 

Returns this signal key that's used to remove this from the ACE_Reactor's internal table.

Definition at line 39 of file Sig_Adapter.cpp.

References ACE_TRACE, and sigkey_.

Referenced by ACE_Sig_Handlers::register_handler(), and ACE_Sig_Handlers::remove_handler(). 

00040 {
00041   ACE_TRACE ("ACE_Sig_Adapter::sigkey");
00042   return this->sigkey_;
00043 }

Member Data Documentation

ACE_Event_Handler* ACE_Sig_Adapter::eh_ [private]
 

This is an ACE hander.

Definition at line 71 of file Sig_Adapter.h.

ACE_Sig_Action ACE_Sig_Adapter::sa_ [private]
 

This is an external handler (ugh).

Definition at line 68 of file Sig_Adapter.h.

ACE_Sig_Handler_Ex ACE_Sig_Adapter::sig_func_ [private]
 

This is a normal C function.

Definition at line 74 of file Sig_Adapter.h.

Referenced by handle_signal().

int ACE_Sig_Adapter::sigkey_ [private]
 

Key for this signal handler (used to remove it).

Definition at line 52 of file Sig_Adapter.h.

Referenced by sigkey().

enum { ... } ACE_Sig_Adapter::type_ [private]
 

Is this an external handler or an ACE handler?

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 12:57:32 2008 for ACE by doxygen 1.3.6