- Main Page
- Namespaces
- Classes
- Files
- Related Pages

- Search for |

- Alphabetical List
- Class List
- Class Hierarchy
- Class Members

# TAO_Asynch_Reply_Dispatcher_Base Class Reference

Base class for TAO_Asynch_Reply_Dispatcher and TAO_DII_Deferred_Reply_Dispatcher. More...

`#include <Asynch_Reply_Dispatcher_Base.h>`

Inheritance diagram for TAO_Asynch_Reply_Dispatcher_Base:

[legend]
Collaboration diagram for TAO_Asynch_Reply_Dispatcher_Base:

[legend]
List of all members.

## Public Member Functions
| TAO_Asynch_Reply_Dispatcher_Base (TAO_ORB_Core *orb_core, ACE_Allocator *allocator=0)
| Default constructor.
void | transport (TAO_Transport *t)
| Sets the transport for this invocation.
virtual void | reply_timed_out (void)=0
| Inform that the reply timed out.
virtual long | schedule_timer (CORBA::ULong, const ACE_Time_Value &)=0
| Install the timeout handler.
bool | try_dispatch_reply (void)
| A helper method that can be used by the subclasses.
The Reply Dispatcher methods
virtual int | dispatch_reply (TAO_Pluggable_Reply_Params &)=0
virtual void | connection_closed (void)=0
Mutators for refcount
long | incr_refcount (void)
long | decr_refcount (void)
## Protected Member Functions
virtual | ~TAO_Asynch_Reply_Dispatcher_Base (void)
| Destructor.
## Protected Attributes
IOP::ServiceContextList | reply_service_info_
| The service context list.
char | buf_ [ACE_CDR::DEFAULT_BUFSIZE]
| The buffer that is used to initialise the data block.
ACE_Data_Block | db_
TAO_InputCDR | reply_cdr_
TAO_Transport * | transport_
| This invocation is using this transport, may change...
## Private Attributes
ACE_Lock * | lock_
| Lock to protect refcount and `is_reply_dispatched_` flag.
long | refcount_
| Refcount paraphernalia for this class.
bool | is_reply_dispatched_
| Has the reply been dispatched?
ACE_Allocator * | allocator_

## Detailed Description

Base class for TAO_Asynch_Reply_Dispatcher and TAO_DII_Deferred_Reply_Dispatcher.

## Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Asynch_Reply_Dispatcher_Base::TAO_Asynch_Reply_Dispatcher_Base | ( | TAO_ORB_Core * | orb_core,
|  | ACE_Allocator * | allocator = `0` |
| ) |  |  |

Default constructor.

TAO_Asynch_Reply_Dispatcher_Base::~TAO_Asynch_Reply_Dispatcher_Base | ( | void |  | ) | `[protected, virtual]`

Destructor.

## Member Function Documentation

void TAO_Asynch_Reply_Dispatcher_Base::connection_closed | ( | void |  | ) | `[pure virtual]`

The used for the pending reply has been closed. No reply is expected.

Todo:
  If the connection was closed due to a CloseConnection message then we could re-issue the request instead of raising the exception, it would a matter of simply adding a boolean argument to this function.

Implements TAO_Reply_Dispatcher.

long TAO_Asynch_Reply_Dispatcher_Base::decr_refcount | ( | void |  | ) |

int TAO_Asynch_Reply_Dispatcher_Base::dispatch_reply | ( | TAO_Pluggable_Reply_Params & |  | ) | `[pure virtual]`

Dispatch the reply. Return 1 on sucess, -1 on error.

Todo:
  Pluggable Messaging: this method has too many arguments, the "Right Thing"[tm] is for the Transport Object to create a "ClientReply" that encapsulates all we need to process a reply. Naturally it is possible that different messaging protocols implement different variants of such ClientReply class.

Implements TAO_Reply_Dispatcher.

long TAO_Asynch_Reply_Dispatcher_Base::incr_refcount | ( | void |  | ) |

void TAO_Asynch_Reply_Dispatcher_Base::reply_timed_out | ( | void |  | ) | `[pure virtual]`

Inform that the reply timed out.

virtual long TAO_Asynch_Reply_Dispatcher_Base::schedule_timer | ( | CORBA::ULong | ,
|  | const ACE_Time_Value & |  |
| ) |  |  | `[pure virtual]`

Install the timeout handler.

void TAO_Asynch_Reply_Dispatcher_Base::transport | ( | TAO_Transport * | t | ) |

Sets the transport for this invocation.

bool TAO_Asynch_Reply_Dispatcher_Base::try_dispatch_reply | ( | void |  | ) |

A helper method that can be used by the subclasses.

The semantics of this helper method needs careful attention. A call to this method will do the following

- If the reply has already been dispatched, the return value will be false to signify not to try.

- If the reply has not been dispatched, this method will set the flag to be true and return a true value to signify that the caller thread can go ahead and dispatch reply.

Why are we clumping everything in one method. Answer is we need atomicity?

## Member Data Documentation

ACE_Allocator* TAO_Asynch_Reply_Dispatcher_Base::allocator_`[private]`

Allocator that was used to allocate this reply dispatcher. In case of zero we come from the heap.

char TAO_Asynch_Reply_Dispatcher_Base::buf_[ACE_CDR::DEFAULT_BUFSIZE]`[protected]`

The buffer that is used to initialise the data block.

ACE_Data_Block TAO_Asynch_Reply_Dispatcher_Base::db_`[protected]`

Datablock that is created on the stack to initialise the CDR stream underneath.

bool TAO_Asynch_Reply_Dispatcher_Base::is_reply_dispatched_`[private]`

Has the reply been dispatched?

ACE_Lock* TAO_Asynch_Reply_Dispatcher_Base::lock_`[private]`

Lock to protect refcount and `is_reply_dispatched_` flag.

long TAO_Asynch_Reply_Dispatcher_Base::refcount_`[private]`

Refcount paraphernalia for this class.

TAO_InputCDR TAO_Asynch_Reply_Dispatcher_Base::reply_cdr_`[protected]`

CDR stream which has the reply information that needs to be demarshalled by the stubs

IOP::ServiceContextList TAO_Asynch_Reply_Dispatcher_Base::reply_service_info_`[protected]`

The service context list.

Note, that this is not a reference as in the synchronous case. We own the reply_service_info because our TAO_Asynch_Invocation or TAO_DII_Deferred_Invocation will go out of scope before we are done.

TAO_Transport* TAO_Asynch_Reply_Dispatcher_Base::transport_`[protected]`

This invocation is using this transport, may change...

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

- Asynch_Reply_Dispatcher_Base.h
- Asynch_Reply_Dispatcher_Base.cpp