Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

Signal.i

Go to the documentation of this file.
00001 /* -*- C++ -*- */
00002 // $Id: Signal.i,v 1.1.1.3 2001/12/04 14:33:09 chad Exp $
00003 
00004 ACE_INLINE
00005 ACE_Sig_Set::ACE_Sig_Set (sigset_t *ss)
00006   // : sigset_ ()
00007 {
00008   ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set");
00009 
00010   if (ss == 0)
00011     ACE_OS::sigfillset (&this->sigset_);
00012   else
00013     // Structure assignment.
00014     this->sigset_ = *ss;
00015 }
00016 
00017 ACE_INLINE
00018 ACE_Sig_Set::ACE_Sig_Set (int fill)
00019   // : sigset_ ()
00020 {
00021   ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set");
00022 
00023   if (fill)
00024     ACE_OS::sigfillset (&this->sigset_);
00025   else
00026     ACE_OS::sigemptyset (&this->sigset_);
00027 }
00028 
00029 ACE_INLINE
00030 ACE_Sig_Set::ACE_Sig_Set (ACE_Sig_Set *ss)
00031   // : sigset_ ()
00032 {
00033   ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set");
00034 
00035   if (ss == 0)
00036     ACE_OS::sigfillset (&this->sigset_);
00037   else
00038     this->sigset_ = ss->sigset_;
00039 }
00040 
00041 ACE_INLINE
00042 ACE_Sig_Set::~ACE_Sig_Set (void)
00043 {
00044   ACE_TRACE ("ACE_Sig_Set::~ACE_Sig_Set");
00045   ACE_OS::sigemptyset (&this->sigset_);
00046 }
00047 
00048 ACE_INLINE int
00049 ACE_Sig_Set::empty_set (void)
00050 {
00051   ACE_TRACE ("ACE_Sig_Set::empty_set");
00052   return ACE_OS::sigemptyset (&this->sigset_);
00053 }
00054 
00055 ACE_INLINE int
00056 ACE_Sig_Set::fill_set (void)
00057 {
00058   ACE_TRACE ("ACE_Sig_Set::fill_set");
00059   return ACE_OS::sigfillset (&this->sigset_);
00060 }
00061 
00062 ACE_INLINE int
00063 ACE_Sig_Set::sig_add (int signo)
00064 {
00065   ACE_TRACE ("ACE_Sig_Set::sig_add");
00066   return ACE_OS::sigaddset (&this->sigset_, signo);
00067 }
00068 
00069 ACE_INLINE int
00070 ACE_Sig_Set::sig_del (int signo)
00071 {
00072   ACE_TRACE ("ACE_Sig_Set::sig_del");
00073   return ACE_OS::sigdelset (&this->sigset_, signo);
00074 }
00075 
00076 ACE_INLINE int
00077 ACE_Sig_Set::is_member (int signo) const
00078 {
00079   ACE_TRACE ("ACE_Sig_Set::is_member");
00080   return ACE_OS::sigismember (ACE_const_cast (sigset_t *, &this->sigset_), signo);
00081 }
00082 
00083 ACE_INLINE
00084 ACE_Sig_Set::operator sigset_t *(void)
00085 {
00086   ACE_TRACE ("ACE_Sig_Set::operator sigset_t *");
00087   return &this->sigset_;
00088 }
00089 
00090 ACE_INLINE sigset_t
00091 ACE_Sig_Set::sigset (void) const
00092 {
00093   ACE_TRACE ("ACE_Sig_Set::sigset");
00094   return this->sigset_;
00095 }
00096 
00097 ACE_INLINE
00098 ACE_Sig_Action::~ACE_Sig_Action (void)
00099 {
00100   ACE_TRACE ("ACE_Sig_Action::~ACE_Sig_Action");
00101 }
00102 
00103 ACE_INLINE int
00104 ACE_Sig_Action::flags (void)
00105 {
00106   ACE_TRACE ("ACE_Sig_Action::flags");
00107   return this->sa_.sa_flags;
00108 }
00109 
00110 ACE_INLINE void
00111 ACE_Sig_Action::flags (int flags)
00112 {
00113   ACE_TRACE ("ACE_Sig_Action::flags");
00114   this->sa_.sa_flags = flags;
00115 }
00116 
00117 ACE_INLINE sigset_t *
00118 ACE_Sig_Action::mask (void)
00119 {
00120   ACE_TRACE ("ACE_Sig_Action::mask");
00121   return &this->sa_.sa_mask;
00122 }
00123 
00124 ACE_INLINE void
00125 ACE_Sig_Action::mask (sigset_t *ss)
00126 {
00127   ACE_TRACE ("ACE_Sig_Action::mask");
00128   if (ss != 0)
00129     this->sa_.sa_mask = *ss; // Structure assignment
00130 }
00131 
00132 ACE_INLINE void
00133 ACE_Sig_Action::mask (ACE_Sig_Set &ss)
00134 {
00135   ACE_TRACE ("ACE_Sig_Action::mask");
00136   this->sa_.sa_mask = ss.sigset (); // Structure assignment
00137 }
00138 
00139 ACE_INLINE ACE_SignalHandler
00140 ACE_Sig_Action::handler (void)
00141 {
00142   ACE_TRACE ("ACE_Sig_Action::handler");
00143   return ACE_SignalHandler (this->sa_.sa_handler);
00144 }
00145 
00146 ACE_INLINE void
00147 ACE_Sig_Action::handler (ACE_SignalHandler handler)
00148 {
00149   ACE_TRACE ("ACE_Sig_Action::handler");
00150 #if !defined(ACE_HAS_TANDEM_SIGNALS)
00151   this->sa_.sa_handler = ACE_SignalHandlerV (handler);
00152 #else
00153   this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (handler);
00154 #endif /* !ACE_HAS_TANDEM_SIGNALS */
00155 }
00156 
00157 #if 0
00158 ACE_INLINE ACE_SignalHandler
00159 ACE_Sig_Action::sigaction (void)
00160 {
00161   ACE_TRACE ("ACE_Sig_Action::sigaction");
00162   return ACE_SignalHandler (this->sa_.sa_sigaction);
00163 }
00164 
00165 ACE_INLINE void
00166 ACE_Sig_Action::sigaction (ACE_SignalHandler handler)
00167 {
00168   ACE_TRACE ("ACE_Sig_Action::sigaction");
00169   this->sa_.sa_sigaction = (void (*)()) ACE_SignalHandlerV (handler);
00170 }
00171 #endif /* 0 */
00172 
00173 ACE_INLINE void
00174 ACE_Sig_Action::set (struct sigaction *sa)
00175 {
00176   ACE_TRACE ("ACE_Sig_Action::set");
00177   this->sa_ = *sa; // Structure assignment.
00178 }
00179 
00180 ACE_INLINE struct sigaction *
00181 ACE_Sig_Action::get (void)
00182 {
00183   ACE_TRACE ("ACE_Sig_Action::get");
00184   return &this->sa_;
00185 }
00186 
00187 ACE_INLINE
00188 ACE_Sig_Action::operator ACE_SIGACTION * ()
00189 {
00190   ACE_TRACE ("ACE_Sig_Action::operator ACE_SIGACTION *");
00191   return &this->sa_;
00192 }
00193 
00194 ACE_INLINE
00195 ACE_Sig_Action::ACE_Sig_Action (const ACE_Sig_Action &s)
00196   // : sa_ ()
00197 {
00198   ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action");
00199   *this = s; // structure copy.
00200 }
00201 
00202 ACE_INLINE int
00203 ACE_Sig_Action::register_action (int signum, ACE_Sig_Action *oaction)
00204 {
00205   ACE_TRACE ("ACE_Sig_Action::register_action");
00206   struct sigaction *sa = oaction == 0 ? 0 : oaction->get ();
00207 
00208   return ACE_OS::sigaction (signum, &this->sa_, sa);
00209 }
00210 
00211 ACE_INLINE int
00212 ACE_Sig_Action::retrieve_action (int signum)
00213 {
00214   ACE_TRACE ("ACE_Sig_Action::retrieve_action");
00215   return ACE_OS::sigaction (signum, 0, &this->sa_);
00216 }
00217 
00218 ACE_INLINE int
00219 ACE_Sig_Action::restore_action (int signum, ACE_Sig_Action &oaction)
00220 {
00221   ACE_TRACE ("ACE_Sig_Action::restore_action");
00222   this->sa_ = *oaction.get (); // Structure assignment
00223   return ACE_OS::sigaction (signum, &this->sa_, 0);
00224 }
00225 
00226 // Block out the signal MASK until the destructor is called.
00227 
00228 ACE_INLINE
00229 ACE_Sig_Guard::ACE_Sig_Guard (ACE_Sig_Set *mask)
00230   : omask_ ()
00231 {
00232   //ACE_TRACE ("ACE_Sig_Guard::ACE_Sig_Guard");
00233 
00234 #if defined (ACE_LACKS_UNIX_SIGNALS)
00235   ACE_UNUSED_ARG (mask);
00236 #else
00237   // If MASK is 0 then block all signals!
00238   if (mask == 0)
00239     {
00240 #  if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK)
00241       ACE_OS::sigprocmask (SIG_BLOCK,
00242                            ACE_OS_Object_Manager::default_mask (),
00243                            (sigset_t *) this->omask_);
00244 #  else
00245       ACE_OS::thr_sigsetmask (SIG_BLOCK,
00246                               ACE_OS_Object_Manager::default_mask (),
00247                               (sigset_t *) this->omask_);
00248 #  endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */
00249     }
00250   else
00251 #  if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK)
00252     ACE_OS::sigprocmask (SIG_BLOCK,
00253                          (sigset_t *) *mask,
00254                          (sigset_t *)
00255                          this->omask_);
00256 #  else
00257     ACE_OS::thr_sigsetmask (SIG_BLOCK,
00258                             (sigset_t *) *mask,
00259                             (sigset_t *)
00260                             this->omask_);
00261 #  endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */
00262 #endif /* ACE_LACKS_UNIX_SIGNALS */
00263 }
00264 
00265 // Restore the signal mask.
00266 
00267 ACE_INLINE
00268 ACE_Sig_Guard::~ACE_Sig_Guard (void)
00269 {
00270   //ACE_TRACE ("ACE_Sig_Guard::~ACE_Sig_Guard");
00271 #if !defined (ACE_LACKS_UNIX_SIGNALS)
00272 #if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK)
00273   ACE_OS::sigprocmask (SIG_SETMASK,
00274                        (sigset_t *) this->omask_,
00275                        0);
00276 #else
00277   ACE_OS::thr_sigsetmask (SIG_SETMASK,
00278                           (sigset_t *) this->omask_,
00279                           0);
00280 #endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */
00281 #endif /* !ACE_LACKS_UNIX_SIGNALS */
00282 }
00283 
00284 #if defined (ACE_HAS_WINCE)
00285 ACE_INLINE
00286 ACE_Sig_Handler::ACE_Sig_Handler (void)
00287 {
00288 }
00289 
00290 ACE_INLINE
00291 ACE_Sig_Handler::~ACE_Sig_Handler (void)
00292 {
00293 }
00294 #endif /* ACE_HAS_WINCE */
00295 
00296 ACE_INLINE int
00297 ACE_Sig_Handler::in_range (int signum)
00298 {
00299   ACE_TRACE ("ACE_Sig_Handler::in_range");
00300   return signum > 0 && signum < ACE_NSIG;
00301 }
00302 
00303 ACE_INLINE
00304 ACE_Sig_Adapter::~ACE_Sig_Adapter (void)
00305 {
00306 }

Generated on Mon Jun 16 11:21:15 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002