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

# TAO_LF_Event Class Reference

Use the Leader/Follower loop to wait for one specific event. More...

`#include <LF_Event.h>`

Inheritance diagram for TAO_LF_Event:

[legend]
Collaboration diagram for TAO_LF_Event:

[legend]
List of all members.

## State management
A Leader/Followers event goes through several states during its lifetime. We use an enum to represent those states and state changes are validated according to the rules defined in the concrete classes. We treat the states as finite states in a FSM. The possible sequence of states through which the FSM migrates is defined in the concrete classes.
enum | { LFS_IDLE = 0, LFS_ACTIVE, LFS_CONNECTION_WAIT, LFS_SUCCESS, LFS_FAILURE, LFS_TIMEOUT, LFS_CONNECTION_CLOSED }
void | state_changed (int new_state)
virtual int | successful (void) const=0
virtual int | error_detected (void) const=0
int | keep_waiting (void)
| Check if we should keep waiting.
## Public Types
## Public Methods
| TAO_LF_Event (void)
| Constructor.
virtual | ~TAO_LF_Event (void)
| Destructor.
int | bind (TAO_LF_Follower *follower)
| Bind a follower.
int | unbind (void)
| Unbind the follower.
void | reset_state (int new_state)
| Reset the state, irrespective of the previous states.
## Protected Methods
virtual void | state_changed_i (int new_state)=0
| Validate the state change.
virtual int | is_state_final (void)=0
| Check whether we have reached the final state..
## Protected Attributes
int | state_
| The current state.
TAO_LF_Follower * | follower_
| The bounded follower.
## Private Methods
virtual void | set_state (int new_state)
| Set the state irrespective of anything.
## Friends
class | TAO_Leader_Follower

## Detailed Description

Use the Leader/Follower loop to wait for one specific event.

The Leader/Follower event loop is used to wait for incoming responses, as well as to wait for all the data to be flushed. This class encapsulates this event loop. It uses Template Method to parametrize the 'waited for' predicate (i.e. reply received or message sent or connection establishment etc.)

Todo:
  Implementing the Leader/Followers loop in this class, as well as the callbacks to communicate that an event has completed leads to excessive coupling. A better design would use a separate class to signal the events, that would allow us to remove the Leader/Followers logic from the ORB. However, that requires other major changes and it somewhat complicates the design.

## Member Enumeration Documentation

anonymous enum

  | Enumeration values:
  LFS_IDLE | The event is created, and is in initial state.
  LFS_ACTIVE | The event is active.
  LFS_CONNECTION_WAIT | The event is waiting for connection completion.
  LFS_SUCCESS | The event has completed successfully.
  LFS_FAILURE | A failure has been detected while the event was active.
  LFS_TIMEOUT | The event has timed out.
  LFS_CONNECTION_CLOSED | The connection was closed.

## Constructor & Destructor Documentation

TAO_LF_Event::TAO_LF_Event | ( | void |  | ) |

| Constructor.

TAO_LF_Event::~TAO_LF_Event | ( | void |  | ) | `[virtual]`

| Destructor.

## Member Function Documentation

ACE_INLINE int TAO_LF_Event::bind | ( | TAO_LF_Follower * | follower | ) |

| Bind a follower. An event can be waited on by at most one follower thread, this method is used to bind the waiting thread to the event, in order to let the event signal any important state changes. Returns: -1 if the LF_Event is already bound, 0 otherwise

virtual int TAO_LF_Event::error_detected | ( | void |  | ) | const`[pure virtual]`

| Return 1 if an error was detected while waiting for the event Implemented in TAO_LF_CH_Event, and TAO_LF_Invocation_Event.

virtual int TAO_LF_Event::is_state_final | ( | void |  | ) | `[protected, pure virtual]`

| Check whether we have reached the final state.. Implemented in TAO_LF_CH_Event, and TAO_LF_Invocation_Event.

ACE_INLINE int TAO_LF_Event::keep_waiting | ( | void |  | ) |

| Check if we should keep waiting.

ACE_INLINE void TAO_LF_Event::reset_state | ( | int | new_state | ) |

| Reset the state, irrespective of the previous states. Reimplemented in TAO_LF_CH_Event.

void TAO_LF_Event::set_state | ( | int | new_state | ) | `[private, virtual]`

| Set the state irrespective of anything. Reimplemented in TAO_LF_CH_Event.

void TAO_LF_Event::state_changed | ( | int | new_state | ) |

| Accessor to change the state. The state isnt changed unless certain conditions are satisfied.

virtual void TAO_LF_Event::state_changed_i | ( | int | new_state | ) | `[protected, pure virtual]`

| Validate the state change. Implemented in TAO_LF_CH_Event, and TAO_LF_Invocation_Event.

virtual int TAO_LF_Event::successful | ( | void |  | ) | const`[pure virtual]`

| Return 1 if the condition was satisfied successfully, 0 if it has not Implemented in TAO_LF_CH_Event, and TAO_LF_Invocation_Event.

ACE_INLINE int TAO_LF_Event::unbind | ( | void |  | ) |

| Unbind the follower.

## Friends And Related Function Documentation

friend class TAO_Leader_Follower`[friend]`

## Member Data Documentation

TAO_LF_Follower* TAO_LF_Event::follower_`[protected]`

| The bounded follower.

int TAO_LF_Event::state_`[protected]`

| The current state.

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

- LF_Event.h
- LF_Event.cpp
- LF_Event.inl