TAO  2.3.3
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Friends | List of all members
TAO_LF_Event Class Referenceabstract

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

#include <LF_Event.h>

Inheritance diagram for TAO_LF_Event:
Inheritance graph
[legend]
Collaboration diagram for TAO_LF_Event:
Collaboration graph
[legend]

Public Member Functions

 TAO_LF_Event (void)
 Constructor. More...
 
virtual ~TAO_LF_Event (void)
 Destructor. More...
 
virtual int bind (TAO_LF_Follower *follower)
 Bind a follower. More...
 
virtual int unbind (TAO_LF_Follower *follower)
 Unbind the follower. More...
 
void reset_state (int new_state)
 Reset the state, irrespective of the previous states. More...
 

Static Public Member Functions

static const char * state_name (int st)
 

Protected Member Functions

virtual void state_changed_i (int new_state)=0
 Validate the state change. More...
 
virtual int is_state_final (void)=0
 Check whether we have reached the final state.. More...
 

Protected Attributes

int state_
 The current state. More...
 
TAO_LF_Followerfollower_
 The bounded follower. More...
 

Private Member Functions

virtual void set_state (int new_state)
 Set the state irrespective of anything. More...
 

Friends

class TAO_Leader_Follower
 

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, TAO_Leader_Follower &lf)
 
virtual int successful (void) const =0
 
virtual int error_detected (void) const =0
 
int keep_waiting (void)
 Check if we should keep waiting. More...
 

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

Virtual methods for this class hierarchy..Accessor to change the state. The state isn't changed unless certain conditions are satisfied.

Sort of double-checked optimization..

Enumerator
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

int TAO_LF_Event::bind ( TAO_LF_Follower follower)
virtual

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.

This is virtual to allow the LF_Multi_Event derived type share the follower with all the subordinate LF_CH_Events.

Returns
-1 if the LF_Event is already bound, 0 otherwise

Reimplemented in TAO_LF_CH_Event, and TAO_LF_Multi_Event.

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_Multi_Event, TAO_LF_CH_Event, and TAO_LF_Invocation_Event.

virtual int TAO_LF_Event::is_state_final ( void  )
protectedpure virtual

Check whether we have reached the final state..

Implemented in TAO_LF_Multi_Event, TAO_LF_Invocation_Event, and TAO_LF_CH_Event.

int TAO_LF_Event::keep_waiting ( void  )

Check if we should keep waiting.

void TAO_LF_Event::reset_state ( int  new_state)

Reset the state, irrespective of the previous states.

void TAO_LF_Event::set_state ( int  new_state)
privatevirtual

Set the state irrespective of anything.

Reimplemented in TAO_LF_CH_Event.

void TAO_LF_Event::state_changed ( int  new_state,
TAO_Leader_Follower lf 
)

Virtual methods for this class hierarchy..Accessor to change the state. The state isn't changed unless certain conditions are satisfied.

Sort of double-checked optimization..

virtual void TAO_LF_Event::state_changed_i ( int  new_state)
protectedpure virtual

Validate the state change.

Implemented in TAO_LF_CH_Event, TAO_LF_Multi_Event, and TAO_LF_Invocation_Event.

const char * TAO_LF_Event::state_name ( int  st)
static
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_Multi_Event, TAO_LF_CH_Event, and TAO_LF_Invocation_Event.

int TAO_LF_Event::unbind ( TAO_LF_Follower follower)
virtual

Unbind the follower.

Reimplemented in TAO_LF_CH_Event, and TAO_LF_Multi_Event.

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: