---

ACE_Select_Reactor_Notify Class Reference

Unblock the <ACE_Select_Reactor> from its event loop. More...

#include <Select_Reactor_Base.h>

Inheritance diagram for ACE_Select_Reactor_Notify:

[legend]Collaboration diagram for ACE_Select_Reactor_Notify:

[legend]List of all members.

Public Methods
	ACE_Select_Reactor_Notify (void)
	Constructor. More...
	~ACE_Select_Reactor_Notify (void)
	Destructor. More...
virtual int	open (ACE_Reactor_Impl *, ACE_Timer_Queue *=0, int disable_notify_pipe=0)
	Initialize. More...
virtual int	close (void)
	Destroy. More...
virtual int	notify (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *=0)
virtual int	dispatch_notifications (int &number_of_active_handles, ACE_Handle_Set &rd_mask)
	Handles pending threads (if any) that are waiting to unblock the <ACE_Select_Reactor>. More...
virtual ACE_HANDLE	notify_handle (void)
	Returns the ACE_HANDLE of the notify pipe on which the reactor is listening for notifications so that other threads can unblock the Select_Reactor. More...
virtual int	dispatch_notify (ACE_Notification_Buffer &buffer)
	Handle one of the notify call on the <handle>. This could be because of a thread trying to unblock the <Reactor_Impl>. More...
virtual int	read_notify_pipe (ACE_HANDLE handle, ACE_Notification_Buffer &buffer)
	Read one of the notify call on the <handle> into the <buffer>. This could be because of a thread trying to unblock the <Reactor_Impl>. More...
virtual int	is_dispatchable (ACE_Notification_Buffer &buffer)
	Verify whether the buffer has dispatchable info or not. More...
virtual int	handle_input (ACE_HANDLE handle)
	Called back by the <ACE_Select_Reactor> when a thread wants to unblock us. More...
virtual void	max_notify_iterations (int)
virtual int	max_notify_iterations (void)
virtual int	purge_pending_notifications (ACE_Event_Handler *, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual void	dump (void) const
	Dump the state of an object. More...
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks. More...
Protected Attributes
ACE_Select_Reactor_Impl *	select_reactor_
ACE_Pipe	notification_pipe_
int	max_notify_iterations_

---

Detailed Description

Unblock the <ACE_Select_Reactor> from its event loop.

This implementation is necessary for cases where the <ACE_Select_Reactor> is run in a multi-threaded program. In this case, we need to be able to unblock <select> or <poll> when updates occur other than in the main <ACE_Select_Reactor> thread. To do this, we signal an auto-reset event the <ACE_Select_Reactor> is listening on. If an <ACE_Event_Handler> and <ACE_Select_Reactor_Mask> is passed to <notify>, the appropriate <handle_*> method is dispatched in the context of the <ACE_Select_Reactor> thread.

Definition at line 117 of file Select_Reactor_Base.h.

---

Constructor & Destructor Documentation

ACE_Select_Reactor_Notify::ACE_Select_Reactor_Notify (  void    )

Constructor. Definition at line 482 of file Select_Reactor_Base.cpp. : max_notify_iterations_ (-1) { }

ACE_INLINE ACE_Select_Reactor_Notify::~ACE_Select_Reactor_Notify (  void    )

Destructor. Definition at line 12 of file Select_Reactor_Base.i. { }

---

Member Function Documentation

int ACE_Select_Reactor_Notify::close (  void    )  [virtual]

Destroy. Implements ACE_Reactor_Notify. Definition at line 673 of file Select_Reactor_Base.cpp. References ACE_TRACE, ACE_Unbounded_Queue_Iterator::advance, ACE_Pipe::close, ACE_Unbounded_Queue_Iterator::next, and notification_pipe_. { ACE_TRACE ("ACE_Select_Reactor_Notify::close"); #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) // Free up the dynamically allocated resources. ACE_Notification_Buffer **b; for (ACE_Unbounded_Queue_Iterator<ACE_Notification_Buffer *> alloc_iter (this->alloc_queue_); alloc_iter.next (b) != 0; alloc_iter.advance ()) { delete [] *b; *b = 0; } this->alloc_queue_.reset (); this->notify_queue_.reset (); this->free_queue_.reset (); #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ return this->notification_pipe_.close (); }

int ACE_Select_Reactor_Notify::dispatch_notifications (  int &    number_of_active_handles, ACE_Handle_Set &    rd_mask )  [virtual]

Handles pending threads (if any) that are waiting to unblock the <ACE_Select_Reactor>. Implements ACE_Reactor_Notify. Definition at line 774 of file Select_Reactor_Base.cpp. References ACE_TRACE, ACE_Handle_Set::clr_bit, handle_input, ACE_Handle_Set::is_set, notification_pipe_, and ACE_Pipe::read_handle. { ACE_TRACE ("ACE_Select_Reactor_Notify::dispatch_notifications"); ACE_HANDLE read_handle = this->notification_pipe_.read_handle (); if (read_handle != ACE_INVALID_HANDLE && rd_mask.is_set (read_handle)) { number_of_active_handles--; rd_mask.clr_bit (read_handle); return this->handle_input (read_handle); } else return 0; }

int ACE_Select_Reactor_Notify::dispatch_notify (  ACE_Notification_Buffer &    buffer )  [virtual]

Handle one of the notify call on the <handle>. This could be because of a thread trying to unblock the <Reactor_Impl>. Implements ACE_Reactor_Notify. Definition at line 865 of file Select_Reactor_Base.cpp. References ACE_Event_Handler::ACCEPT_MASK, ACE_ERROR, ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_LIB_TEXT, ACE_SYNCH_MUTEX, ACE_Notification_Buffer::eh_, ACE_Event_Handler::EXCEPT_MASK, ACE_Event_Handler::GROUP_QOS_MASK, ACE_Event_Handler::handle_close, ACE_Event_Handler::handle_exception, ACE_Event_Handler::handle_group_qos, ACE_Event_Handler::handle_input, ACE_Event_Handler::handle_output, ACE_Event_Handler::handle_qos, LM_ERROR, ACE_Notification_Buffer::mask_, ACE_Event_Handler::QOS_MASK, ACE_Event_Handler::READ_MASK, and ACE_Event_Handler::WRITE_MASK. Referenced by handle_input. { int result = 0; #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) // Dispatch all messages that are in the <notify_queue_>. { // We acquire the lock in a block to make sure we're not // holding the lock while delivering callbacks... ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); ACE_Notification_Buffer *temp; if (notify_queue_.is_empty ()) return 0; else if (notify_queue_.dequeue_head (temp) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("dequeue_head")), -1); buffer = *temp; if (free_queue_.enqueue_head (temp) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_head")), -1); } // If eh == 0 then another thread is unblocking the // <ACE_Select_Reactor> to update the <ACE_Select_Reactor>'s // internal structures. Otherwise, we need to dispatch the // appropriate handle_* method on the <ACE_Event_Handler> // pointer we've been passed. if (buffer.eh_ != 0) { switch (buffer.mask_) { case ACE_Event_Handler::READ_MASK: case ACE_Event_Handler::ACCEPT_MASK: result = buffer.eh_->handle_input (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::WRITE_MASK: result = buffer.eh_->handle_output (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::EXCEPT_MASK: result = buffer.eh_->handle_exception (ACE_INVALID_HANDLE); break; default: // Should we bail out if we get an invalid mask? ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("invalid mask = %d\n"), buffer.mask_)); } if (result == -1) buffer.eh_->handle_close (ACE_INVALID_HANDLE, ACE_Event_Handler::EXCEPT_MASK); } #else // If eh == 0 then another thread is unblocking the // <ACE_Select_Reactor> to update the <ACE_Select_Reactor>'s // internal structures. Otherwise, we need to dispatch the // appropriate handle_* method on the <ACE_Event_Handler> // pointer we've been passed. if (buffer.eh_ != 0) { switch (buffer.mask_) { case ACE_Event_Handler::READ_MASK: case ACE_Event_Handler::ACCEPT_MASK: result = buffer.eh_->handle_input (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::WRITE_MASK: result = buffer.eh_->handle_output (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::EXCEPT_MASK: result = buffer.eh_->handle_exception (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::QOS_MASK: result = buffer.eh_->handle_qos (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::GROUP_QOS_MASK: result = buffer.eh_->handle_group_qos (ACE_INVALID_HANDLE); break; default: // Should we bail out if we get an invalid mask? ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("invalid mask = %d\n"), buffer.mask_)); } if (result == -1) buffer.eh_->handle_close (ACE_INVALID_HANDLE, ACE_Event_Handler::EXCEPT_MASK); } #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ return 1; }

void ACE_Select_Reactor_Notify::dump (  void    )  const [virtual]

Dump the state of an object. Implements ACE_Reactor_Notify. Definition at line 600 of file Select_Reactor_Base.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, ACE_Pipe::dump, LM_DEBUG, and notification_pipe_. { ACE_TRACE ("ACE_Select_Reactor_Notify::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("select_reactor_ = %x"), this->select_reactor_)); this->notification_pipe_.dump (); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); }

int ACE_Select_Reactor_Notify::handle_input (  ACE_HANDLE    handle )  [virtual]

Called back by the <ACE_Select_Reactor> when a thread wants to unblock us. Reimplemented from ACE_Event_Handler. Definition at line 1000 of file Select_Reactor_Base.cpp. References ACE_TRACE, dispatch_notify, max_notify_iterations_, read_notify_pipe, ACE_Select_Reactor_Impl::renew, and select_reactor_. Referenced by dispatch_notifications. { ACE_TRACE ("ACE_Select_Reactor_Notify::handle_input"); // Precondition: this->select_reactor_.token_.current_owner () == // ACE_Thread::self (); int number_dispatched = 0; int result = 0; ACE_Notification_Buffer buffer; while ((result = this->read_notify_pipe (handle, buffer)) > 0) { // Dispatch the buffer // NOTE: We count only if we made any dispatches ie. upcalls. if (this->dispatch_notify (buffer) > 0) number_dispatched++; // Bail out if we've reached the <notify_threshold_>. Note that // by default <notify_threshold_> is -1, so we'll loop until all // the notifications in the pipe have been dispatched. if (number_dispatched == this->max_notify_iterations_) break; } // Reassign number_dispatched to -1 if things have gone seriously // wrong. if (result < 0) number_dispatched = -1; // Enqueue ourselves into the list of waiting threads. When we // reacquire the token we'll be off and running again with ownership // of the token. The postcondition of this call is that // <select_reactor_.token_.current_owner> == <ACE_Thread::self>. this->select_reactor_->renew (); return number_dispatched; }

int ACE_Select_Reactor_Notify::is_dispatchable (  ACE_Notification_Buffer &    buffer )  [virtual]

Verify whether the buffer has dispatchable info or not. Implements ACE_Reactor_Notify. Definition at line 808 of file Select_Reactor_Base.cpp. References ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_LIB_TEXT, ACE_SYNCH_MUTEX, ACE_Notification_Buffer::eh_, and LM_ERROR. { // There is tonnes of code that can be abstracted... #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) { ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); ACE_Notification_Buffer *temp; ACE_UNUSED_ARG (buffer); // If the queue is empty just return 0 if (notify_queue_.is_empty ()) return 0; if (this->notify_queue_.dequeue_head (temp) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("dequeue_head")), -1); if (temp->eh_ != 0) { // If the queue had a buffer that has an event handler, put // the element back in the queue and return a 1 if (this->notify_queue_.enqueue_head (temp) == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enque_head")), -1); } return 1; } // Else put the element in the free queue if (free_queue_.enqueue_head (temp) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_head")), -1); } #else // If eh == 0 then another thread is unblocking the // <ACE_Select_Reactor> to update the <ACE_Select_Reactor>'s // internal structures. Otherwise, we need to dispatch the // appropriate handle_* method on the <ACE_Event_Handler> // pointer we've been passed. if (buffer.eh_ != 0) return 1; #endif /*ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ // has no dispatchable buffer return 0; }

int ACE_Select_Reactor_Notify::max_notify_iterations (  void    )  [virtual]

Get the maximum number of times that the <ACE_Select_Reactor_Notify::handle_input> method will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify pipe before breaking out of its <recv> loop. Implements ACE_Reactor_Notify. Definition at line 498 of file Select_Reactor_Base.cpp. References max_notify_iterations_. { return this->max_notify_iterations_; }

void ACE_Select_Reactor_Notify::max_notify_iterations (  int    )  [virtual]

Set the maximum number of times that the <ACE_Select_Reactor_Notify::handle_input> method will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify pipe before breaking out of its <recv> loop. By default, this is set to -1, which means "iterate until the pipe is empty." Setting this to a value like "1 or 2" will increase "fairness" (and thus prevent starvation) at the expense of slightly higher dispatching overhead. Implements ACE_Reactor_Notify. Definition at line 488 of file Select_Reactor_Base.cpp. References max_notify_iterations_. { // Must always be > 0 or < 0 to optimize the loop exit condition. if (iterations == 0) iterations = 1; this->max_notify_iterations_ = iterations; }

int ACE_Select_Reactor_Notify::notify (  ACE_Event_Handler *    = 0, ACE_Reactor_Mask    = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *    = 0 )  [virtual]

Called by a thread when it wants to unblock the <ACE_Select_Reactor>. This wakeups the <ACE_Select_Reactor> if currently blocked in <select>/<poll>. Pass over both the <Event_Handler> *and* the <mask> to allow the caller to dictate which <Event_Handler> method the <ACE_Select_Reactor> will invoke. The <ACE_Time_Value> indicates how long to blocking trying to notify the <ACE_Select_Reactor>. If <timeout> == 0, the caller will block until action is possible, else will wait until the relative time specified in *<timeout> elapses). Implements ACE_Reactor_Notify. Definition at line 698 of file Select_Reactor_Base.cpp. References ACE_ASSERT, ACE_GUARD_RETURN, ACE_NEW_RETURN, ACE_Reactor_Mask, ACE_REACTOR_NOTIFICATION_ARRAY_SIZE, ACE_SYNCH_MUTEX, ACE_TRACE, select_reactor_, ACE::send, and ssize_t. { ACE_TRACE ("ACE_Select_Reactor_Notify::notify"); // Just consider this method a "no-op" if there's no // <ACE_Select_Reactor> configured. if (this->select_reactor_ == 0) return 0; ACE_Notification_Buffer buffer (eh, mask); #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) // Artificial scope to limit the duration of the mutex. { // int notification_required = 0; ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); // No pending notifications. // We will send notify for every message.. // if (this->notify_queue_.is_empty ()) // notification_required = 1; ACE_Notification_Buffer *temp = 0; if (free_queue_.dequeue_head (temp) == -1) { // Grow the queue of available buffers. ACE_Notification_Buffer *temp1; ACE_NEW_RETURN (temp1, ACE_Notification_Buffer[ACE_REACTOR_NOTIFICATION_ARRAY_SIZE], -1); if (this->alloc_queue_.enqueue_head (temp1) == -1) { delete [] temp1; return -1; } // Start at 1 and enqueue only // (ACE_REACTOR_NOTIFICATION_ARRAY_SIZE - 1) elements since // the first one will be used right now. for (size_t i = 1; i < ACE_REACTOR_NOTIFICATION_ARRAY_SIZE; i++) this->free_queue_.enqueue_head (temp1 + i); temp = temp1; } ACE_ASSERT (temp != 0); *temp = buffer; if (notify_queue_.enqueue_tail (temp) == -1) return -1; } #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ ssize_t n = ACE::send (this->notification_pipe_.write_handle (), (char *) &buffer, sizeof buffer, timeout); if (n == -1) return -1; return 0; }

ACE_HANDLE ACE_Select_Reactor_Notify::notify_handle (  void    )  [virtual]

Returns the ACE_HANDLE of the notify pipe on which the reactor is listening for notifications so that other threads can unblock the Select_Reactor. Implements ACE_Reactor_Notify. Definition at line 795 of file Select_Reactor_Base.cpp. References ACE_TRACE, notification_pipe_, and ACE_Pipe::read_handle. { ACE_TRACE ("ACE_Select_Reactor_Notify::notify_handle"); return this->notification_pipe_.read_handle (); }

int ACE_Select_Reactor_Notify::open (  ACE_Reactor_Impl *   , ACE_Timer_Queue *    = 0, int    disable_notify_pipe = 0 )  [virtual]

Initialize. Implements ACE_Reactor_Notify. Definition at line 611 of file Select_Reactor_Base.cpp. References ACE_NEW_RETURN, ACE_NONBLOCK, ACE_REACTOR_NOTIFICATION_ARRAY_SIZE, ACE_TRACE, ACE_OS::fcntl, notification_pipe_, ACE_Pipe::open, ACE_Pipe::read_handle, ACE_Event_Handler::READ_MASK, ACE_Reactor_Impl::register_handler, select_reactor_, and ACE_Flag_Manip::set_flags. { ACE_TRACE ("ACE_Select_Reactor_Notify::open"); if (disable_notify_pipe == 0) { this->select_reactor_ = ACE_dynamic_cast (ACE_Select_Reactor_Impl *, r); if (select_reactor_ == 0) { errno = EINVAL; return -1; } if (this->notification_pipe_.open () == -1) return -1; #if defined (F_SETFD) ACE_OS::fcntl (this->notification_pipe_.read_handle (), F_SETFD, 1); ACE_OS::fcntl (this->notification_pipe_.write_handle (), F_SETFD, 1); #endif /* F_SETFD */ #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) ACE_Notification_Buffer *temp; ACE_NEW_RETURN (temp, ACE_Notification_Buffer[ACE_REACTOR_NOTIFICATION_ARRAY_SIZE], -1); if (this->alloc_queue_.enqueue_head (temp) == -1) { delete [] temp; return -1; } for (size_t i = 0; i < ACE_REACTOR_NOTIFICATION_ARRAY_SIZE; i++) if (free_queue_.enqueue_head (temp + i) == -1) return -1; #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ // There seems to be a Win32 bug with this... Set this into // non-blocking mode. if (ACE::set_flags (this->notification_pipe_.read_handle (), ACE_NONBLOCK) == -1) return -1; else return this->select_reactor_->register_handler (this->notification_pipe_.read_handle (), this, ACE_Event_Handler::READ_MASK); } else { this->select_reactor_ = 0; return 0; } }

int ACE_Select_Reactor_Notify::purge_pending_notifications (  ACE_Event_Handler *   , ACE_Reactor_Mask    = ACE_Event_Handler::ALL_EVENTS_MASK )  [virtual]

Purge any notifications pending in this reactor for the specified <ACE_Event_Handler> object. If <eh> == 0, all notifications for all handlers are removed (but not any notifications posted just to wake up the reactor itself). Returns the number of notifications purged. Returns -1 on error. Implements ACE_Reactor_Notify. Definition at line 510 of file Select_Reactor_Base.cpp. References ACE_ASSERT, ACE_BIT_DISABLED, ACE_CLR_BITS, ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_LIB_TEXT, ACE_Reactor_Mask, ACE_SYNCH_MUTEX, ACE_TRACE, ACE_Unbounded_Queue::dequeue_head, ACE_Notification_Buffer::eh_, ACE_Unbounded_Queue::enqueue_head, LM_ERROR, ACE_Notification_Buffer::mask_, and ACE_Unbounded_Queue::size. { ACE_TRACE ("ACE_Select_Reactor_Notify::purge_pending_notifications"); #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); if (this->notify_queue_.is_empty ()) return 0; ACE_Notification_Buffer *temp; ACE_Unbounded_Queue <ACE_Notification_Buffer *> local_queue; size_t queue_size = this->notify_queue_.size (); int number_purged = 0; size_t i; for (i = 0; i < queue_size; ++i) { if (-1 == this->notify_queue_.dequeue_head (temp)) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("dequeue_head")), -1); // If this is not a Reactor notify (it is for a particular handler), // and it matches the specified handler (or purging all), // and applying the mask would totally eliminate the notification, then // release it and count the number purged. if ((0 != temp->eh_) && (0 == eh || eh == temp->eh_) && ACE_BIT_DISABLED (temp->mask_, ~mask)) // the existing notificationmask // is left with nothing when // applying the mask { if (-1 == this->free_queue_.enqueue_head (temp)) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_head")), -1); ++number_purged; } else { // To preserve it, move it to the local_queue. // But first, if this is not a Reactor notify (it is for a particularhandler), // and it matches the specified handler (or purging all), then // apply the mask if ((0 != temp->eh_) && (0 == eh || eh == temp->eh_)) ACE_CLR_BITS(temp->mask_, mask); if (-1 == local_queue.enqueue_head (temp)) return -1; } } if (this->notify_queue_.size ()) { // should be empty! ACE_ASSERT (0); return -1; } // now put it back in the notify queue queue_size = local_queue.size (); for (i = 0; i < queue_size; ++i) { if (-1 == local_queue.dequeue_head (temp)) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("dequeue_head")), -1); if (-1 == this->notify_queue_.enqueue_head (temp)) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_head")), -1); } return number_purged; #else /* defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) */ ACE_UNUSED_ARG (eh); ACE_UNUSED_ARG (mask); ACE_NOTSUP_RETURN (-1); #endif /* defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) */ }

int ACE_Select_Reactor_Notify::read_notify_pipe (  ACE_HANDLE    handle, ACE_Notification_Buffer &    buffer )  [virtual]

Read one of the notify call on the <handle> into the <buffer>. This could be because of a thread trying to unblock the <Reactor_Impl>. Implements ACE_Reactor_Notify. Definition at line 963 of file Select_Reactor_Base.cpp. References ACE_TRACE, EWOULDBLOCK, ACE::recv, and ssize_t. Referenced by handle_input. { ACE_TRACE ("ACE_Select_Reactor_Notify::read_notify_pipe"); ssize_t n = ACE::recv (handle, (char *) &buffer, sizeof buffer); if (n > 0) { // Check to see if we've got a short read. if (n != sizeof buffer) { ssize_t remainder = sizeof buffer - n; // If so, try to recover by reading the remainder. If this // doesn't work we're in big trouble since the input stream // won't be aligned correctly. I'm not sure quite what to // do at this point. It's probably best just to return -1. if (ACE::recv (handle, ((char *) &buffer) + n, remainder) != remainder) return -1; } return 1; } // Return -1 if things have gone seriously wrong. if (n <= 0 && (errno != EWOULDBLOCK && errno != EAGAIN)) return -1; return 0; }

---

Member Data Documentation

ACE_Select_Reactor_Notify::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks. Definition at line 211 of file Select_Reactor_Base.h.

int ACE_Select_Reactor_Notify::max_notify_iterations_ [protected]

Keeps track of the maximum number of times that the <ACE_Select_Reactor_Notify::handle_input> method will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify pipe before breaking out of its <recv> loop. By default, this is set to -1, which means "iterate until the pipe is empty." Definition at line 235 of file Select_Reactor_Base.h. Referenced by handle_input, and max_notify_iterations.

ACE_Pipe ACE_Select_Reactor_Notify::notification_pipe_ [protected]

Contains the <ACE_HANDLE> the <ACE_Select_Reactor> is listening on, as well as the <ACE_HANDLE> that threads wanting the attention of the <ACE_Select_Reactor> will write to. Definition at line 226 of file Select_Reactor_Base.h. Referenced by close, dispatch_notifications, dump, notify_handle, and open.

ACE_Select_Reactor_Impl* ACE_Select_Reactor_Notify::select_reactor_ [protected]

Keep a back pointer to the <ACE_Select_Reactor>. If this value if NULL then the <ACE_Select_Reactor> has been initialized with <disable_notify_pipe>. Definition at line 219 of file Select_Reactor_Base.h. Referenced by handle_input, notify, and open.

---

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

• Select_Reactor_Base.h
• Select_Reactor_Base.cpp
• Select_Reactor_Base.i

---