---

ACE_WFMO_Reactor_Handler_Repository Class Reference

Used to map <ACE_HANDLE>s 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 Methods
	ACE_WFMO_Reactor_Handler_Repository (ACE_WFMO_Reactor &wfmo_reactor)
	Constructor. More...
virtual	~ACE_WFMO_Reactor_Handler_Repository (void)
	Destructor. More...
int	open (size_t size)
	Initialize the repository of the approriate <size>. More...
int	close (void)
	Close down the handler repository. More...
int	bind (ACE_HANDLE, ACE_Event_Handler *)
	Bind the <ACE_Event_Handler *> to the <ACE_HANDLE>. This is for the simple event entry. More...
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)
	Insert I/O <Event_Handler> entry into the system. This method assumes that the lock are head *before* this method is invoked. More...
int	unbind (ACE_HANDLE, ACE_Reactor_Mask mask)
	Remove the binding of <ACE_HANDLE> in accordance with the <mask>. More...
int	unbind_i (ACE_HANDLE, ACE_Reactor_Mask mask, int &changes_required)
	Non-lock-grabbing version of <unbind>. More...
void	unbind_all (void)
	Remove all bindings of <ACE_HANDLE, ACE_Event_Handler> tuples. More...
int	invalid_handle (ACE_HANDLE handle) const
DWORD	max_handlep1 (void) const
	Maximum ACE_HANDLE value, plus 1. More...
ACE_HANDLE *	handles (void) const
	Pointer to the beginning of the current array of <ACE_HANDLE> *'s. More...
Current_Info *	current_info (void) const
	Pointer to the beginning of the current array of <ACE_Event_Handler> *'s. More...
virtual int	changes_required (void)
	Check if changes to the handle set are required. More...
virtual int	make_changes (void)
	Make changes to the handle set. More...
int	scheduled_for_deletion (size_t slot) const
	Check to see if <slot> has been scheduled for deletion. More...
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)
	This method is used to change the network mask left (if any) after a remove request to <WFMO_Reactor>. More...
int	suspend_handler_i (ACE_HANDLE handle, int &changes_required)
	Temporarily suspend entry. More...
int	resume_handler_i (ACE_HANDLE handle, int &changes_required)
	Resume suspended entry. More...
int	make_changes_in_current_infos (void)
	Deletions and suspensions in current_info_. More...
int	make_changes_in_suspension_infos (void)
	Deletions and resumptions in current_suspended_info_. More...
int	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_. More...
int	remove_handler_i (size_t slot, ACE_Reactor_Mask mask)
	Removes the <ACE_Event_Handler> at <slot> from the table. More...
int	remove_suspended_handler_i (size_t slot, ACE_Reactor_Mask mask)
	Removes the <ACE_Event_Handler> at <slot> from the table. More...
int	remove_to_be_added_handler_i (size_t slot, ACE_Reactor_Mask to_be_removed_masks)
	Removes the <ACE_Event_Handler> at <slot> from the table. More...
int	handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=0)
void	dump (void) const
	Dump the state of an object. More...
Protected Attributes
ACE_WFMO_Reactor &	wfmo_reactor_
	Reference to our <WFMO_Reactor>. More...
size_t	max_size_
	Maximum number of handles. More...
ACE_HANDLE *	current_handles_
Current_Info *	current_info_
	Array of current entries in the table. More...
DWORD	max_handlep1_
	A count of the number of active handles. More...
To_Be_Added_Info *	to_be_added_info_
	Information for entries to be added. More...
size_t	handles_to_be_added_
	Number of records to be added. More...
Suspended_Info *	current_suspended_info_
	Currently suspended handles. More...
size_t	suspended_handles_
	Number of currently suspended handles. More...
size_t	handles_to_be_suspended_
	Number of records to be suspended. More...
size_t	handles_to_be_resumed_
	Number of records to be resumed. More...
size_t	handles_to_be_deleted_
	Number of records to be deleted. More...
Friends
class	ACE_WFMO_Reactor
class	ACE_WFMO_Reactor_Test

---

Detailed Description

Used to map <ACE_HANDLE>s onto the appropriate <ACE_Event_Handler> * and other information.

Definition at line 96 of file WFMO_Reactor.h.

---

Constructor & Destructor Documentation

ACE_WFMO_Reactor_Handler_Repository::ACE_WFMO_Reactor_Handler_Repository (  ACE_WFMO_Reactor &    wfmo_reactor )

Constructor. Definition at line 20 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 64 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 <Event_Handler> entry into the system. This method assumes that the lock are head *before* this method is invoked. Definition at line 624 of file WFMO_Reactor.cpp. References ACE_Event_Handler::get_handle, handles_to_be_added_, handles_to_be_deleted_, invalid_handle, max_handlep1_, max_size_, 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. if (current_size < 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_++; // 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 <WFMO_Reactor>. Definition at line 74 of file WFMO_Reactor.cpp. References ACE_Event_Handler::ACCEPT_MASK, ACE_BIT_ENABLED, ACE_CLR_BITS, ACE_Reactor_Mask, ACE_SET_BITS, ACE_Reactor::ADD_MASK, ACE_Reactor::CLR_MASK, ACE_Event_Handler::CONNECT_MASK, ACE_Event_Handler::EXCEPT_MASK, FD_GROUP_QOS, FD_QOS, ACE_Reactor::GET_MASK, ACE_Event_Handler::GROUP_QOS_MASK, ACE_Event_Handler::NULL_MASK, ACE_Event_Handler::QOS_MASK, ACE_Event_Handler::READ_MASK, ACE_Reactor::SET_MASK, and ACE_Event_Handler::WRITE_MASK. 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 382 of file WFMO_Reactor.i. References handles_to_be_added_, handles_to_be_deleted_, handles_to_be_resumed_, and handles_to_be_suspended_. Referenced by ACE_WFMO_Reactor::open, resume_handler_i, suspend_handler_i, unbind, unbind_i, 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 316 of file WFMO_Reactor.i. 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 340 of file WFMO_Reactor.i. 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 935 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, max_handlep1_, suspended_handles_, and to_be_added_info_. Referenced by ACE_WFMO_Reactor::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)); }

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

Check to see if <handle> is associated with a valid Event_Handler bound to <mask>. Return the <event_handler> associated with this <handler> if <event_handler> != 0. Definition at line 1472 of file WFMO_Reactor.cpp. References ACE_Event_Handler::ACCEPT_MASK, ACE_BIT_ENABLED, ACE_Reactor_Mask, ACE_Event_Handler::CONNECT_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_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::event_handler_, ACE_Event_Handler::EXCEPT_MASK, FD_GROUP_QOS, FD_QOS, ACE_Event_Handler::GROUP_QOS_MASK, handles_to_be_added_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, max_handlep1_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::network_events_, ACE_Event_Handler::QOS_MASK, ACE_Event_Handler::READ_MASK, suspended_handles_, to_be_added_info_, and ACE_Event_Handler::WRITE_MASK. Referenced by ACE_WFMO_Reactor::handler. { int found = 0; size_t i = 0; ACE_Event_Handler *event_handler = 0; long 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 the handle is not found, return failure. 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 = event_handler; 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 325 of file WFMO_Reactor.i. 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 367 of file WFMO_Reactor.i. 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 392 of file WFMO_Reactor.i. 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 670 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_WFMO_Reactor_Handler_Repository::Common_Info::delete_event_, ACE_Event_Handler::DONT_CALL, ACE_OS::event_destroy, ACE_WFMO_Reactor_Handler_Repository::Common_Info::event_handler_, ACE_Event_Handler::handle_close, 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_, max_handlep1_, ACE_Event_Handler::NULL_MASK, ACE_WFMO_Reactor_Handler_Repository::Current_Info::reset, 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) { for (size_t i = 0; i < this->max_handlep1_; 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->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_--; } // Now that all internal structures have been updated, make // the upcall. if (event_handler != 0) event_handler->handle_close (handle, masks); } } return 0; }

int ACE_WFMO_Reactor_Handler_Repository::make_changes_in_suspension_infos (  void    )

Deletions and resumptions in current_suspended_info_. Definition at line 763 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_WFMO_Reactor_Handler_Repository::Common_Info::delete_event_, ACE_Event_Handler::DONT_CALL, ACE_OS::event_destroy, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::event_handle_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::event_handler_, ACE_Event_Handler::handle_close, 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_, max_handlep1_, ACE_Event_Handler::NULL_MASK, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::reset, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::resume_entry_, 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) { for (size_t i = 0; i < this->suspended_handles_; 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->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_--; } // Now that all internal structures have been updated, make // the upcall. if (event_handler != 0) event_handler->handle_close (handle, masks); } } 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 852 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_WFMO_Reactor_Handler_Repository::Common_Info::delete_event_, ACE_Event_Handler::DONT_CALL, ACE_OS::event_destroy, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::event_handle_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::event_handler_, ACE_Event_Handler::handle_close, handles_to_be_added_, 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_, max_handlep1_, ACE_Event_Handler::NULL_MASK, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::reset, 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) event_handler->handle_close (handle, masks); } // 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 349 of file WFMO_Reactor.i. References max_handlep1_, 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 <WFMO_Reactor>. Note that because the <Event_Handler> may already be in the handler repository, we may have to find the old event and the old network events Definition at line 1408 of file WFMO_Reactor.cpp. References ACE_Reactor_Mask, bit_ops, current_handles_, current_info_, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_event_, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::event_handle_, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::event_handle_, handles_to_be_added_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::io_handle_, max_handlep1_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::network_events_, 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 <size>. Definition at line 26 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, max_handlep1_, max_size_, 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 <slot> from the table. Definition at line 258 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, bit_ops, ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, ACE_Reactor::CLR_MASK, current_handles_, current_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_Event_Handler::DONT_CALL, ACE_WFMO_Reactor_Handler_Repository::Common_Info::event_handler_, ACE_Event_Handler::handle_close, 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_Event_Handler::NULL_MASK, 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 <slot> from the table. Definition at line 326 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, bit_ops, ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, ACE_Reactor::CLR_MASK, current_suspended_info_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_Event_Handler::DONT_CALL, ACE_WFMO_Reactor_Handler_Repository::Suspended_Info::event_handle_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::event_handler_, ACE_Event_Handler::handle_close, 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_, ACE_Event_Handler::NULL_MASK, 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 <slot> from the table. Definition at line 393 of file WFMO_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, bit_ops, ACE_WFMO_Reactor_Handler_Repository::Common_Info::close_masks_, ACE_Reactor::CLR_MASK, ACE_WFMO_Reactor_Handler_Repository::Common_Info::delete_entry_, ACE_Event_Handler::DONT_CALL, ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info::event_handle_, ACE_WFMO_Reactor_Handler_Repository::Common_Info::event_handler_, ACE_Event_Handler::handle_close, 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_Event_Handler::NULL_MASK, 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 524 of file WFMO_Reactor.cpp. References changes_required, 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_, max_handlep1_, 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 <slot> has been scheduled for deletion. Definition at line 358 of file WFMO_Reactor.i. 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 460 of file WFMO_Reactor.cpp. References changes_required, 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_, max_handlep1_, 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 <mask>. Definition at line 413 of file WFMO_Reactor.i. 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 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 588 of file WFMO_Reactor.cpp. References ACE_GUARD, ACE_Event_Handler::ALL_EVENTS_MASK, handles_to_be_added_, max_handlep1_, 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 <unbind>. Definition at line 186 of file WFMO_Reactor.cpp. References ACE_Reactor_Mask, changes_required, 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_, max_handlep1_, 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 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 99 of file WFMO_Reactor.h.

friend class ACE_WFMO_Reactor_Test [friend]

Definition at line 100 of file WFMO_Reactor.h.

---

Member Data Documentation

ACE_HANDLE* ACE_WFMO_Reactor_Handler_Repository::current_handles_ [protected]

Array of <ACE_HANDLEs> passed to <WaitForMultipleObjects>. This is not part of the structure as the handle array needs to be passed directly to <WaitForMultipleObjects>. Definition at line 429 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 432 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 444 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 441 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 456 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 453 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 450 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 435 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, max_handlep1, modify_network_events_i, open, resume_handler_i, suspend_handler_i, ACE_WFMO_Reactor::suspend_handlers, unbind_all, and unbind_i.

size_t ACE_WFMO_Reactor_Handler_Repository::max_size_ [protected]

Maximum number of handles. Definition at line 422 of file WFMO_Reactor.h. Referenced by bind_i, open, and ACE_WFMO_Reactor::size.

size_t ACE_WFMO_Reactor_Handler_Repository::suspended_handles_ [protected]

Number of currently suspended handles. Definition at line 447 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 438 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 <WFMO_Reactor>. Definition at line 419 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.i

---