ACE_Dev_Poll_Reactor_Notify Class Reference

Event handler used for unblocking the ACE_Dev_Poll_Reactor from its event loop. More...

#include <Dev_Poll_Reactor.h>

Inheritance diagram for ACE_Dev_Poll_Reactor_Notify:

[legend]Collaboration diagram for ACE_Dev_Poll_Reactor_Notify:

[legend]List of all members.

Initialization and Termination Methods
Methods called when initializing and terminating this event handler.
virtual int	open (ACE_Reactor_Impl *, ACE_Timer_Queue *timer_queue=0, int disable_notify=0)
virtual int	close (void)
virtual int	notify (ACE_Event_Handler *eh=0, ACE_Reactor_Mask mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *timeout=0)
virtual int	dispatch_notifications (int &number_of_active_handles, ACE_Handle_Set &rd_mask)
virtual ACE_HANDLE	notify_handle (void)
virtual int	is_dispatchable (ACE_Notification_Buffer &buffer)
	Verify whether the buffer has dispatchable info or not.
virtual int	dispatch_notify (ACE_Notification_Buffer &buffer)
virtual int	read_notify_pipe (ACE_HANDLE handle, ACE_Notification_Buffer &buffer)
virtual int	handle_input (ACE_HANDLE handle)
virtual void	max_notify_iterations (int)
virtual int	max_notify_iterations (void)
virtual int	purge_pending_notifications (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual void	dump (void) const
	Dump the state of an object.
ACE_Dev_Poll_Reactor *	dp_reactor_
ACE_Pipe	notification_pipe_
int	max_notify_iterations_
Public Member Functions
	ACE_Dev_Poll_Reactor_Notify (void)
	Constructor.

---

Detailed Description

Event handler used for unblocking the ACE_Dev_Poll_Reactor from its event loop.

This event handler is used internally by the ACE_Dev_Poll_Reactor as a means to allow a thread other then the one running the event loop to unblock the event loop.

Definition at line 166 of file Dev_Poll_Reactor.h.

---

Constructor & Destructor Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Dev_Poll_Reactor_Notify::ACE_Dev_Poll_Reactor_Notify (  void   )

Constructor. Definition at line 45 of file Dev_Poll_Reactor.cpp. : dp_reactor_ (0) , notification_pipe_ () , max_notify_iterations_ (-1) #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) , alloc_queue_ () , notify_queue_ () , free_queue_ () , notify_queue_lock_ () #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ { }

---

Member Function Documentation

int ACE_Dev_Poll_Reactor_Notify::close (  void   )  [virtual]

Implements ACE_Reactor_Notify. Definition at line 115 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Unbounded_Queue_Iterator< T >::advance(), ACE_Pipe::close(), ACE_Unbounded_Queue_Iterator< T >::next(), and notification_pipe_. { ACE_TRACE ("ACE_Dev_Poll_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_Dev_Poll_Reactor_Notify::dispatch_notifications (  int &  number_of_active_handles, ACE_Handle_Set &  rd_mask )  [virtual]

This method's interface is not very compatibile with this Reactor's design. It's not clear why this method is pure virtual either. Implements ACE_Reactor_Notify. Definition at line 225 of file Dev_Poll_Reactor.cpp. References ACE_NOTSUP_RETURN, ACE_TRACE, handle_input(), notification_pipe_, and ACE_Pipe::read_handle(). { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dispatch_notifications"); // This method is unimplemented in the ACE_Dev_Poll_Reactor. // Instead, the notification handler is invoked as part of the IO // event set. Doing so alters the some documented semantics that // state that the notifications are handled before IO events. // Enforcing such semantics does not appear to be beneficial, and // also serves to slow down event dispatching particularly with this // ACE_Dev_Poll_Reactor. #if 0 ACE_HANDLE read_handle = this->notification_pipe_.read_handle (); // Note that we do not check if the handle has received any events. // Instead a non-blocking "speculative" read is performed. If the // read returns with errno == EWOULDBLOCK then no notifications are // dispatched. See ACE_Dev_Poll_Reactor_Notify::read_notify_pipe() // for details. if (read_handle != ACE_INVALID_HANDLE) { --number_of_active_handles; return this->handle_input (read_handle); } else return 0; #else ACE_NOTSUP_RETURN (-1); #endif /* 0 */ }

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

Handle one notify call represented in buffer. This could be because of a thread trying to unblock the Reactor_Impl. Implements ACE_Reactor_Notify. Definition at line 403 of file Dev_Poll_Reactor.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TRACE, ACE_Notification_Buffer::eh_, ACE_Event_Handler::handle_close(), ACE_Event_Handler::handle_exception(), ACE_Event_Handler::handle_input(), ACE_Event_Handler::handle_output(), LM_ERROR, and ACE_Notification_Buffer::mask_. Referenced by handle_input(). { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dispatch_notify"); // If eh == 0 then another thread is unblocking the // ACE_Dev_Poll_Reactor to update the ACE_Dev_Poll_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) { int result = 0; // Guard the handler's refcount. Recall that when the notify // was queued, the refcount was incremented, so it need not be // now. The guard insures that it is decremented properly. ACE_Dev_Poll_Handler_Guard eh_guard (buffer.eh_, false); 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 ("dispatch_notify invalid mask = %d\n"), buffer.mask_)); } if (result == -1) buffer.eh_->handle_close (ACE_INVALID_HANDLE, buffer.mask_); } return 1; }

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

Dump the state of an object. Implements ACE_Reactor_Notify. Definition at line 561 of file Dev_Poll_Reactor.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, ACE_Pipe::dump(), LM_DEBUG, and notification_pipe_. { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("dp_reactor_ = %@"), this->dp_reactor_)); this->notification_pipe_.dump (); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_HAS_DUMP */ }

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

Called back by the ACE_Dev_Poll_Reactor when a thread wants to unblock us. Reimplemented from ACE_Event_Handler. Definition at line 341 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, dispatch_notify(), max_notify_iterations_, and read_notify_pipe(). Referenced by dispatch_notifications(). { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::handle_input"); // @@ We may end up dispatching this event handler twice: once when // performing the speculative read on the notification pipe // handle, and once more when dispatching the IO events. // 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 available notifications have been dispatched. if (number_dispatched == this->max_notify_iterations_) break; } if (result == -1) { // Reassign number_dispatched to -1 if things have gone // seriously wrong. 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_Dev_Poll_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 395 of file Dev_Poll_Reactor.cpp. References ACE_NOTSUP_RETURN, and ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::is_dispatchable"); ACE_NOTSUP_RETURN (-1); }

int ACE_Dev_Poll_Reactor_Notify::max_notify_iterations (  void   )  [virtual]

Get the maximum number of times that the handle_input method will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify queue before breaking out of its event loop. Implements ACE_Reactor_Notify. Definition at line 459 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and max_notify_iterations_. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::max_notify_iterations"); return this->max_notify_iterations_; }

void ACE_Dev_Poll_Reactor_Notify::max_notify_iterations (  int   )  [virtual]

Set the maximum number of times that the handle_input method will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify queue before breaking out of the event loop. By default, this is set to -1, which means "iterate until the queue 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 447 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and max_notify_iterations_. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::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_Dev_Poll_Reactor_Notify::notify (  ACE_Event_Handler *  eh = 0, ACE_Reactor_Mask  mask = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *  timeout = 0 )  [virtual]

Called by a thread when it wants to unblock the Reactor_Impl. This wakes up the Reactor_Impl if currently blocked. Pass over both the Event_Handler and the mask to allow the caller to dictate which Event_Handler method the Reactor_Impl will invoke. The ACE_Time_Value indicates how long to block trying to notify the Reactor_Impl. 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 140 of file Dev_Poll_Reactor.cpp. References ACE_ASSERT, ACE_GUARD_RETURN, ACE_NEW_RETURN, ACE_Reactor_Mask, ACE_REACTOR_NOTIFICATION_ARRAY_SIZE, ACE_SYNCH_MUTEX, ACE_TRACE, dp_reactor_, ETIME, ACE_Dev_Poll_Handler_Guard::release(), ACE::send(), and ssize_t. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::notify"); // Just consider this method a "no-op" if there's no // ACE_Dev_Poll_Reactor configured. if (this->dp_reactor_ == 0) return 0; ACE_Notification_Buffer buffer (eh, mask); #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); // Locate a free buffer in the queue. Enlarge the queue if needed. 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) 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; ACE_Dev_Poll_Handler_Guard eh_guard (eh); if (notify_queue_.enqueue_tail (temp) == -1) return -1; // Now pop the pipe to force the callback for dispatching when ready. If // the send fails due to a full pipe, don't fail - assume the already-sent // pipe bytes will cause the entire notification queue to be processed. ssize_t n = ACE::send (this->notification_pipe_.write_handle (), (char *) &buffer, 1, // Only need one byte to pop the pipe timeout); if (n == -1 && (errno != ETIME && errno != EAGAIN)) return -1; // Since the notify is queued (and maybe already delivered by now) // we can simply release the guard. The dispatch of this notification // will decrement the reference count. eh_guard.release (); return 0; #else ACE_Dev_Poll_Handler_Guard eh_guard (eh); ssize_t n = ACE::send (this->notification_pipe_.write_handle (), (char *) &buffer, sizeof buffer, timeout); if (n == -1) return -1; eh_guard.release (); return 0; #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ }

ACE_HANDLE ACE_Dev_Poll_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 Reactor_Impl. Implements ACE_Reactor_Notify. Definition at line 387 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, notification_pipe_, and ACE_Pipe::read_handle(). { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::notify_handle"); return this->notification_pipe_.read_handle (); }

int ACE_Dev_Poll_Reactor_Notify::open (  ACE_Reactor_Impl *  , ACE_Timer_Queue *  timer_queue = 0, int  disable_notify = 0 )  [virtual]

Implements ACE_Reactor_Notify. Definition at line 59 of file Dev_Poll_Reactor.cpp. References ACE_NEW_RETURN, ACE_NONBLOCK, ACE_REACTOR_NOTIFICATION_ARRAY_SIZE, ACE_Timer_Queue, ACE_TRACE, dp_reactor_, ACE_OS::fcntl(), notification_pipe_, ACE_Pipe::open(), and ACE::set_flags(). { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::open"); if (disable_notify_pipe == 0) { this->dp_reactor_ = dynamic_cast<ACE_Dev_Poll_Reactor *> (r); if (this->dp_reactor_ == 0) { errno = EINVAL; return -1; } if (this->notification_pipe_.open () == -1) return -1; #if defined (F_SETFD) // close-on-exec 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) return -1; for (size_t i = 0; i < ACE_REACTOR_NOTIFICATION_ARRAY_SIZE; ++i) if (free_queue_.enqueue_head (temp + i) == -1) return -1; if (ACE::set_flags (this->notification_pipe_.write_handle (), ACE_NONBLOCK) == -1) return -1; #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ // Set the read handle into non-blocking mode since we need to // perform a "speculative" read when determining if their are // notifications to dispatch. if (ACE::set_flags (this->notification_pipe_.read_handle (), ACE_NONBLOCK) == -1) return -1; } return 0; }

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

Purge any notifications pending in this reactor for the specified ACE_Event_Handler object. Returns the number of notifications purged. Returns -1 on error. Implements ACE_Reactor_Notify. Definition at line 467 of file Dev_Poll_Reactor.cpp. References ACE_ASSERT, ACE_BIT_DISABLED, ACE_CLR_BITS, ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_LIB_TEXT, ACE_NOTSUP_RETURN, ACE_Reactor_Mask, ACE_SYNCH_MUTEX, ACE_TRACE, ACE_Unbounded_Queue< T >::dequeue_head(), ACE_Notification_Buffer::eh_, ACE_Unbounded_Queue< T >::enqueue_head(), LM_ERROR, ACE_Notification_Buffer::mask_, and ACE_Unbounded_Queue< T >::size(). { ACE_TRACE ("ACE_Dev_Poll_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 // notification mask // is left with // nothing when // applying the mask. { if (this->free_queue_.enqueue_head (temp) == -1) 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 // particular handler), 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_Dev_Poll_Reactor_Notify::read_notify_pipe (  ACE_HANDLE  handle, ACE_Notification_Buffer &  buffer )  [virtual]

Read one notify call on the handle into buffer. This could be because of a thread trying to unblock the Reactor_Impl. Implements ACE_Reactor_Notify. Definition at line 262 of file Dev_Poll_Reactor.cpp. References ACE_ERROR, ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_LIB_TEXT, ACE_SYNCH_MUTEX, ACE_TRACE, EWOULDBLOCK, LM_ERROR, ACE::recv(), and ssize_t. Referenced by handle_input(). { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::read_notify_pipe"); // This is a (non-blocking) "speculative" read, i.e., we attempt to // read even if no event was polled on the read handle. A // speculative read is necessary since notifications must be // dispatched before IO events. We can avoid the speculative read // by "walking" the array of pollfd structures returned from // `/dev/poll' or `/dev/epoll' but that is potentially much more // expensive than simply checking for an EWOULDBLOCK. size_t to_read; char *read_p; bool have_one = false; #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) // For the queued case, we'll try to read one byte (since that's what // the notify() tried to put in) but we don't need it - notifications can // be queued even if the pipe fills, so there may be more notifications // queued than there are bytes in the pipe. char b; read_p = &b; to_read = 1; ACE_Notification_Buffer *temp; // New scope to release the guard before trying the recv(). { ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); 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 ("read_notify_pipe: dequeue_head")), -1); buffer = *temp; have_one = true; if (free_queue_.enqueue_head (temp) == -1) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("read_notify_pipe: enqueue_head"))); } #else to_read = sizeof buffer; read_p = (char *)&buffer; #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ ssize_t n = ACE::recv (handle, read_p, to_read); if (n > 0) { // Check to see if we've got a short read. if (static_cast<size_t>(n) != to_read) { size_t remainder = to_read - 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, &read_p[n], remainder) <= 0) return -1; } return 1; } // Return -1 if things have gone seriously wrong. if (n <= 0 && (errno != EWOULDBLOCK && errno != EAGAIN)) return -1; return have_one ? 1 : 0; }

---

Member Data Documentation

ACE_Dev_Poll_Reactor* ACE_Dev_Poll_Reactor_Notify::dp_reactor_ [protected]

Keep a back pointer to the ACE_Dev_Poll_Reactor. If this value if NULL then the ACE_Dev_Poll_Reactor has been initialized with disable_notify_pipe. Definition at line 267 of file Dev_Poll_Reactor.h. Referenced by notify(), and open().

int ACE_Dev_Poll_Reactor_Notify::max_notify_iterations_ [protected]

Keeps track of the maximum number of times that the ACE_Dev_Poll_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 283 of file Dev_Poll_Reactor.h. Referenced by handle_input(), and max_notify_iterations().

ACE_Pipe ACE_Dev_Poll_Reactor_Notify::notification_pipe_ [protected]

Contains the ACE_HANDLE the ACE_Dev_Poll_Reactor is listening on, as well as the ACE_HANDLE that threads wanting the attention of the ACE_Dev_Poll_Reactor will write to. Definition at line 274 of file Dev_Poll_Reactor.h. Referenced by close(), dispatch_notifications(), dump(), notify_handle(), and open().

---

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

• Dev_Poll_Reactor.h
• Dev_Poll_Reactor.cpp

---