Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE_Select_Reactor_Impl Class Reference

This class simply defines how Select_Reactor's basic interface functions should look like and provides a common base class for <Select_Reactor> using various locking mechanism. More...

`#include <Select_Reactor_Base.h>`

Inheritance diagram for ACE_Select_Reactor_Impl:

[legend]
Collaboration diagram for ACE_Select_Reactor_Impl:

[legend]
List of all members.

## Public Types
enum | { DEFAULT_SIZE = ACE_DEFAULT_SELECT_REACTOR_SIZE }
## Public Methods
| ACE_Select_Reactor_Impl (void)
| Constructor. More...
virtual int | purge_pending_notifications (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual int | resumable_handler (void)
| Does the reactor allow the application to resume the handle on its own ie. can it pass on the control of handle resumption to the application. The select reactor has no handlers that can be resumed by the application. So return 0;. More...
## Protected Methods
virtual int | bit_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Select_Reactor_Handle_Set &wait_Set, int ops)
| Allow manipulation of the <wait_set_> mask and <ready_set_> mask. More...
virtual void | renew (void)=0
| Enqueue ourselves into the list of waiting threads at the appropriate point specified by <requeue_position_>. More...
virtual int | is_suspended_i (ACE_HANDLE handle)=0
| Check to see if the <Event_Handler> associated with <handle> is suspended. Returns 0 if not, 1 if so. More...
int | supress_notify_renew (void)
| Controls/access whether the notify handler should renew the Select_Reactor's token or not. More...
void | supress_notify_renew (int sr)
## Protected Attributes
ACE_Select_Reactor_Handler_Repository | handler_rep_
| Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s. More...
ACE_Select_Reactor_Handle_Set | wait_set_
| Tracks handles that are waited for by <select>. More...
ACE_Select_Reactor_Handle_Set | suspend_set_
| Tracks handles that are currently suspended. More...
ACE_Select_Reactor_Handle_Set | ready_set_
| Track HANDLES we are interested in for various events that must be dispatched *without* going through <select>. More...
ACE_Timer_Queue * | timer_queue_
| Defined as a pointer to allow overriding by derived classes... More...
int | delete_timer_queue_
| Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it). More...
ACE_Sig_Handler * | signal_handler_
| Handle signals without requiring global/static variables. More...
int | delete_signal_handler_
| Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it). More...
ACE_Reactor_Notify * | notify_handler_
| Callback object that unblocks the <ACE_Select_Reactor> if it's sleeping. More...
int | delete_notify_handler_
| Keeps track of whether we need to delete the notify handler (if we didn't create it, then we don't delete it). More...
int | restart_
| Restart the <handle_events> event-loop method automatically when <select> is interrupted via <EINTR>. More...
int | requeue_position_
int | initialized_
| True if we've been initialized yet... More...
ACE_thread_t | owner_
| The original thread that created this Select_Reactor. More...
int | state_changed_
## Private Methods
| ACE_Select_Reactor_Impl (const ACE_Select_Reactor_Impl &)
| Deny access since member-wise won't work... More...
ACE_Select_Reactor_Impl & | operator= (const ACE_Select_Reactor_Impl &)
## Private Attributes
int | supress_renew_
| Determine whether we should renew Select_Reactor's token after handling the notification message. More...
## Friends
class | ACE_Select_Reactor_Notify
class | ACE_Select_Reactor_Handler_Repository

## Detailed Description

This class simply defines how Select_Reactor's basic interface functions should look like and provides a common base class for <Select_Reactor> using various locking mechanism.

## Member Enumeration Documentation

anonymous enum

  | Enumeration values:
  DEFAULT_SIZE | Default size of the Select_Reactor's handle table.

## Constructor & Destructor Documentation

ACE_INLINE ACE_Select_Reactor_Impl::ACE_Select_Reactor_Impl | ( | void |  | ) |

| Constructor.

ACE_Select_Reactor_Impl::ACE_Select_Reactor_Impl | ( | const ACE_Select_Reactor_Impl & |  | ) | `[private]`

| Deny access since member-wise won't work...

## Member Function Documentation

int ACE_Select_Reactor_Impl::bit_ops | ( | ACE_HANDLE | handle,
|  | ACE_Reactor_Mask | mask,
|  | ACE_Select_Reactor_Handle_Set & | handle_set,
|  | int | ops
| ) | `[protected, virtual]`

| Allow manipulation of the <wait_set_> mask and <ready_set_> mask.

virtual int ACE_Select_Reactor_Impl::is_suspended_i | ( | ACE_HANDLE | handle | ) | `[protected, pure virtual]`

| Check to see if the <Event_Handler> associated with <handle> is suspended. Returns 0 if not, 1 if so. Reimplemented in ACE_Select_Reactor_T, and ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.

ACE_Select_Reactor_Impl& ACE_Select_Reactor_Impl::operator= | ( | const ACE_Select_Reactor_Impl & |  | ) | `[private]`

ACE_INLINE int ACE_Select_Reactor_Impl::purge_pending_notifications | ( | ACE_Event_Handler * | eh = 0,
|  | ACE_Reactor_Mask | mask = ACE_Event_Handler::ALL_EVENTS_MASK
| ) | `[virtual]`

| Purge any notifications pending in this reactor for the specified <ACE_Event_Handler> object. Returns the number of notifications purged. Returns -1 on error. Reimplemented from ACE_Reactor_Impl.

virtual void ACE_Select_Reactor_Impl::renew | ( | void |  | ) | `[protected, pure virtual]`

| Enqueue ourselves into the list of waiting threads at the appropriate point specified by <requeue_position_>. Reimplemented in ACE_Select_Reactor_T, and ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.

int ACE_Select_Reactor_Impl::resumable_handler | ( | void |  | ) | `[virtual]`

| Does the reactor allow the application to resume the handle on its own ie. can it pass on the control of handle resumption to the application. The select reactor has no handlers that can be resumed by the application. So return 0;. Reimplemented from ACE_Reactor_Impl. Reimplemented in ACE_TP_Reactor.

ACE_INLINE void ACE_Select_Reactor_Impl::supress_notify_renew | ( | int | sr | ) | `[protected]`

ACE_INLINE int ACE_Select_Reactor_Impl::supress_notify_renew | ( | void |  | ) | `[protected]`

| Controls/access whether the notify handler should renew the Select_Reactor's token or not.

## Friends And Related Function Documentation

friend class ACE_Select_Reactor_Handler_Repository`[friend]`

friend class ACE_Select_Reactor_Notify`[friend]`

## Member Data Documentation

int ACE_Select_Reactor_Impl::delete_notify_handler_`[protected]`

| Keeps track of whether we need to delete the notify handler (if we didn't create it, then we don't delete it).

int ACE_Select_Reactor_Impl::delete_signal_handler_`[protected]`

| Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it).

int ACE_Select_Reactor_Impl::delete_timer_queue_`[protected]`

| Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it).

ACE_Select_Reactor_Handler_Repository ACE_Select_Reactor_Impl::handler_rep_`[protected]`

| Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s.

int ACE_Select_Reactor_Impl::initialized_`[protected]`

| True if we've been initialized yet...

ACE_Reactor_Notify* ACE_Select_Reactor_Impl::notify_handler_`[protected]`

| Callback object that unblocks the <ACE_Select_Reactor> if it's sleeping.

ACE_thread_t ACE_Select_Reactor_Impl::owner_`[protected]`

| The original thread that created this Select_Reactor.

ACE_Select_Reactor_Handle_Set ACE_Select_Reactor_Impl::ready_set_`[protected]`

| Track HANDLES we are interested in for various events that must be dispatched *without* going through <select>.

int ACE_Select_Reactor_Impl::requeue_position_`[protected]`

| Position that the main ACE_Select_Reactor thread is requeued in the list of waiters during a <notify> callback. If this value == -1 we are requeued at the end of the list. Else if it's 0 then we are requeued at the front of the list. Else if it's > 1 then that indicates the number of waiters to skip over.

int ACE_Select_Reactor_Impl::restart_`[protected]`

| Restart the <handle_events> event-loop method automatically when <select> is interrupted via <EINTR>.

ACE_Sig_Handler* ACE_Select_Reactor_Impl::signal_handler_`[protected]`

| Handle signals without requiring global/static variables.

int ACE_Select_Reactor_Impl::state_changed_`[protected]`

| True if state has changed during dispatching of <ACE_Event_Handlers>, else false. This is used to determine whether we need to make another trip through the <Select_Reactor>'s <wait_for_multiple_events> loop.

int ACE_Select_Reactor_Impl::supress_renew_`[private]`

| Determine whether we should renew Select_Reactor's token after handling the notification message.

ACE_Select_Reactor_Handle_Set ACE_Select_Reactor_Impl::suspend_set_`[protected]`

| Tracks handles that are currently suspended.

ACE_Timer_Queue* ACE_Select_Reactor_Impl::timer_queue_`[protected]`

| Defined as a pointer to allow overriding by derived classes...

ACE_Select_Reactor_Handle_Set ACE_Select_Reactor_Impl::wait_set_`[protected]`

| Tracks handles that are waited for by <select>.

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

- Select_Reactor_Base.h
- Select_Reactor_Base.cpp
- Select_Reactor_Base.i