---
name: "ACE_WFMO_Reactor_Handler_Repository"
section: "3"
platform: "linux"
package: "libace-doc"
version: "5.0.7-4"
release: "Debian 2.2 (Potato)"
platforms: ["linux"]
url: "https://new.carta.tech/ACE_WFMO_Reactor_Handler_Repository"
---

# ACE\_WFMO\_Reactor\_Handler\_Repository(3)

Used to map ACE\_HANDLEs onto the appropriate ACE\_Event\_Handler \* and other information.

## NAME

ACE\_WFMO\_Reactor\_Handler\_Repository -

Used to map ACE\_HANDLEs onto the appropriate ACE\_Event\_Handler \* and other information.

## SYNOPSIS

```
#include <ace/WFMO_Reactor.h>
class ACE_WFMO_Reactor_Handler_Repository
{
  public:
    friend class ACE_WFMO_Reactor;
    class Common_Info
    {
      public:
        int io_entry_;
        ACE_Event_Handler *event_handler_;
        ACE_HANDLE io_handle_;
        long network_events_;
        int delete_event_;
        int delete_entry_;
        ACE_Reactor_Mask close_masks_;
        Common_Info (void);
        void reset (void);
        void set (
            int io_entry,
            ACE_Event_Handler *event_handler,
            ACE_HANDLE io_handle,
            long network_events,
            int delete_event,
            int delete_entry,
            ACE_Reactor_Mask close_masks
            );
        void set (Common_Info &common_info);
        void dump (void) const;
    };
```

    class Current\_Info\
     {\
       public:         int suspend\_entry\_;         Current\_Info (void);         void reset (void);         void set (\
             int io\_entry,\
             ACE\_Event\_Handler \*event\_handler,\
             ACE\_HANDLE io\_handle,\
             long network\_events,\
             int delete\_event,\
             int delete\_entry = 0,\
             ACE\_Reactor\_Mask close\_masks = ACE\_Event\_Handler::NULL\_MASK,\
             int suspend\_entry = 0\
             );         void set (Common\_Info &common\_info, int suspend\_entry = 0);         void dump (ACE\_HANDLE event\_handle) const;\
     };

    class To\_Be\_Added\_Info\
     {\
       public:         ACE\_HANDLE event\_handle\_;         int suspend\_entry\_;         To\_Be\_Added\_Info (void);         void reset (void);         void set (\
             ACE\_HANDLE event\_handle,\
             int io\_entry,\
             ACE\_Event\_Handler \*event\_handler,\
             ACE\_HANDLE io\_handle,\
             long network\_events,\
             int delete\_event,\
             int delete\_entry = 0,\
             ACE\_Reactor\_Mask close\_masks = ACE\_Event\_Handler::NULL\_MASK,\
             int suspend\_entry = 0\
             );         void set (\
             ACE\_HANDLE event\_handle,\
             Common\_Info &common\_info,\
             int suspend\_entry = 0\
             );         void dump (void) const;\
     };

    class Suspended\_Info\
     {\
       public:         ACE\_HANDLE event\_handle\_;         int resume\_entry\_;         Suspended\_Info (void);         void reset (void);         void set (\
             ACE\_HANDLE event\_handle,\
             int io\_entry,\
             ACE\_Event\_Handler \*event\_handler,\
             ACE\_HANDLE io\_handle,\
             long network\_events,\
             int delete\_event,\
             int delete\_entry = 0,\
             ACE\_Reactor\_Mask close\_masks = 0,\
             int resume\_entry = 0\
             );         void set (\
             ACE\_HANDLE event\_handle,\
             Common\_Info &common\_info,\
             int resume\_entry = 0\
             );         void dump (void) const;\
     };     ACE\_WFMO\_Reactor\_Handler\_Repository (\
         ACE\_WFMO\_Reactor &wfmo\_reactor\
         );     virtual ~ACE\_WFMO\_Reactor\_Handler\_Repository (void);     int open (size\_t size);     int close (void);     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);     int unbind\_i (\
         ACE\_HANDLE,\
         ACE\_Reactor\_Mask mask,\
         int &changes\_required\
         );     void unbind\_all (void);     int invalid\_handle (ACE\_HANDLE handle) const;     size\_t max\_handlep1 (void) const;     ACE\_HANDLE \*handles (void) const;     Current\_Info \*current\_info (void) const;     virtual int changes\_required (void);     virtual int make\_changes (void);     int scheduled\_for\_deletion (size\_t slot) const;     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);     int resume\_handler\_i (ACE\_HANDLE handle, int &changes\_required);     int make\_changes\_in\_current\_infos (void);     int make\_changes\_in\_suspension\_infos (void);     int make\_changes\_in\_to\_be\_added\_infos (void);     int remove\_handler\_i (size\_t slot, ACE\_Reactor\_Mask mask);     int remove\_suspended\_handler\_i (\
         size\_t slot,\
         ACE\_Reactor\_Mask mask\
         );     int remove\_to\_be\_added\_handler\_i (\
         size\_t slot,\
         ACE\_Reactor\_Mask to\_be\_removed\_masks\
         );     int handler (\
         ACE\_HANDLE handle,\
         ACE\_Reactor\_Mask mask,\
         ACE\_Event\_Handler \*\*event\_handler = 0\
         );     void dump (void) const;\
   protected:     ACE\_WFMO\_Reactor &wfmo\_reactor\_;     size\_t max\_size\_;     ACE\_HANDLE \*current\_handles\_;     Current\_Info \*current\_info\_;     size\_t max\_handlep1\_;     To\_Be\_Added\_Info \*to\_be\_added\_info\_;     size\_t handles\_to\_be\_added\_;     Suspended\_Info \*current\_suspended\_info\_;     size\_t suspended\_handles\_;     size\_t handles\_to\_be\_suspended\_;     size\_t handles\_to\_be\_resumed\_;     size\_t handles\_to\_be\_deleted\_; };

## Search structure operations.

```
int bind (ACE_HANDLE, ACE_Event_Handler *);
```

Bind the ACE\_Event\_Handler \* to the ACE\_HANDLE. This is for the simple event entry.

```
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.

```
int unbind (ACE_HANDLE, ACE_Reactor_Mask mask);
```

Remove the binding of ACE\_HANDLE in accordance with the mask.

```
int unbind_i (
    ACE_HANDLE,
    ACE_Reactor_Mask mask,
    int &changes_required
    );
```

Non-lock-grabbing version of unbind

```
void unbind_all (void);
```

Remove all bindings of ACE\_HANDLE, ACE\_Event\_Handler tuples.

## Sanity checking.

Check the handle to make sure it's a valid ACE\_HANDLE

```
int invalid_handle (ACE_HANDLE handle) const;
```

## Accessors.

```
size_t max_handlep1 (void) const;
```

Maximum ACE\_HANDLE value, plus 1.

```
ACE_HANDLE *handles (void) const;
```

Pointer to the beginning of the current array of ACE\_HANDLE \*'s.

```
Current_Info *current_info (void) const;
```

Pointer to the beginning of the current array of ACE\_Event\_Handler \*'s.

```
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 slot 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
    );
```

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

```
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

```
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);
```

Deletions in to\_be\_added\_info\_, or transfers to current\_info\_ or current\_suspended\_info\_ from to\_be\_added\_info\_

```
int remove_handler_i (size_t slot, ACE_Reactor_Mask mask);
```

Removes the ACE\_Event\_Handler at slot from the table.

```
int remove_suspended_handler_i (size_t slot, ACE_Reactor_Mask mask);
```

Removes the ACE\_Event\_Handler at slot 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 slot from the table.

```
int 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.

```
void dump (void) const;
```

Dump the state of an object.

## AUTHOR

Irfan Pyarali, Tim Harrison, and Doug Schmidt

## LIBRARY

ace