ACE_WFMO_Reactor_Handler_Repository Class Reference

Used to map ACE_HANDLEs onto the appropriate ACE_Event_Handler * and other information. More...

#include <WFMO_Reactor.h>

Collaboration diagram for ACE_WFMO_Reactor_Handler_Repository:

[legend]List of all members.

Public Member Functions
	ACE_WFMO_Reactor_Handler_Repository (ACE_WFMO_Reactor &wfmo_reactor)
	Constructor.
virtual	~ACE_WFMO_Reactor_Handler_Repository (void)
	Destructor.
int	open (size_t size)
	Initialize the repository of the approriate .
int	close (void)
	Close down the handler repository.
int	bind (ACE_HANDLE, ACE_Event_Handler *)
int	bind_i (int io_entry, ACE_Event_Handler *event_handler, long network_events, ACE_HANDLE io_handle, ACE_HANDLE event_handle, int delete_event)
int	unbind (ACE_HANDLE, ACE_Reactor_Mask mask)
	Remove the binding of ACE_HANDLE in accordance with the .
int	unbind_i (ACE_HANDLE, ACE_Reactor_Mask mask, int &changes_required)
	Non-lock-grabbing version of .
void	unbind_all (void)
	Remove all bindings of <ACE_HANDLE, ACE_Event_Handler> tuples.
int	invalid_handle (ACE_HANDLE handle) const
DWORD	max_handlep1 (void) const
	Maximum ACE_HANDLE value, plus 1.
ACE_HANDLE *	handles (void) const
Current_Info *	current_info (void) const
virtual int	changes_required (void)
	Check if changes to the handle set are required.
virtual int	make_changes (void)
	Make changes to the handle set.
int	scheduled_for_deletion (size_t slot) const
	Check to see if has been scheduled for deletion.
int	modify_network_events_i (ACE_HANDLE io_handle, ACE_Reactor_Mask new_masks, ACE_Reactor_Mask &old_masks, long &new_network_events, ACE_HANDLE &event_handle, int &delete_event, int operation)
ACE_Reactor_Mask	bit_ops (long &existing_masks, ACE_Reactor_Mask to_be_removed_masks, int operation)
int	suspend_handler_i (ACE_HANDLE handle, int &changes_required)
	Temporarily suspend entry.
int	resume_handler_i (ACE_HANDLE handle, int &changes_required)
	Resume suspended entry.
int	make_changes_in_current_infos (void)
	Deletions and suspensions in current_info_.
int	make_changes_in_suspension_infos (void)
	Deletions and resumptions in current_suspended_info_.
int	make_changes_in_to_be_added_infos (void)
int	remove_handler_i (size_t slot, ACE_Reactor_Mask mask)
	Removes the ACE_Event_Handler at from the table.
int	remove_suspended_handler_i (size_t slot, ACE_Reactor_Mask mask)
	Removes the ACE_Event_Handler at from the table.
int	remove_to_be_added_handler_i (size_t slot, ACE_Reactor_Mask to_be_removed_masks)
	Removes the ACE_Event_Handler at from the table.
ACE_Event_Handler *	find_handler (ACE_HANDLE handle)
int	handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=0)
ACE_Event_Handler *	handler (ACE_HANDLE handle, long &existing_masks)
void	dump (void) const
	Dump the state of an object.
Protected Attributes
ACE_WFMO_Reactor &	wfmo_reactor_
	Reference to our .
size_t	max_size_
	Maximum number of handles.
ACE_HANDLE *	current_handles_
Current_Info *	current_info_
	Array of current entries in the table.
DWORD	max_handlep1_
	A count of the number of active handles.
To_Be_Added_Info *	to_be_added_info_
	Information for entries to be added.
size_t	handles_to_be_added_
	Number of records to be added.
Suspended_Info *	current_suspended_info_
	Currently suspended handles.
size_t	suspended_handles_
	Number of currently suspended handles.
size_t	handles_to_be_suspended_
	Number of records to be suspended.
size_t	handles_to_be_resumed_
	Number of records to be resumed.
size_t	handles_to_be_deleted_
	Number of records to be deleted.
Friends
class	ACE_WFMO_Reactor
class	ACE_WFMO_Reactor_Test

---

Detailed Description

Used to map ACE_HANDLEs onto the appropriate ACE_Event_Handler * and other information.

Definition at line 103 of file WFMO_Reactor.h.

---

Constructor & Destructor Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_WFMO_Reactor_Handler_Repository::ACE_WFMO_Reactor_Handler_Repository (  ACE_WFMO_Reactor &  wfmo_reactor  )

Constructor. Definition at line 23 of file WFMO_Reactor.cpp. : wfmo_reactor_ (wfmo_reactor) { }

ACE_WFMO_Reactor_Handler_Repository::~ACE_WFMO_Reactor_Handler_Repository (  void   )  [virtual]

Destructor. Definition at line 67 of file WFMO_Reactor.cpp. References current_handles_, current_info_, current_suspended_info_, and to_be_added_info_. Referenced by ACE_WFMO_Reactor::open(). { // Free up dynamically allocated space delete [] this->current_handles_; delete [] this->current_info_; delete [] this->current_suspended_info_; delete [] this->to_be_added_info_; }

---

Member Function Documentation

int ACE_WFMO_Reactor_Handler_Repository::bind (  ACE_HANDLE  , ACE_Event_Handler *  )

Bind the <ACE_Event_Handler *> to the ACE_HANDLE. This is for the simple event entry.

int ACE_WFMO_Reactor_Handler_Repository::bind_i (  int  io_entry, ACE_Event_Handler *  event_handler, long  network_events, ACE_HANDLE  io_handle, ACE_HANDLE  event_handle, int  delete_event )

Insert I/O entry into the system. This method assumes that the lock are head *before* this method is invoked. Definition at line 627 of file WFMO_Reactor.cpp. References ACE_Event_Handler::add_reference(), ACE_Event_Handler::get_handle(), handles_to_be_added_, handles_to_be_deleted_, invalid_handle(), ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::set(), suspended_handles_, to_be_added_info_, ACE_WFMO_Reactor::wakeup_all_threads(), and wfmo_reactor_. Referenced by ACE_WFMO_Reactor::register_handler(), and ACE_WFMO_Reactor::register_handler_i(). { // Make sure that the <handle> is valid if (event_handle == ACE_INVALID_HANDLE) event_handle = event_handler->get_handle (); if (this->invalid_handle (event_handle)) return -1; size_t current_size = this->max_handlep1_ + this->handles_to_be_added_ - this->handles_to_be_deleted_ + this->suspended_handles_; // Make sure that there's room in the table and that total pending // additions should not exceed what the <to_be_added_info_> array // can hold. if (current_size < this->max_size_ && this->handles_to_be_added_ < this->max_size_) { // Cache this set into the <to_be_added_info_>, till we come // around to actually adding this to the <current_info_> this->to_be_added_info_[this->handles_to_be_added_].set (event_handle, io_entry, event_handler, io_handle, network_events, delete_event); ++this->handles_to_be_added_; event_handler->add_reference (); // Wake up all threads in WaitForMultipleObjects so that they can // reconsult the handle set this->wfmo_reactor_.wakeup_all_threads (); } else { errno = EMFILE; // File descriptor table is full (better than nothing) return -1; } return 0; }

ACE_Reactor_Mask ACE_WFMO_Reactor_Handler_Repository::bit_ops (  long &  existing_masks, ACE_Reactor_Mask  to_be_removed_masks, int  operation )

This method is used to change the network mask left (if any) after a remove request to Definition at line 77 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_CLR_BITS, ACE_Reactor_Mask, ACE_SET_BITS, FD_GROUP_QOS, and FD_QOS. Referenced by modify_network_events_i(), remove_handler_i(), remove_suspended_handler_i(), and remove_to_be_added_handler_i(). { // Find the old reactor masks. This automatically does the work of // the GET_MASK operation. ACE_Reactor_Mask old_masks = ACE_Event_Handler::NULL_MASK; if (ACE_BIT_ENABLED (existing_masks, FD_READ) || ACE_BIT_ENABLED (existing_masks, FD_CLOSE)) ACE_SET_BITS (old_masks, ACE_Event_Handler::READ_MASK); if (ACE_BIT_ENABLED (existing_masks, FD_WRITE)) ACE_SET_BITS (old_masks, ACE_Event_Handler::WRITE_MASK); if (ACE_BIT_ENABLED (existing_masks, FD_OOB)) ACE_SET_BITS (old_masks, ACE_Event_Handler::EXCEPT_MASK); if (ACE_BIT_ENABLED (existing_masks, FD_ACCEPT)) ACE_SET_BITS (old_masks, ACE_Event_Handler::ACCEPT_MASK); if (ACE_BIT_ENABLED (existing_masks, FD_CONNECT)) ACE_SET_BITS (old_masks, ACE_Event_Handler::CONNECT_MASK); if (ACE_BIT_ENABLED (existing_masks, FD_QOS)) ACE_SET_BITS (old_masks, ACE_Event_Handler::QOS_MASK); if (ACE_BIT_ENABLED (existing_masks, FD_GROUP_QOS)) ACE_SET_BITS (old_masks, ACE_Event_Handler::GROUP_QOS_MASK); switch (operation) { case ACE_Reactor::CLR_MASK: // For the CLR_MASK operation, clear only the specific masks. if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::READ_MASK)) { ACE_CLR_BITS (existing_masks, FD_READ); ACE_CLR_BITS (existing_masks, FD_CLOSE); } if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::WRITE_MASK)) ACE_CLR_BITS (existing_masks, FD_WRITE); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::EXCEPT_MASK)) ACE_CLR_BITS (existing_masks, FD_OOB); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::ACCEPT_MASK)) ACE_CLR_BITS (existing_masks, FD_ACCEPT); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::CONNECT_MASK)) ACE_CLR_BITS (existing_masks, FD_CONNECT); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::QOS_MASK)) ACE_CLR_BITS (existing_masks, FD_QOS); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::GROUP_QOS_MASK)) ACE_CLR_BITS (existing_masks, FD_GROUP_QOS); break; case ACE_Reactor::SET_MASK: // If the operation is a set, first reset any existing masks existing_masks = 0; /* FALLTHRU */ case ACE_Reactor::ADD_MASK: // For the ADD_MASK and the SET_MASK operation, add only the // specific masks. if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::READ_MASK)) { ACE_SET_BITS (existing_masks, FD_READ); ACE_SET_BITS (existing_masks, FD_CLOSE); } if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::WRITE_MASK)) ACE_SET_BITS (existing_masks, FD_WRITE); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::EXCEPT_MASK)) ACE_SET_BITS (existing_masks, FD_OOB); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::ACCEPT_MASK)) ACE_SET_BITS (existing_masks, FD_ACCEPT); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::CONNECT_MASK)) ACE_SET_BITS (existing_masks, FD_CONNECT); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::QOS_MASK)) ACE_SET_BITS (existing_masks, FD_QOS); if (ACE_BIT_ENABLED (change_masks, ACE_Event_Handler::GROUP_QOS_MASK)) ACE_SET_BITS (existing_masks, FD_GROUP_QOS); break; case ACE_Reactor::GET_MASK: // The work for this operation is done in all cases at the // begining of the function. ACE_UNUSED_ARG (change_masks); break; } return old_masks; }

ACE_INLINE int ACE_WFMO_Reactor_Handler_Repository::changes_required (  void   )  [virtual]

Check if changes to the handle set are required. Definition at line 395 of file WFMO_Reactor.inl. References handles_to_be_added_, handles_to_be_deleted_, handles_to_be_resumed_, and handles_to_be_suspended_. Referenced by ACE_WFMO_Reactor::open(), unbind(), and ACE_WFMO_Reactor::update_state(). { // Check if handles have be scheduled for additions or removal return this->handles_to_be_added_ > 0 || this->handles_to_be_deleted_ > 0 || this->handles_to_be_suspended_ > 0 || this->handles_to_be_resumed_ > 0; }

ACE_INLINE int ACE_WFMO_Reactor_Handler_Repository::close (  void   )

Close down the handler repository. Definition at line 329 of file WFMO_Reactor.inl. References unbind_all(). Referenced by ACE_WFMO_Reactor::close(). { // Let all the handlers know that the <WFMO_Reactor> is closing down this->unbind_all (); return 0; }

ACE_INLINE ACE_WFMO_Reactor_Handler_Repository::Current_Info * ACE_WFMO_Reactor_Handler_Repository::current_info (  void   )  const

Pointer to the beginning of the current array of ACE_Event_Handler *'s. Definition at line 353 of file WFMO_Reactor.inl. References current_info_, ACE_WFMO_Reactor::owner_i(), ACE_Thread::self(), and wfmo_reactor_. Referenced by ACE_WFMO_Reactor::complex_dispatch_handler(), ACE_WFMO_Reactor::dispatch_handler(), and ACE_WFMO_Reactor::simple_dispatch_handler(). { if (ACE_Thread::self () == this->wfmo_reactor_.owner_i ()) return this->current_info_; else return this->current_info_ + 1; }

void ACE_WFMO_Reactor_Handler_Repository::dump (  void   )  const

Dump the state of an object. Definition at line 992 of file WFMO_Reactor.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, current_info_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::dump(), ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::dump(), ACE_WFMO_Reactor_Handler_Repository::Current_Info::dump(), handles_to_be_added_, LM_DEBUG, suspended_handles_, and to_be_added_info_. Referenced by ACE_WFMO_Reactor::dump(). { #if defined (ACE_HAS_DUMP) size_t i = 0; ACE_TRACE ("ACE_WFMO_Reactor_Handler_Repository::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("Max size = %d\n"), this->max_size_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("Current info table\n\n"))); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\tSize = %d\n"), this->max_handlep1_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\tHandles to be suspended = %d\n"), this->handles_to_be_suspended_)); for (i = 0; i < this->max_handlep1_; ++i) this->current_info_[i].dump (this->current_handles_[i]); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n"))); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("To-be-added info table\n\n"))); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\tSize = %d\n"), this->handles_to_be_added_)); for (i = 0; i < this->handles_to_be_added_; ++i) this->to_be_added_info_[i].dump (); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n"))); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("Suspended info table\n\n"))); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\tSize = %d\n"), this->suspended_handles_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\tHandles to be resumed = %d\n"), this->handles_to_be_resumed_)); for (i = 0; i < this->suspended_handles_; ++i) this->current_suspended_info_[i].dump (); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n"))); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("Total handles to be deleted = %d\n"), this->handles_to_be_deleted_)); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_HAS_DUMP */ }

ACE_Event_Handler * ACE_WFMO_Reactor_Handler_Repository::find_handler (  ACE_HANDLE  handle  )

Return the Event_Handler associated with . Return 0 if is not registered. Definition at line 1534 of file WFMO_Reactor.cpp. References handler(). Referenced by ACE_WFMO_Reactor::find_handler(). { long existing_masks_ignored = 0; return this->handler (handle, existing_masks_ignored); }

ACE_Event_Handler * ACE_WFMO_Reactor_Handler_Repository::handler (  ACE_HANDLE  handle, long &  existing_masks )

Check to see if is associated with a valid Event_Handler. Return Event_Handler and associated masks. Definition at line 1542 of file WFMO_Reactor.cpp. References ACE_Event_Handler::add_reference(), current_handles_, current_info_, current_suspended_info_, handles_to_be_added_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, suspended_handles_, and to_be_added_info_. { int found = 0; size_t i = 0; ACE_Event_Handler *event_handler = 0; existing_masks = 0; // Look for the handle first // First go through the current entries // // Look for all entries in the current handles for matching handle // (except those that have been scheduled for deletion) for (i = 0; i < this->max_handlep1_ && !found; ++i) if ((handle == this->current_info_[i].io_handle_ || handle == this->current_handles_[i]) && !this->current_info_[i].delete_entry_) { found = 1; event_handler = this->current_info_[i].event_handler_; existing_masks = this->current_info_[i].network_events_; } // Then pass through the suspended handles // // Look for all entries in the suspended handles for matching handle // (except those that have been scheduled for deletion) for (i = 0; i < this->suspended_handles_ && !found; ++i) if ((handle == this->current_suspended_info_[i].io_handle_ || handle == this->current_suspended_info_[i].event_handle_) && !this->current_suspended_info_[i].delete_entry_) { found = 1; event_handler = this->current_suspended_info_[i].event_handler_; existing_masks = this->current_suspended_info_[i].network_events_; } // Then check the to_be_added handles // // Look for all entries in the to_be_added handles for matching // handle (except those that have been scheduled for deletion) for (i = 0; i < this->handles_to_be_added_ && !found; ++i) if ((handle == this->to_be_added_info_[i].io_handle_ || handle == this->to_be_added_info_[i].event_handle_) && !this->to_be_added_info_[i].delete_entry_) { found = 1; event_handler = this->to_be_added_info_[i].event_handler_; existing_masks = this->to_be_added_info_[i].network_events_; } if (event_handler) event_handler->add_reference (); return event_handler; }

int ACE_WFMO_Reactor_Handler_Repository::handler (  ACE_HANDLE  handle, ACE_Reactor_Mask  mask, ACE_Event_Handler **  event_handler = 0 )

Check to see if is associated with a valid Event_Handler bound to . Return the associated with this if != 0. Definition at line 1601 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, FD_GROUP_QOS, FD_QOS, ACE_Event_Handler_var::handler(), and ACE_Event_Handler_var::release(). Referenced by find_handler(), and ACE_WFMO_Reactor::handler(). { long existing_masks = 0; int found = 0; ACE_Event_Handler_var safe_event_handler = this->handler (handle, existing_masks); if (safe_event_handler.handler ()) found = 1; if (!found) return -1; // Otherwise, make sure that the masks that the user is looking for // are on. if (found && ACE_BIT_ENABLED (user_masks, ACE_Event_Handler::READ_MASK)) if (!ACE_BIT_ENABLED (existing_masks, FD_READ) && !ACE_BIT_ENABLED (existing_masks, FD_CLOSE)) found = 0; if (found && ACE_BIT_ENABLED (user_masks, ACE_Event_Handler::WRITE_MASK)) if (!ACE_BIT_ENABLED (existing_masks, FD_WRITE)) found = 0; if (found && ACE_BIT_ENABLED (user_masks, ACE_Event_Handler::EXCEPT_MASK)) if (!ACE_BIT_ENABLED (existing_masks, FD_OOB)) found = 0; if (found && ACE_BIT_ENABLED (user_masks, ACE_Event_Handler::ACCEPT_MASK)) if (!ACE_BIT_ENABLED (existing_masks, FD_ACCEPT)) found = 0; if (found && ACE_BIT_ENABLED (user_masks, ACE_Event_Handler::CONNECT_MASK)) if (!ACE_BIT_ENABLED (existing_masks, FD_CONNECT)) found = 0; if (found && ACE_BIT_ENABLED (user_masks, ACE_Event_Handler::QOS_MASK)) if (!ACE_BIT_ENABLED (existing_masks, FD_QOS)) found = 0; if (found && ACE_BIT_ENABLED (user_masks, ACE_Event_Handler::GROUP_QOS_MASK)) if (!ACE_BIT_ENABLED (existing_masks, FD_GROUP_QOS)) found = 0; if (found && user_event_handler) *user_event_handler = safe_event_handler.release (); if (found) return 0; else return -1; }

ACE_INLINE ACE_HANDLE * ACE_WFMO_Reactor_Handler_Repository::handles (  void   )  const

Pointer to the beginning of the current array of ACE_HANDLE 's. Definition at line 338 of file WFMO_Reactor.inl. References current_handles_, ACE_WFMO_Reactor::owner_i(), ACE_Thread::self(), and wfmo_reactor_. Referenced by ACE_WFMO_Reactor::dispatch_handler(), ACE_WFMO_Reactor::poll_remaining_handles(), ACE_Msg_WFMO_Reactor::poll_remaining_handles(), ACE_WFMO_Reactor::wait_for_multiple_events(), and ACE_Msg_WFMO_Reactor::wait_for_multiple_events(). { // This code is probably too subtle to be useful in the long run... // The basic idea is that all threads wait on all user handles plus // the <wakeup_all_threads_> handle. The owner thread additional // waits on the <notify_> handle. This is to ensure that only the // <owner_> thread get to expire timers and handle event on the // notify pipe. if (ACE_Thread::self () == this->wfmo_reactor_.owner_i ()) return this->current_handles_; else return this->current_handles_ + 1; }

ACE_INLINE int ACE_WFMO_Reactor_Handler_Repository::invalid_handle (  ACE_HANDLE  handle  )  const

Definition at line 380 of file WFMO_Reactor.inl. References ACE_TRACE. Referenced by bind_i(), ACE_WFMO_Reactor::mask_ops_i(), ACE_WFMO_Reactor::register_handler_i(), and unbind(). { ACE_TRACE ("ACE_WFMO_Reactor_Handler_Repository::invalid_handle"); // It's too expensive to perform more exhaustive validity checks on // Win32 due to the way that they implement SOCKET HANDLEs. if (handle == ACE_INVALID_HANDLE) { errno = EINVAL; return 1; } else return 0; }

ACE_INLINE int ACE_WFMO_Reactor_Handler_Repository::make_changes (  void   )  [virtual]

Make changes to the handle set. Definition at line 405 of file WFMO_Reactor.inl. References make_changes_in_current_infos(), make_changes_in_suspension_infos(), and make_changes_in_to_be_added_infos(). Referenced by ACE_WFMO_Reactor::open(), ACE_WFMO_Reactor::update_state(), and ACE_WFMO_Reactor::~ACE_WFMO_Reactor(). { // This method must ONLY be called by the // <WFMO_Reactor->change_state_thread_>. We therefore assume that // there will be no contention for this method and hence no guards // are neccessary. // Deletions and suspensions in current_info_ this->make_changes_in_current_infos (); // Deletions and resumptions in current_suspended_info_ this->make_changes_in_suspension_infos (); // Deletions in to_be_added_info_, or transfers to current_info_ or // current_suspended_info_ from to_be_added_info_ this->make_changes_in_to_be_added_infos (); return 0; }

int ACE_WFMO_Reactor_Handler_Repository::make_changes_in_current_infos (  void   )

Deletions and suspensions in current_info_. Definition at line 678 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, current_handles_, current_info_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_OS::event_destroy(), ACE_Event_Handler::handle_close(), handles_to_be_deleted_, handles_to_be_suspended_, ACE_Event_Handler::reference_counting_policy(), ACE_Event_Handler::remove_reference(), ACE_WFMO_Reactor_Handler_Repository::Current_Info::reset(), ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::set(), ACE_WFMO_Reactor_Handler_Repository::Current_Info::suspend_entry_, and suspended_handles_. Referenced by make_changes(). { // Go through the entire valid array and check for all handles that // have been schedule for deletion if (this->handles_to_be_deleted_ > 0 || this->handles_to_be_suspended_ > 0) { size_t i = 0; while (i < this->max_handlep1_) { // This stuff is necessary here, since we should not make // the upcall until all the internal data structures have // been updated. This is to protect against upcalls that // try to deregister again. ACE_HANDLE handle = ACE_INVALID_HANDLE; ACE_Reactor_Mask masks = ACE_Event_Handler::NULL_MASK; ACE_Event_Handler *event_handler = 0; // See if this entry is scheduled for deletion if (this->current_info_[i].delete_entry_) { // Calling the <handle_close> method here will ensure that we // will only call it once per deregistering <Event_Handler>. // This is essential in the case when the <Event_Handler> will // do something like delete itself and we have multiple // threads in WFMO_Reactor. // // Make sure that the DONT_CALL mask is not set masks = this->current_info_[i].close_masks_; if (ACE_BIT_ENABLED (masks, ACE_Event_Handler::DONT_CALL) == 0) { // Grab the correct handle depending on the type entry if (this->current_info_[i].io_entry_) handle = this->current_info_[i].io_handle_; else handle = this->current_handles_[i]; // Event handler event_handler = this->current_info_[i].event_handler_; } // If <WFMO_Reactor> created the event, we need to clean it up if (this->current_info_[i].delete_event_) ACE_OS::event_destroy (&this->current_handles_[i]); // Reduce count by one --this->handles_to_be_deleted_; } // See if this entry is scheduled for suspension else if (this->current_info_[i].suspend_entry_) { this->current_suspended_info_ [this->suspended_handles_].set (this->current_handles_[i], this->current_info_[i]); // Increase number of suspended handles ++this->suspended_handles_; // Reduce count by one --this->handles_to_be_suspended_; } // See if this entry is scheduled for deletion or suspension // If so we need to clean up if (this->current_info_[i].delete_entry_ || this->current_info_[i].suspend_entry_ ) { size_t last_valid_slot = this->max_handlep1_ - 1; // If this is the last handle in the set, no need to swap // places. Simply remove it. if (i < last_valid_slot) // Swap this handle with the last valid handle { // Struct copy this->current_info_[i] = this->current_info_[last_valid_slot]; this->current_handles_[i] = this->current_handles_[last_valid_slot]; } // Reset the info in this slot this->current_info_[last_valid_slot].reset (); this->current_handles_[last_valid_slot] = ACE_INVALID_HANDLE; --this->max_handlep1_; } else { // This current entry is not up for deletion or // suspension. Proceed to the next entry in the current // handles. ++i; } // Now that all internal structures have been updated, make // the upcall. if (event_handler != 0) { int requires_reference_counting = event_handler->reference_counting_policy ().value () == ACE_Event_Handler::Reference_Counting_Policy::ENABLED; event_handler->handle_close (handle, masks); if (requires_reference_counting) { event_handler->remove_reference (); } } } } return 0; }

int ACE_WFMO_Reactor_Handler_Repository::make_changes_in_suspension_infos (  void   )

Deletions and resumptions in current_suspended_info_. Definition at line 790 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, current_handles_, current_info_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_OS::event_destroy(), ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::event_handle_, ACE_Event_Handler::handle_close(), handles_to_be_deleted_, handles_to_be_resumed_, ACE_Event_Handler::reference_counting_policy(), ACE_Event_Handler::remove_reference(), ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::reset(), ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::resume_entry_, ACE_WFMO_Reactor_Handler_Repository::Current_Info::set(), and suspended_handles_. Referenced by make_changes(). { // Go through the <suspended_handle> array if (this->handles_to_be_deleted_ > 0 || this->handles_to_be_resumed_ > 0) { size_t i = 0; while (i < this->suspended_handles_) { // This stuff is necessary here, since we should not make // the upcall until all the internal data structures have // been updated. This is to protect against upcalls that // try to deregister again. ACE_HANDLE handle = ACE_INVALID_HANDLE; ACE_Reactor_Mask masks = ACE_Event_Handler::NULL_MASK; ACE_Event_Handler *event_handler = 0; // See if this entry is scheduled for deletion if (this->current_suspended_info_[i].delete_entry_) { // Calling the <handle_close> method here will ensure that we // will only call it once per deregistering <Event_Handler>. // This is essential in the case when the <Event_Handler> will // do something like delete itself and we have multiple // threads in WFMO_Reactor. // // Make sure that the DONT_CALL mask is not set masks = this->current_suspended_info_[i].close_masks_; if (ACE_BIT_ENABLED (masks, ACE_Event_Handler::DONT_CALL) == 0) { // Grab the correct handle depending on the type entry if (this->current_suspended_info_[i].io_entry_) handle = this->current_suspended_info_[i].io_handle_; else handle = this->current_suspended_info_[i].event_handle_; // Upcall event_handler = this->current_suspended_info_[i].event_handler_; } // If <WFMO_Reactor> created the event, we need to clean it up if (this->current_suspended_info_[i].delete_event_) ACE_OS::event_destroy (&this->current_suspended_info_[i].event_handle_); // Reduce count by one --this->handles_to_be_deleted_; } else if (this->current_suspended_info_[i].resume_entry_) { // Add to the end of the current handles set this->current_handles_[this->max_handlep1_] = this->current_suspended_info_[i].event_handle_; // Struct copy this->current_info_[this->max_handlep1_].set (this->current_suspended_info_[i]); ++this->max_handlep1_; // Reduce count by one --this->handles_to_be_resumed_; } // If an entry needs to be removed, either because it // was deleted or resumed, remove it now before doing // the upcall. if (this->current_suspended_info_[i].resume_entry_ || this->current_suspended_info_[i].delete_entry_) { size_t last_valid_slot = this->suspended_handles_ - 1; // Net effect is that we're removing an entry and // compressing the list from the end. So, if removing // an entry from the middle, copy the last valid one to the // removed slot. Reset the end and decrement the number // of suspended handles. if (i < last_valid_slot) // Struct copy this->current_suspended_info_[i] = this->current_suspended_info_[last_valid_slot]; this->current_suspended_info_[last_valid_slot].reset (); --this->suspended_handles_; } else { // This current entry is not up for deletion or // resumption. Proceed to the next entry in the // suspended handles. ++i; } // Now that all internal structures have been updated, make // the upcall. if (event_handler != 0) { int requires_reference_counting = event_handler->reference_counting_policy ().value () == ACE_Event_Handler::Reference_Counting_Policy::ENABLED; event_handler->handle_close (handle, masks); if (requires_reference_counting) { event_handler->remove_reference (); } } } } return 0; }

int ACE_WFMO_Reactor_Handler_Repository::make_changes_in_to_be_added_infos (  void   )

Deletions in to_be_added_info_, or transfers to current_info_ or current_suspended_info_ from to_be_added_info_ Definition at line 898 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, current_handles_, current_info_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_OS::event_destroy(), ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::event_handle_, ACE_Event_Handler::handle_close(), handles_to_be_added_, handles_to_be_deleted_, handles_to_be_suspended_, ACE_Event_Handler::reference_counting_policy(), ACE_Event_Handler::remove_reference(), ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::reset(), ACE_WFMO_Reactor_Handler_Repository::Current_Info::set(), ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::set(), ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::suspend_entry_, suspended_handles_, and to_be_added_info_. Referenced by make_changes(). { // Go through the <to_be_added_*> arrays for (size_t i = 0; i < this->handles_to_be_added_; ++i) { // This stuff is necessary here, since we should not make // the upcall until all the internal data structures have // been updated. This is to protect against upcalls that // try to deregister again. ACE_HANDLE handle = ACE_INVALID_HANDLE; ACE_Reactor_Mask masks = ACE_Event_Handler::NULL_MASK; ACE_Event_Handler *event_handler = 0; // See if this entry is scheduled for deletion if (this->to_be_added_info_[i].delete_entry_) { // Calling the <handle_close> method here will ensure that we // will only call it once per deregistering <Event_Handler>. // This is essential in the case when the <Event_Handler> will // do something like delete itself and we have multiple // threads in WFMO_Reactor. // // Make sure that the DONT_CALL mask is not set masks = this->to_be_added_info_[i].close_masks_; if (ACE_BIT_ENABLED (masks, ACE_Event_Handler::DONT_CALL) == 0) { // Grab the correct handle depending on the type entry if (this->to_be_added_info_[i].io_entry_) handle = this->to_be_added_info_[i].io_handle_; else handle = this->to_be_added_info_[i].event_handle_; // Upcall event_handler = this->to_be_added_info_[i].event_handler_; } // If <WFMO_Reactor> created the event, we need to clean it up if (this->to_be_added_info_[i].delete_event_) ACE_OS::event_destroy (&this->to_be_added_info_[i].event_handle_); // Reduce count by one --this->handles_to_be_deleted_; } // See if this entry is scheduled for suspension else if (this->to_be_added_info_[i].suspend_entry_) { this->current_suspended_info_ [this->suspended_handles_].set (this->to_be_added_info_[i].event_handle_, this->to_be_added_info_[i]); // Increase number of suspended handles ++this->suspended_handles_; // Reduce count by one --this->handles_to_be_suspended_; } // If neither of the two flags are on, add to current else { // Add to the end of the current handles set this->current_handles_[this->max_handlep1_] = this->to_be_added_info_[i].event_handle_; // Struct copy this->current_info_[this->max_handlep1_].set (this->to_be_added_info_[i]); ++this->max_handlep1_; } // Reset the <to_be_added_info_> this->to_be_added_info_[i].reset (); // Now that all internal structures have been updated, make the // upcall. if (event_handler != 0) { int requires_reference_counting = event_handler->reference_counting_policy ().value () == ACE_Event_Handler::Reference_Counting_Policy::ENABLED; event_handler->handle_close (handle, masks); if (requires_reference_counting) { event_handler->remove_reference (); } } } // Since all to be added handles have been taken care of, reset the // counter this->handles_to_be_added_ = 0; return 0; }

ACE_INLINE DWORD ACE_WFMO_Reactor_Handler_Repository::max_handlep1 (  void   )  const

Maximum ACE_HANDLE value, plus 1. Definition at line 362 of file WFMO_Reactor.inl. References ACE_WFMO_Reactor::owner_i(), ACE_Thread::self(), and wfmo_reactor_. Referenced by ACE_WFMO_Reactor::dispatch_handles(). { if (ACE_Thread::self () == this->wfmo_reactor_.owner_i ()) return this->max_handlep1_; else return this->max_handlep1_ - 1; }

int ACE_WFMO_Reactor_Handler_Repository::modify_network_events_i (  ACE_HANDLE  io_handle, ACE_Reactor_Mask  new_masks, ACE_Reactor_Mask &  old_masks, long &  new_network_events, ACE_HANDLE &  event_handle, int &  delete_event, int  operation )

This method is used to calculate the network mask after a mask_op request to . Note that because the may already be in the handler repository, we may have to find the old event and the old network events Definition at line 1470 of file WFMO_Reactor.cpp. References ACE_Reactor_Mask, bit_ops(), current_handles_, current_info_, current_suspended_info_, handles_to_be_added_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, suspended_handles_, and to_be_added_info_. Referenced by ACE_WFMO_Reactor::mask_ops_i(), and ACE_WFMO_Reactor::register_handler_i(). { long *modified_network_events = &new_network_events; int found = 0; size_t i; // First go through the current entries // // Look for all entries in the current handles for matching handle // (except those that have been scheduled for deletion) for (i = 0; i < this->max_handlep1_ && !found; ++i) if (io_handle == this->current_info_[i].io_handle_ && !this->current_info_[i].delete_entry_) { found = 1; modified_network_events = &this->current_info_[i].network_events_; delete_event = this->current_info_[i].delete_event_; event_handle = this->current_handles_[i]; } // Then pass through the suspended handles // // Look for all entries in the suspended handles for matching handle // (except those that have been scheduled for deletion) for (i = 0; i < this->suspended_handles_ && !found; ++i) if (io_handle == this->current_suspended_info_[i].io_handle_ && !this->current_suspended_info_[i].delete_entry_) { found = 1; modified_network_events = &this->current_suspended_info_[i].network_events_; delete_event = this->current_suspended_info_[i].delete_event_; event_handle = this->current_suspended_info_[i].event_handle_; } // Then check the to_be_added handles // // Look for all entries in the to_be_added handles for matching // handle (except those that have been scheduled for deletion) for (i = 0; i < this->handles_to_be_added_ && !found; ++i) if (io_handle == this->to_be_added_info_[i].io_handle_ && !this->to_be_added_info_[i].delete_entry_) { found = 1; modified_network_events = &this->to_be_added_info_[i].network_events_; delete_event = this->to_be_added_info_[i].delete_event_; event_handle = this->to_be_added_info_[i].event_handle_; } old_masks = this->bit_ops (*modified_network_events, new_masks, operation); new_network_events = *modified_network_events; return found; }

int ACE_WFMO_Reactor_Handler_Repository::open (  size_t  size  )

Initialize the repository of the approriate . Definition at line 29 of file WFMO_Reactor.cpp. References ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_NEW_RETURN, current_handles_, handles_to_be_added_, handles_to_be_deleted_, handles_to_be_resumed_, handles_to_be_suspended_, LM_ERROR, and suspended_handles_. Referenced by ACE_WFMO_Reactor::open(). { if (size > MAXIMUM_WAIT_OBJECTS) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%d exceeds MAXIMUM_WAIT_OBJECTS (%d)\n"), size, MAXIMUM_WAIT_OBJECTS), -1); // Dynamic allocation ACE_NEW_RETURN (this->current_handles_, ACE_HANDLE[size], -1); ACE_NEW_RETURN (this->current_info_, Current_Info[size], -1); ACE_NEW_RETURN (this->current_suspended_info_, Suspended_Info[size], -1); ACE_NEW_RETURN (this->to_be_added_info_, To_Be_Added_Info[size], -1); // Initialization this->max_size_ = size; this->max_handlep1_ = 0; this->suspended_handles_ = 0; this->handles_to_be_added_ = 0; this->handles_to_be_deleted_ = 0; this->handles_to_be_suspended_ = 0; this->handles_to_be_resumed_ = 0; for (size_t i = 0; i < size; ++i) this->current_handles_[i] = ACE_INVALID_HANDLE; return 0; }

int ACE_WFMO_Reactor_Handler_Repository::remove_handler_i (  size_t  slot, ACE_Reactor_Mask  mask )

Removes the ACE_Event_Handler at from the table. Definition at line 261 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, bit_ops(), ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, current_handles_, current_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, handles_to_be_deleted_, handles_to_be_suspended_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_entry_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::network_events_, and ACE_WFMO_Reactor_Handler_Repository::Current_Info::suspend_entry_. Referenced by unbind_i(). { // I/O entries if (this->current_info_[slot].io_entry_) { // See if there are other events that the <Event_Handler> is // interested in this->bit_ops (this->current_info_[slot].network_events_, to_be_removed_masks, ACE_Reactor::CLR_MASK); // Disassociate/Reassociate the event from/with the I/O handle. // This will depend on the value of remaining set of network // events that the <event_handler> is interested in. I don't // think we can do anything about errors here, so I will not // check this. ::WSAEventSelect ((SOCKET) this->current_info_[slot].io_handle_, this->current_handles_[slot], this->current_info_[slot].network_events_); } // Normal event entries. else if (ACE_BIT_ENABLED (to_be_removed_masks, ACE_Event_Handler::DONT_CALL)) // Preserve DONT_CALL to_be_removed_masks = ACE_Event_Handler::DONT_CALL; else // Make sure that the <to_be_removed_masks> is the NULL_MASK to_be_removed_masks = ACE_Event_Handler::NULL_MASK; // If this event was marked for suspension, undo the suspension flag // and reduce the to be suspended count. if (this->current_info_[slot].suspend_entry_) { // Undo suspension this->current_info_[slot].suspend_entry_ = 0; // Decrement the handle count --this->handles_to_be_suspended_; } // If there are no more events that the <Event_Handler> is // interested in, or this is a non-I/O entry, schedule the // <Event_Handler> for removal if (this->current_info_[slot].network_events_ == 0) { // Mark to be deleted this->current_info_[slot].delete_entry_ = 1; // Remember the mask this->current_info_[slot].close_masks_ = to_be_removed_masks; // Increment the handle count ++this->handles_to_be_deleted_; } // Since it is not a complete removal, we'll call handle_close // for all the masks that were removed. This does not change // the internal state of the reactor. // // Note: this condition only applies to I/O entries else if (ACE_BIT_ENABLED (to_be_removed_masks, ACE_Event_Handler::DONT_CALL) == 0) { ACE_HANDLE handle = this->current_info_[slot].io_handle_; this->current_info_[slot].event_handler_->handle_close (handle, to_be_removed_masks); } return 0; }

int ACE_WFMO_Reactor_Handler_Repository::remove_suspended_handler_i (  size_t  slot, ACE_Reactor_Mask  mask )

Removes the ACE_Event_Handler at from the table. Definition at line 329 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, bit_ops(), ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::event_handle_, handles_to_be_deleted_, handles_to_be_resumed_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_entry_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::network_events_, and ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::resume_entry_. Referenced by unbind_i(). { // I/O entries if (this->current_suspended_info_[slot].io_entry_) { // See if there are other events that the <Event_Handler> is // interested in this->bit_ops (this->current_suspended_info_[slot].network_events_, to_be_removed_masks, ACE_Reactor::CLR_MASK); // Disassociate/Reassociate the event from/with the I/O handle. // This will depend on the value of remaining set of network // events that the <event_handler> is interested in. I don't // think we can do anything about errors here, so I will not // check this. ::WSAEventSelect ((SOCKET) this->current_suspended_info_[slot].io_handle_, this->current_suspended_info_[slot].event_handle_, this->current_suspended_info_[slot].network_events_); } // Normal event entries. else if (ACE_BIT_ENABLED (to_be_removed_masks, ACE_Event_Handler::DONT_CALL)) // Preserve DONT_CALL to_be_removed_masks = ACE_Event_Handler::DONT_CALL; else // Make sure that the <to_be_removed_masks> is the NULL_MASK to_be_removed_masks = ACE_Event_Handler::NULL_MASK; // If this event was marked for resumption, undo the resumption flag // and reduce the to be resumed count. if (this->current_suspended_info_[slot].resume_entry_) { // Undo resumption this->current_suspended_info_[slot].resume_entry_ = 0; // Decrement the handle count --this->handles_to_be_resumed_; } // If there are no more events that the <Event_Handler> is // interested in, or this is a non-I/O entry, schedule the // <Event_Handler> for removal if (this->current_suspended_info_[slot].network_events_ == 0) { // Mark to be deleted this->current_suspended_info_[slot].delete_entry_ = 1; // Remember the mask this->current_suspended_info_[slot].close_masks_ = to_be_removed_masks; // Increment the handle count ++this->handles_to_be_deleted_; } // Since it is not a complete removal, we'll call handle_close for // all the masks that were removed. This does not change the // internal state of the reactor. // // Note: this condition only applies to I/O entries else if (ACE_BIT_ENABLED (to_be_removed_masks, ACE_Event_Handler::DONT_CALL) == 0) { ACE_HANDLE handle = this->current_suspended_info_[slot].io_handle_; this->current_suspended_info_[slot].event_handler_->handle_close (handle, to_be_removed_masks); } return 0; }

int ACE_WFMO_Reactor_Handler_Repository::remove_to_be_added_handler_i (  size_t  slot, ACE_Reactor_Mask  to_be_removed_masks )

Removes the ACE_Event_Handler at from the table. Definition at line 396 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, bit_ops(), ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::event_handle_, handles_to_be_deleted_, handles_to_be_suspended_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_entry_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::network_events_, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::suspend_entry_, and to_be_added_info_. Referenced by unbind_i(). { // I/O entries if (this->to_be_added_info_[slot].io_entry_) { // See if there are other events that the <Event_Handler> is // interested in this->bit_ops (this->to_be_added_info_[slot].network_events_, to_be_removed_masks, ACE_Reactor::CLR_MASK); // Disassociate/Reassociate the event from/with the I/O handle. // This will depend on the value of remaining set of network // events that the <event_handler> is interested in. I don't // think we can do anything about errors here, so I will not // check this. ::WSAEventSelect ((SOCKET) this->to_be_added_info_[slot].io_handle_, this->to_be_added_info_[slot].event_handle_, this->to_be_added_info_[slot].network_events_); } // Normal event entries. else if (ACE_BIT_ENABLED (to_be_removed_masks, ACE_Event_Handler::DONT_CALL)) // Preserve DONT_CALL to_be_removed_masks = ACE_Event_Handler::DONT_CALL; else // Make sure that the <to_be_removed_masks> is the NULL_MASK to_be_removed_masks = ACE_Event_Handler::NULL_MASK; // If this event was marked for suspension, undo the suspension flag // and reduce the to be suspended count. if (this->to_be_added_info_[slot].suspend_entry_) { // Undo suspension this->to_be_added_info_[slot].suspend_entry_ = 0; // Decrement the handle count --this->handles_to_be_suspended_; } // If there are no more events that the <Event_Handler> is // interested in, or this is a non-I/O entry, schedule the // <Event_Handler> for removal if (this->to_be_added_info_[slot].network_events_ == 0) { // Mark to be deleted this->to_be_added_info_[slot].delete_entry_ = 1; // Remember the mask this->to_be_added_info_[slot].close_masks_ = to_be_removed_masks; // Increment the handle count ++this->handles_to_be_deleted_; } // Since it is not a complete removal, we'll call handle_close // for all the masks that were removed. This does not change // the internal state of the reactor. // // Note: this condition only applies to I/O entries else if (ACE_BIT_ENABLED (to_be_removed_masks, ACE_Event_Handler::DONT_CALL) == 0) { ACE_HANDLE handle = this->to_be_added_info_[slot].io_handle_; this->to_be_added_info_[slot].event_handler_->handle_close (handle, to_be_removed_masks); } return 0; }

int ACE_WFMO_Reactor_Handler_Repository::resume_handler_i (  ACE_HANDLE  handle, int &  changes_required )

Resume suspended entry. Definition at line 527 of file WFMO_Reactor.cpp. References current_handles_, current_info_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::event_handle_, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::event_handle_, handles_to_be_added_, handles_to_be_resumed_, handles_to_be_suspended_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::resume_entry_, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::suspend_entry_, ACE_WFMO_Reactor_Handler_Repository::Current_Info::suspend_entry_, suspended_handles_, and to_be_added_info_. Referenced by ACE_WFMO_Reactor::resume_handler(), and ACE_WFMO_Reactor::resume_handlers(). { size_t i = 0; // Go through all the handles looking for <handle>. Even if we find // it, we continue through the rest of the list since <handle> could // appear multiple times. All handles are checked. // Check the current entries first. for (i = 0; i < this->max_handlep1_; ++i) // Since the handle can either be the event or the I/O handle, // we have to check both if ((this->current_handles_[i] == handle || this->current_info_[i].io_handle_ == handle) && // Make sure that the suspension is not already undone this->current_info_[i].suspend_entry_) { // Undo suspension this->current_info_[i].suspend_entry_ = 0; // Decrement the handle count --this->handles_to_be_suspended_; // Changes will be required changes_required = 1; } // Then check the suspended entries. for (i = 0; i < this->suspended_handles_; ++i) // Since the handle can either be the event or the I/O handle, // we have to check both if ((this->current_suspended_info_[i].event_handle_ == handle || this->current_suspended_info_[i].io_handle_ == handle) && // Make sure that it is not already marked for resumption !this->current_suspended_info_[i].resume_entry_) { // Mark to be resumed this->current_suspended_info_[i].resume_entry_ = 1; // Increment the handle count ++this->handles_to_be_resumed_; // Changes will be required changes_required = 1; } // Then check the to_be_added entries. for (i = 0; i < this->handles_to_be_added_; ++i) // Since the handle can either be the event or the I/O handle, // we have to check both if ((this->to_be_added_info_[i].io_handle_ == handle || this->to_be_added_info_[i].event_handle_ == handle) && // Make sure that the suspension is not already undone this->to_be_added_info_[i].suspend_entry_) { // Undo suspension this->to_be_added_info_[i].suspend_entry_ = 0; // Decrement the handle count --this->handles_to_be_suspended_; // Changes will be required changes_required = 1; } return 0; }

ACE_INLINE int ACE_WFMO_Reactor_Handler_Repository::scheduled_for_deletion (  size_t  slot  )  const

Check to see if has been scheduled for deletion. Definition at line 371 of file WFMO_Reactor.inl. References current_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_WFMO_Reactor::owner_i(), ACE_Thread::self(), and wfmo_reactor_. Referenced by ACE_WFMO_Reactor::complex_dispatch_handler(), and ACE_WFMO_Reactor::dispatch_handler(). { if (ACE_Thread::self () == this->wfmo_reactor_.owner_i ()) return this->current_info_[slot].delete_entry_ == 1; else return this->current_info_[slot + 1].delete_entry_ == 1; }

int ACE_WFMO_Reactor_Handler_Repository::suspend_handler_i (  ACE_HANDLE  handle, int &  changes_required )

Temporarily suspend entry. Definition at line 463 of file WFMO_Reactor.cpp. References current_handles_, current_info_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::event_handle_, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::event_handle_, handles_to_be_added_, handles_to_be_resumed_, handles_to_be_suspended_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::resume_entry_, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::suspend_entry_, ACE_WFMO_Reactor_Handler_Repository::Current_Info::suspend_entry_, suspended_handles_, and to_be_added_info_. Referenced by ACE_WFMO_Reactor::suspend_handler(), and ACE_WFMO_Reactor::suspend_handlers(). { size_t i = 0; // Go through all the handles looking for <handle>. Even if we find // it, we continue through the rest of the list since <handle> could // appear multiple times. All handles are checked. // Check the current entries first. for (i = 0; i < this->max_handlep1_; ++i) // Since the handle can either be the event or the I/O handle, // we have to check both if ((this->current_handles_[i] == handle || this->current_info_[i].io_handle_ == handle) && // Make sure that it is not already marked for suspension !this->current_info_[i].suspend_entry_) { // Mark to be suspended this->current_info_[i].suspend_entry_ = 1; // Increment the handle count ++this->handles_to_be_suspended_; // Changes will be required changes_required = 1; } // Then check the suspended entries. for (i = 0; i < this->suspended_handles_; ++i) // Since the handle can either be the event or the I/O handle, // we have to check both if ((this->current_suspended_info_[i].event_handle_ == handle || this->current_suspended_info_[i].io_handle_ == handle) && // Make sure that the resumption is not already undone this->current_suspended_info_[i].resume_entry_) { // Undo resumption this->current_suspended_info_[i].resume_entry_ = 0; // Decrement the handle count --this->handles_to_be_resumed_; // Changes will be required changes_required = 1; } // Then check the to_be_added entries. for (i = 0; i < this->handles_to_be_added_; ++i) // Since the handle can either be the event or the I/O handle, // we have to check both if ((this->to_be_added_info_[i].io_handle_ == handle || this->to_be_added_info_[i].event_handle_ == handle) && // Make sure that it is not already marked for suspension !this->to_be_added_info_[i].suspend_entry_) { // Mark to be suspended this->to_be_added_info_[i].suspend_entry_ = 1; // Increment the handle count ++this->handles_to_be_suspended_; // Changes will be required changes_required = 1; } return 0; }

ACE_INLINE int ACE_WFMO_Reactor_Handler_Repository::unbind (  ACE_HANDLE  , ACE_Reactor_Mask  mask )

Remove the binding of ACE_HANDLE in accordance with the . Definition at line 426 of file WFMO_Reactor.inl. References ACE_GUARD_RETURN, ACE_Reactor_Mask, changes_required(), invalid_handle(), unbind_i(), ACE_WFMO_Reactor::wakeup_all_threads(), and wfmo_reactor_. Referenced by ACE_WFMO_Reactor::complex_dispatch_handler(), ACE_WFMO_Reactor::remove_handler(), and ACE_WFMO_Reactor::simple_dispatch_handler(). { if (this->invalid_handle (handle)) return -1; ACE_GUARD_RETURN (ACE_Process_Mutex, ace_mon, this->wfmo_reactor_.lock_, -1); int changes_required = 0; int const result = this->unbind_i (handle, mask, changes_required); if (changes_required) // Wake up all threads in WaitForMultipleObjects so that they can // reconsult the handle set this->wfmo_reactor_.wakeup_all_threads (); return result; }

void ACE_WFMO_Reactor_Handler_Repository::unbind_all (  void   )

Remove all bindings of <ACE_HANDLE, ACE_Event_Handler> tuples. Definition at line 591 of file WFMO_Reactor.cpp. References ACE_GUARD, handles_to_be_added_, suspended_handles_, unbind_i(), ACE_WFMO_Reactor::wakeup_all_threads(), and wfmo_reactor_. Referenced by close(). { { ACE_GUARD (ACE_Process_Mutex, ace_mon, this->wfmo_reactor_.lock_); int dummy; size_t i; // Remove all the current handlers for (i = 0; i < this->max_handlep1_; ++i) this->unbind_i (this->current_handles_[i], ACE_Event_Handler::ALL_EVENTS_MASK, dummy); // Remove all the suspended handlers for (i = 0; i < this->suspended_handles_; ++i) this->unbind_i (this->current_suspended_info_[i].event_handle_, ACE_Event_Handler::ALL_EVENTS_MASK, dummy); // Remove all the to_be_added handlers for (i = 0; i < this->handles_to_be_added_; ++i) this->unbind_i (this->to_be_added_info_[i].event_handle_, ACE_Event_Handler::ALL_EVENTS_MASK, dummy); } // The guard is released here // Wake up all threads in WaitForMultipleObjects so that they can // reconsult the handle set this->wfmo_reactor_.wakeup_all_threads (); }

int ACE_WFMO_Reactor_Handler_Repository::unbind_i (  ACE_HANDLE  , ACE_Reactor_Mask  mask, int &  changes_required )

Non-lock-grabbing version of . Definition at line 189 of file WFMO_Reactor.cpp. References ACE_Reactor_Mask, current_handles_, current_info_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::event_handle_, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::event_handle_, handles_to_be_added_, handles_to_be_deleted_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, remove_handler_i(), remove_suspended_handler_i(), remove_to_be_added_handler_i(), suspended_handles_, and to_be_added_info_. Referenced by ACE_WFMO_Reactor::remove_handler(), unbind(), and unbind_all(). { int error = 0; // Remember this value; only if it changes do we need to wakeup // the other threads size_t const original_handle_count = this->handles_to_be_deleted_; int result = 0; size_t i; // Go through all the handles looking for <handle>. Even if we find // it, we continue through the rest of the list since <handle> could // appear multiple times. All handles are checked. // First check the current entries for (i = 0; i < this->max_handlep1_ && error == 0; ++i) // Since the handle can either be the event or the I/O handle, // we have to check both if ((this->current_handles_[i] == handle || this->current_info_[i].io_handle_ == handle) && // Make sure that it is not already marked for deleted !this->current_info_[i].delete_entry_) { result = this->remove_handler_i (i, mask); if (result == -1) error = 1; } // Then check the suspended entries for (i = 0; i < this->suspended_handles_ && error == 0; ++i) // Since the handle can either be the event or the I/O handle, we // have to check both if ((this->current_suspended_info_[i].io_handle_ == handle || this->current_suspended_info_[i].event_handle_ == handle) && // Make sure that it is not already marked for deleted !this->current_suspended_info_[i].delete_entry_) { result = this->remove_suspended_handler_i (i, mask); if (result == -1) error = 1; } // Then check the to_be_added entries for (i = 0; i < this->handles_to_be_added_ && error == 0; ++i) // Since the handle can either be the event or the I/O handle, // we have to check both if ((this->to_be_added_info_[i].io_handle_ == handle || this->to_be_added_info_[i].event_handle_ == handle) && // Make sure that it is not already marked for deleted !this->to_be_added_info_[i].delete_entry_) { result = this->remove_to_be_added_handler_i (i, mask); if (result == -1) error = 1; } // Only if the number of handlers to be deleted changes do we need // to wakeup the other threads if (original_handle_count < this->handles_to_be_deleted_) changes_required = 1; return error ? -1 : 0; }

---

Friends And Related Function Documentation

friend class ACE_WFMO_Reactor [friend]

Definition at line 106 of file WFMO_Reactor.h.

friend class ACE_WFMO_Reactor_Test [friend]

Definition at line 107 of file WFMO_Reactor.h.

---

Member Data Documentation

ACE_HANDLE* ACE_WFMO_Reactor_Handler_Repository::current_handles_ [protected]

Array of passed to . This is not part of the structure as the handle array needs to be passed directly to . Definition at line 449 of file WFMO_Reactor.h. Referenced by handler(), handles(), make_changes_in_current_infos(), make_changes_in_suspension_infos(), make_changes_in_to_be_added_infos(), modify_network_events_i(), open(), remove_handler_i(), resume_handler_i(), suspend_handler_i(), unbind_i(), and ~ACE_WFMO_Reactor_Handler_Repository().

Current_Info* ACE_WFMO_Reactor_Handler_Repository::current_info_ [protected]

Array of current entries in the table. Definition at line 452 of file WFMO_Reactor.h. Referenced by current_info(), dump(), handler(), make_changes_in_current_infos(), make_changes_in_suspension_infos(), make_changes_in_to_be_added_infos(), modify_network_events_i(), remove_handler_i(), resume_handler_i(), scheduled_for_deletion(), suspend_handler_i(), unbind_i(), and ~ACE_WFMO_Reactor_Handler_Repository().

Suspended_Info* ACE_WFMO_Reactor_Handler_Repository::current_suspended_info_ [protected]

Currently suspended handles. Definition at line 464 of file WFMO_Reactor.h. Referenced by dump(), handler(), make_changes_in_current_infos(), make_changes_in_suspension_infos(), make_changes_in_to_be_added_infos(), modify_network_events_i(), remove_suspended_handler_i(), resume_handler_i(), suspend_handler_i(), unbind_i(), and ~ACE_WFMO_Reactor_Handler_Repository().

size_t ACE_WFMO_Reactor_Handler_Repository::handles_to_be_added_ [protected]

Number of records to be added. Definition at line 461 of file WFMO_Reactor.h. Referenced by bind_i(), changes_required(), dump(), handler(), make_changes_in_to_be_added_infos(), modify_network_events_i(), open(), resume_handler_i(), ACE_WFMO_Reactor::resume_handlers(), suspend_handler_i(), ACE_WFMO_Reactor::suspend_handlers(), unbind_all(), and unbind_i().

size_t ACE_WFMO_Reactor_Handler_Repository::handles_to_be_deleted_ [protected]

Number of records to be deleted. Definition at line 476 of file WFMO_Reactor.h. Referenced by bind_i(), changes_required(), make_changes_in_current_infos(), make_changes_in_suspension_infos(), make_changes_in_to_be_added_infos(), open(), remove_handler_i(), remove_suspended_handler_i(), remove_to_be_added_handler_i(), and unbind_i().

size_t ACE_WFMO_Reactor_Handler_Repository::handles_to_be_resumed_ [protected]

Number of records to be resumed. Definition at line 473 of file WFMO_Reactor.h. Referenced by changes_required(), make_changes_in_suspension_infos(), open(), remove_suspended_handler_i(), resume_handler_i(), and suspend_handler_i().

size_t ACE_WFMO_Reactor_Handler_Repository::handles_to_be_suspended_ [protected]

Number of records to be suspended. Definition at line 470 of file WFMO_Reactor.h. Referenced by changes_required(), make_changes_in_current_infos(), make_changes_in_to_be_added_infos(), open(), remove_handler_i(), remove_to_be_added_handler_i(), resume_handler_i(), and suspend_handler_i().

DWORD ACE_WFMO_Reactor_Handler_Repository::max_handlep1_ [protected]

A count of the number of active handles. Definition at line 455 of file WFMO_Reactor.h. Referenced by ACE_WFMO_Reactor::suspend_handlers().

size_t ACE_WFMO_Reactor_Handler_Repository::max_size_ [protected]

Maximum number of handles. Definition at line 442 of file WFMO_Reactor.h. Referenced by ACE_WFMO_Reactor::size().

size_t ACE_WFMO_Reactor_Handler_Repository::suspended_handles_ [protected]

Number of currently suspended handles. Definition at line 467 of file WFMO_Reactor.h. Referenced by bind_i(), dump(), handler(), make_changes_in_current_infos(), make_changes_in_suspension_infos(), make_changes_in_to_be_added_infos(), modify_network_events_i(), open(), resume_handler_i(), ACE_WFMO_Reactor::resume_handlers(), suspend_handler_i(), unbind_all(), and unbind_i().

To_Be_Added_Info* ACE_WFMO_Reactor_Handler_Repository::to_be_added_info_ [protected]

Information for entries to be added. Definition at line 458 of file WFMO_Reactor.h. Referenced by bind_i(), dump(), handler(), make_changes_in_to_be_added_infos(), modify_network_events_i(), remove_to_be_added_handler_i(), resume_handler_i(), ACE_WFMO_Reactor::resume_handlers(), suspend_handler_i(), ACE_WFMO_Reactor::suspend_handlers(), unbind_i(), and ~ACE_WFMO_Reactor_Handler_Repository().

ACE_WFMO_Reactor& ACE_WFMO_Reactor_Handler_Repository::wfmo_reactor_ [protected]

Reference to our . Definition at line 439 of file WFMO_Reactor.h. Referenced by bind_i(), current_info(), handles(), max_handlep1(), scheduled_for_deletion(), unbind(), and unbind_all().

---

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

• WFMO_Reactor.h
• WFMO_Reactor.cpp
• WFMO_Reactor.inl

---