ACE_event_t Class Reference

Wrapper for NT events on UNIX. More...

#include <OS_NS_Thread.h>

Collaboration diagram for ACE_event_t:

[legend]List of all members.

Protected Attributes
char *	name_
	Event name if process shared.
ACE_eventdata_t *	eventdata_
	Event data.
Friends
int	event_init (ACE_event_t *, int, int, int, const char *, void *, int)
int	event_destroy (ACE_event_t *)
int	event_wait (ACE_event_t *)
int	event_timedwait (ACE_event_t *, ACE_Time_Value *, int)
int	event_signal (ACE_event_t *)
int	event_pulse (ACE_event_t *)
int	event_reset (ACE_event_t *)

---

Detailed Description

Wrapper for NT events on UNIX.

Definition at line 1859 of file OS_NS_Thread.h.

---

Friends And Related Function Documentation

int event_destroy

(

ACE_event_t *

event

)

[friend]

Definition at line 2352 of file OS_NS_Thread.cpp.

{
#if defined (ACE_WIN32)
  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (*event), ace_result_), int, -1);
#elif defined (ACE_HAS_THREADS)
  if (event->eventdata_)
    {
      // mutex_destroy()/cond_destroy() are called in a loop if the object
      // is BUSY.  This avoids conditions where we fail to destroy these
      // objects because at time of destroy they were just being used in
      // another thread possibly causing deadlocks later on if they keep
      // being used after we're gone.

      if (event->eventdata_->type_ == USYNC_PROCESS)
        {
          if (event->name_)
            {
              // Only destroy the event data if we're the ones who initialized
              // it.

              int r1, r2;
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              // First destroy the mutex so locking after this will return
              // errors.
              while ((r1 = ACE_OS::mutex_destroy (&event->eventdata_->lock_)) == -1
                     && errno == EBUSY)
                {
                  ACE_OS::thr_yield ();
                }
# else
              r1 = ACE_OS::sema_destroy(&event->lock_);
# endif

# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              // Now fix event to manual reset, raise signal and broadcast
              // until is's possible to destroy the condition.
              event->eventdata_->manual_reset_ = 1;
              while ((r2 = ACE_OS::cond_destroy (&event->eventdata_->condition_)) == -1
                     && errno == EBUSY)
                {
                  event->eventdata_->is_signaled_ = 1;
                  ACE_OS::cond_broadcast (&event->eventdata_->condition_);
                  ACE_OS::thr_yield ();
                }
# else
              r2 = ACE_OS::sema_destroy(&event->semaphore_);
# endif
              ACE_OS::munmap (event->eventdata_,
                              sizeof (ACE_eventdata_t));
              ACE_OS::shm_unlink (ACE_TEXT_CHAR_TO_TCHAR(event->name_));
              ACE_OS::free (event->name_);
              return r1 != 0 || r2 != 0 ? -1 : 0;
            }
          else
            {
              ACE_OS::munmap (event->eventdata_,
                              sizeof (ACE_eventdata_t));
# if (!defined (ACE_HAS_PTHREADS) || !defined (_POSIX_THREAD_PROCESS_SHARED) || \
        (defined (ACE_LACKS_MUTEXATTR_PSHARED) && defined (ACE_LACKS_CONDATTR_PSHARED))) && \
     (defined (ACE_USES_FIFO_SEM) || \
        (defined (ACE_HAS_POSIX_SEM) && defined (ACE_HAS_POSIX_SEM_TIMEOUT) && defined (ACE_LACKS_NAMED_POSIX_SEM)))
              ACE_OS::sema_destroy(&event->lock_);
# endif
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              return 0;
# else
              return ACE_OS::sema_destroy(&event->semaphore_);
# endif
            }
        }
      else
        {
          int r1, r2;
          // First destroy the mutex so locking after this will return errors.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
      // first destroy the mutex so locking after this will return errors
          while ((r1 = ACE_OS::mutex_destroy (&event->eventdata_->lock_)) == -1
                 && errno == EBUSY)
            {
              ACE_OS::thr_yield ();
            }
# else
          r1 = ACE_OS::sema_destroy(&event->lock_);
# endif

# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
          // Now fix event to manual reset, raise signal and broadcast until
          // it's possible to destroy the condition.
          event->eventdata_->manual_reset_ = 1;
          while ((r2 = ACE_OS::cond_destroy (&event->eventdata_->condition_)) == -1
                 && errno == EBUSY)
            {
              event->eventdata_->is_signaled_ = 1;
              ACE_OS::cond_broadcast (&event->eventdata_->condition_);
              ACE_OS::thr_yield ();
            }
# else
          r2 = ACE_OS::sema_destroy(&event->semaphore_);
# endif
          delete event->eventdata_;
          return r1 != 0 || r2 != 0 ? -1 : 0;
        }
    }

  return 0;
#else
  ACE_UNUSED_ARG (event);
  ACE_NOTSUP_RETURN (-1);
#endif /* ACE_WIN32 */
}

int event_init	(	ACE_event_t *	,
		int	,
		int	,
		int	,
		const char *	,
		void *	,
		int
	)			[friend]

int event_pulse

(

ACE_event_t *

event

)

[friend]

Definition at line 2736 of file OS_NS_Thread.cpp.

{
#if defined (ACE_WIN32)
  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::PulseEvent (*event), ace_result_), int, -1);
#elif defined (ACE_HAS_THREADS)
  int result = 0;
  int error = 0;

  // grab the lock first
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
  if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0)
# else
  if (ACE_OS::sema_wait (&event->lock_) == 0)
# endif
  {
    if (event->eventdata_->waiting_threads_ > 0)
    {
      // Manual-reset event.
      if (event->eventdata_->manual_reset_ == 1)
      {
        // Wakeup all waiters.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
        if (ACE_OS::cond_broadcast (&event->eventdata_->condition_) != 0)
        {
          result = -1;
          error = errno;
        }
        if (result == 0)
          event->eventdata_->signal_count_ = event->eventdata_->waiting_threads_;
# else
        event->eventdata_->signal_count_ = event->eventdata_->waiting_threads_;
        for (unsigned long i=0; i<event->eventdata_->signal_count_ ;++i)
          if (ACE_OS::sema_post(&event->semaphore_) != 0)
          {
            event->eventdata_->signal_count_ = 0;
            result = -1;
            error = errno;
          }

        if (result == 0)
          while(event->eventdata_->signal_count_!=0 && event->eventdata_->waiting_threads_!=0)
            ACE_OS::thr_yield ();
# endif
      }
      // Auto-reset event: wakeup one waiter.
      else
      {
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
        if (ACE_OS::cond_signal (&event->eventdata_->condition_) != 0)
# else
        if (ACE_OS::sema_post(&event->semaphore_) != 0)
# endif
        {
          result = -1;
          error = errno;
        }

        event->eventdata_->auto_event_signaled_ = true;
      }
    }

    // Reset event.
    event->eventdata_->is_signaled_ = 0;

    // Now we can let go of the lock.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
    ACE_OS::mutex_unlock (&event->eventdata_->lock_);
# else
    ACE_OS::sema_post (&event->lock_);
# endif
    if (result == -1)
      // Reset errno in case mutex_unlock() also fails...
      errno = error;
  }
  else
    result = -1;
  return result;
#else
  ACE_UNUSED_ARG (event);
  ACE_NOTSUP_RETURN (-1);
#endif /* ACE_WIN32 */
}

int event_reset

(

ACE_event_t *

event

)

[friend]

Definition at line 2830 of file OS_NS_Thread.cpp.

{
#if defined (ACE_WIN32)
  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::ResetEvent (*event), ace_result_), int, -1);
#elif defined (ACE_HAS_THREADS)
  int result = 0;

  // Grab the lock first.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
  if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0)
# else
  if (ACE_OS::sema_wait (&event->lock_) == 0)
# endif
  {
    // Reset event.
    event->eventdata_->is_signaled_ = 0;
    event->eventdata_->auto_event_signaled_ = false;

    // Now we can let go of the lock.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
    ACE_OS::mutex_unlock (&event->eventdata_->lock_);
# else
    ACE_OS::sema_post (&event->lock_);
# endif
  }
  else
    result = -1;
  return result;
#else
  ACE_UNUSED_ARG (event);
  ACE_NOTSUP_RETURN (-1);
#endif /* ACE_WIN32 */
}

int event_signal

(

ACE_event_t *

event

)

[friend]

Definition at line 2871 of file OS_NS_Thread.cpp.

{
#if defined (ACE_WIN32)
  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetEvent (*event), ace_result_), int, -1);
#elif defined (ACE_HAS_THREADS)
  int result = 0;
  int error = 0;

  // grab the lock first
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
  if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0)
# else
  if (ACE_OS::sema_wait (&event->lock_) == 0)
# endif
  {
    // Manual-reset event.
    if (event->eventdata_->manual_reset_ == 1)
    {
      // wakeup all
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
      if (ACE_OS::cond_broadcast (&event->eventdata_->condition_) != 0)
      {
        result = -1;
        error = errno;
      }
# else
      if (ACE_OS::sema_post(&event->semaphore_) != 0)
      {
        result = -1;
        error = errno;
      }
# endif

      if (result == 0)
        // signal event
        event->eventdata_->is_signaled_ = 1;
    }
    // Auto-reset event
    else
    {
      if (event->eventdata_->waiting_threads_ == 0)
        // No waiters: signal event.
        event->eventdata_->is_signaled_ = 1;
      // Waiters: wakeup one waiter.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
      else if (ACE_OS::cond_signal (&event->eventdata_->condition_) != 0)
# else
      else if (ACE_OS::sema_post(&event->semaphore_) != 0)
# endif
      {
        result = -1;
        error = errno;
      }

      event->eventdata_->auto_event_signaled_ = true;
    }

    // Now we can let go of the lock.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
    ACE_OS::mutex_unlock (&event->eventdata_->lock_);
# else
    ACE_OS::sema_post (&event->lock_);
# endif

    if (result == -1)
      // Reset errno in case mutex_unlock() also fails...
      errno = error;
  }
  else
    result = -1;

  return result;
#else
  ACE_UNUSED_ARG (event);
  ACE_NOTSUP_RETURN (-1);
#endif /* ACE_WIN32 */
}

int event_timedwait	(	ACE_event_t *	event,
		ACE_Time_Value *	timeout,
		int	use_absolute_time = 1
	)			[friend]

Definition at line 2960 of file OS_NS_Thread.cpp.

{
  if (timeout == 0)
    // Wait indefinitely.
    return ACE_OS::event_wait (event);

#if defined (ACE_WIN32)
  DWORD result;

  if (timeout->sec () == 0 && timeout->usec () == 0)
    // Do a "poll".
    result = ::WaitForSingleObject (*event, 0);
  else
    {
      // Wait for upto <relative_time> number of milliseconds.  Note
      // that we must convert between absolute time (which is passed
      // as a parameter) and relative time (which is what
      // WaitForSingleObjects() expects).
      // <timeout> parameter is given in absolute or relative value
      // depending on parameter <use_absolute_time>.
      int msec_timeout;
      if (use_absolute_time)
        {
          // Time is given in absolute time, we should use
          // gettimeofday() to calculate relative time
          ACE_Time_Value relative_time (*timeout - ACE_OS::gettimeofday ());

          // Watchout for situations where a context switch has caused
          // the current time to be > the timeout.  Thanks to Norbert
          // Rapp <NRapp@nexus-informatics.de> for pointing this.
          if (relative_time < ACE_Time_Value::zero)
            msec_timeout = 0;
          else
            msec_timeout = relative_time.msec ();
        }
      else
        // time is given in relative time, just convert it into
        // milliseconds and use it
        msec_timeout = timeout->msec ();
      result = ::WaitForSingleObject (*event, msec_timeout);
    }

  switch (result)
    {
    case WAIT_OBJECT_0:
      return 0;
    case WAIT_TIMEOUT:
      errno = ETIME;
      return -1;
    default:
      // This is a hack, we need to find an appropriate mapping...
      ACE_OS::set_errno_to_last_error ();
      return -1;
    }
#elif defined (ACE_HAS_THREADS)
  int result = 0;
  int error = 0;

  // grab the lock first
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
  if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0)
# else
  if (ACE_OS::sema_wait (&event->lock_) == 0)
# endif
    {
      if (event->eventdata_->is_signaled_ == 1)
        // event is currently signaled
        {
          if (event->eventdata_->manual_reset_ == 0)
            {
              // AUTO: reset state
              event->eventdata_->is_signaled_ = 0;
              event->eventdata_->auto_event_signaled_ = false;
            }
        }
      else
        // event is currently not signaled
        {
          event->eventdata_->waiting_threads_++;

          ACE_Time_Value absolute_timeout = *timeout;

          // cond_timewait() expects absolute time, check
          // <use_absolute_time> flag.
          if (use_absolute_time == 0)
            absolute_timeout += ACE_OS::gettimeofday ();

          while (event->eventdata_->is_signaled_ == 0 &&
                 event->eventdata_->auto_event_signaled_ == false)
            {
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              if (ACE_OS::cond_timedwait (&event->eventdata_->condition_,
                                          &event->eventdata_->lock_,
                                          &absolute_timeout) != 0)
                {
                  result = -1;
                  error = errno;
                  break;
                }

              if (event->eventdata_->signal_count_ > 0)
                {
                  event->eventdata_->signal_count_--;
                  break;
                }
# else
#   if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED)) || \
      (!defined (ACE_USES_FIFO_SEM) && (!defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              if (ACE_OS::mutex_unlock (&event->eventdata_->lock_) != 0)
#   else
                if (ACE_OS::sema_post (&event->lock_) != 0)
#   endif
                  {
                    event->eventdata_->waiting_threads_--;
                    return -1;
                  }

              if (ACE_OS::sema_wait(&event->semaphore_, absolute_timeout) !=0)
                {
                  result = -1;
                  if (errno == ETIMEDOUT) // Semaphores time out with ETIMEDOUT (POSIX)
                    error = ETIME;
                  else
                    error = errno;
                }

              bool signalled = false;
              if (result == 0 && event->eventdata_->signal_count_ > 0)
                {
                  event->eventdata_->signal_count_--;
                  signalled = true;
                }

#   if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED)) || \
      (!defined (ACE_USES_FIFO_SEM) && (!defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              if (ACE_OS::mutex_lock (&event->eventdata_->lock_) != 0)
#   else
                if (ACE_OS::sema_wait (&event->lock_) != 0)
#   endif
                  {
                    event->eventdata_->waiting_threads_--;  // yes, I know it's not save
                    return -1;
                  }

              if (result)
                break;

              if (event->eventdata_->manual_reset_ == 1 && event->eventdata_->is_signaled_ == 1)
                if (ACE_OS::sema_post(&event->semaphore_) != 0)
                  {
                    result = -1;
                    error = errno;
                    break;
                  }

              if (signalled)
                break;
# endif
            }

          // Reset the auto_event_signaled_ to false now that we have
          // woken up.
          if (event->eventdata_->auto_event_signaled_ == true)
            event->eventdata_->auto_event_signaled_ = false;

          event->eventdata_->waiting_threads_--;
        }

      // Now we can let go of the lock.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
      ACE_OS::mutex_unlock (&event->eventdata_->lock_);
# else
      ACE_OS::sema_post (&event->lock_);
# endif

      if (result == -1)
        // Reset errno in case mutex_unlock() also fails...
        errno = error;
    }
  else
    result = -1;
  return result;
#else
  ACE_UNUSED_ARG (event);
  ACE_UNUSED_ARG (timeout);
  ACE_UNUSED_ARG (use_absolute_time);
  ACE_NOTSUP_RETURN (-1);
#endif /* ACE_WIN32 */
}

int event_wait

(

ACE_event_t *

event

)

[friend]

Definition at line 3161 of file OS_NS_Thread.cpp.

{
#if defined (ACE_WIN32)
  switch (::WaitForSingleObject (*event, INFINITE))
    {
    case WAIT_OBJECT_0:
      return 0;
    default:
      {
        ACE_OS::set_errno_to_last_error ();
        return -1;
      }
    }
#elif defined (ACE_HAS_THREADS)
  int result = 0;
  int error = 0;

  // grab the lock first
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
  if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0)
# else
  if (ACE_OS::sema_wait (&event->lock_) == 0)
# endif
    {
      if (event->eventdata_->is_signaled_ == 1)
        // Event is currently signaled.
        {
          if (event->eventdata_->manual_reset_ == 0)
            // AUTO: reset state
            event->eventdata_->is_signaled_ = 0;
        }
      else // event is currently not signaled
        {
          event->eventdata_->waiting_threads_++;

          while (event->eventdata_->is_signaled_ == 0 &&
                 event->eventdata_->auto_event_signaled_ == false)
            {
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
    (!defined (ACE_USES_FIFO_SEM) && \
      (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              if (ACE_OS::cond_wait (&event->eventdata_->condition_,
                                     &event->eventdata_->lock_) != 0)
                {
                  result = -1;
                  error = errno;
                  // Something went wrong...
                  break;
                }
              if (event->eventdata_->signal_count_ > 0)
                {
                  event->eventdata_->signal_count_--;
                  break;
                }
# else
#   if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED)) || \
      (!defined (ACE_USES_FIFO_SEM) && (!defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              if (ACE_OS::mutex_unlock (&event->eventdata_->lock_) != 0)
#   else
                if (ACE_OS::sema_post (&event->lock_) != 0)
#   endif
                  {
                    event->eventdata_->waiting_threads_--;
                    return -1;
                  }

              if (ACE_OS::sema_wait (&event->semaphore_) !=0)
                {
                  result = -1;
                  error = errno;
                }

              bool signalled = false;
              if (result == 0 && event->eventdata_->signal_count_ > 0)
                {
                  event->eventdata_->signal_count_--;
                  signalled = true;
                }

#   if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED)) || \
      (!defined (ACE_USES_FIFO_SEM) && (!defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
              if (ACE_OS::mutex_lock (&event->eventdata_->lock_) != 0)
#   else
                if (ACE_OS::sema_wait (&event->lock_) != 0)
#   endif
                  {
                    event->eventdata_->waiting_threads_--;
                    return -1;
                  }

              if (result)
                break;

              if (event->eventdata_->manual_reset_ == 1 && event->eventdata_->is_signaled_ == 1)
                if (ACE_OS::sema_post(&event->semaphore_) != 0)
                  {
                    result = -1;
                    error = errno;
                    break;
                  }

              if (signalled)
                break;
# endif
            }

          // Reset it since we have woken up.
          if (event->eventdata_->auto_event_signaled_ == true)
            event->eventdata_->auto_event_signaled_ = false;

          event->eventdata_->waiting_threads_--;
        }

      // Now we can let go of the lock.
# if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
        (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
     (!defined (ACE_USES_FIFO_SEM) && \
        (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
      ACE_OS::mutex_unlock (&event->eventdata_->lock_);
# else
      ACE_OS::sema_post (&event->lock_);
# endif

      if (result == -1)
        // Reset errno in case mutex_unlock() also fails...
        errno = error;
    }
  else
    result = -1;
  return result;
#else
  ACE_UNUSED_ARG (event);
  ACE_NOTSUP_RETURN (-1);
#endif /* ACE_WIN32 */
}

---

Member Data Documentation

ACE_eventdata_t* ACE_event_t::eventdata_ [protected]

Event data.

Definition at line 1874 of file OS_NS_Thread.h.

char* ACE_event_t::name_ [protected]

Event name if process shared.

Definition at line 1871 of file OS_NS_Thread.h.

---

The documentation for this class was generated from the following file:

• OS_NS_Thread.h

---