ACE: ACE_Sig_Adapter Class Reference

anonymous enum [private]

Is this an external handler or an ACE handler?

Enumerator:

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_;

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.

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 }

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

Called by the <Reactor> to dispatch the signal handler.

Reimplemented from ACE_Event_Handler.

Definition at line 46 of file Sig_Adapter.cpp.

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

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().

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

ACE_Event_Handler* ACE_Sig_Adapter::eh_ [private]

This is an ACE hander.

Definition at line 71 of file Sig_Adapter.h.

Referenced by handle_signal().

ACE_Sig_Action ACE_Sig_Adapter::sa_ [private]

This is an external handler (ugh).

Definition at line 68 of file Sig_Adapter.h.

Referenced by handle_signal().

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?

ACE_Sig_Adapter Class Reference

Public Member Functions

Private Types

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


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 <Reactor> to dispatch the signal handler.
Private Types
	ACE_HANDLER
	We're just wrapping an ACE_Event_Handler.
	SIG_ACTION
	An ACE_Sig_Action.
	C_FUNCTION
	A normal C function.
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.