TAO_DynamicInterface: CORBA::Request Class Reference

typedef CORBA::Request_out CORBA::Request::_out_type

Definition at line 202 of file Request.h.

typedef CORBA::Request_ptr CORBA::Request::_ptr_type

Definition at line 200 of file Request.h.

typedef CORBA::Request_var CORBA::Request::_var_type

Definition at line 201 of file Request.h.

CORBA::Request::Request	(	CORBA::Object_ptr	obj,
		CORBA::ORB_ptr	orb,
		const CORBA::Char *	op,
		CORBA::NVList_ptr	args,
		CORBA::NamedValue_ptr	result,
		CORBA::Flags	flags,
		CORBA::ExceptionList_ptr	exceptions
	)			`[private]`

Definition at line 54 of file Request.cpp.

References ACE_NEW, and exceptions_.

00061   : target_ (CORBA::Object::_duplicate (obj)),
00062     orb_ (CORBA::ORB::_duplicate (orb)),
00063     opname_ (CORBA::string_dup (op)),
00064     args_ (CORBA::NVList::_duplicate (args)),
00065     result_ (CORBA::NamedValue::_duplicate (result)),
00066     flags_ (flags),
00067     // env_ (env),
00068     exceptions_ (CORBA::ExceptionList::_duplicate (exceptions)),
00069     contexts_ (0),
00070     ctx_ (CORBA::Context::_nil ()),
00071     refcount_ (1),
00072     lazy_evaluation_ (false),
00073     response_received_ (false),
00074     byte_order_ (TAO_ENCAP_BYTE_ORDER)
00075 {
00076   if (this->exceptions_.in () == 0)
00077     {
00078       CORBA::ExceptionList *tmp = 0;
00079       ACE_NEW (tmp,
00080                CORBA::ExceptionList);
00081 
00082       this->exceptions_ = tmp;
00083     }
00084 }

CORBA::Request::Request	(	CORBA::Object_ptr	obj,
		CORBA::ORB_ptr	orb,
		const CORBA::Char *	op
	)			`[private]`

Definition at line 86 of file Request.cpp.

References ACE_NEW, and exceptions_.

00089   : target_ (CORBA::Object::_duplicate (obj)),
00090     orb_ (CORBA::ORB::_duplicate (orb)),
00091     opname_ (CORBA::string_dup (op)),
00092     flags_ (0),
00093     // env_ (env),
00094     contexts_ (0),
00095     ctx_ (CORBA::Context::_nil ()),
00096     refcount_ (1),
00097     lazy_evaluation_ (false),
00098     response_received_ (false),
00099     byte_order_ (TAO_ENCAP_BYTE_ORDER)
00100 {
00101   CORBA::ExceptionList *tmp = 0;
00102   ACE_NEW (tmp,
00103            CORBA::ExceptionList);
00104 
00105   this->exceptions_ = tmp;
00106 
00107   ACE_NEW (this->args_,
00108            CORBA::NVList);
00109 
00110   ACE_NEW (this->result_,
00111            CORBA::NamedValue);
00112 }

CORBA::Request::~Request ( void ) [private]

Definition at line 114 of file Request.cpp.

References ACE_ASSERT, args_, opname_, refcount_, release(), result_, string_free(), and target_.

00115 {
00116   ACE_ASSERT (refcount_ == 0);
00117 
00118   ::CORBA::release (this->target_);
00119   ::CORBA::string_free ((char*) this->opname_);
00120   this->opname_ = 0;
00121   ::CORBA::release (this->args_);
00122   ::CORBA::release (this->result_);
00123 }

CORBA::ULong CORBA::Request::_decr_refcnt ( void )

Definition at line 42 of file Request.cpp.

References refcount_.

Referenced by TAO_Dynamic_Adapter_Impl::request_release().

00043 {
00044   CORBA::ULong const new_count = --this->refcount_;
00045 
00046   if (new_count == 0)
00047     delete this;
00048 
00049   return new_count;
00050 }

static CORBA::Request* CORBA::Request::_duplicate ( CORBA::Request * ) [static]

Pseudo object methods.

TAO_BEGIN_VERSIONED_NAMESPACE_DECL CORBA::ULong CORBA::Request::_incr_refcnt ( void )

Definition at line 36 of file Request.cpp.

References refcount_.

00037 {
00038   return ++this->refcount_;
00039 }

ACE_INLINE CORBA::Request_ptr CORBA::Request::_nil ( void ) [static]

Definition at line 38 of file Request.inl.

Referenced by TAO_Dynamic_Adapter_Impl::request().

00039 {
00040   return 0;
00041 }

ACE_INLINE void CORBA::Request::_tao_byte_order ( int byte_order )

Set the byte order member.

Definition at line 166 of file Request.inl.

References byte_order_.

00167 {
00168   this->byte_order_ = byte_order;
00169 }

ACE_INLINE int CORBA::Request::_tao_byte_order ( void ) const

Get the byte order member.

Definition at line 160 of file Request.inl.

References byte_order_.

Referenced by TAO::DII_Deferred_Invocation_Adapter::invoke_twoway(), and TAO::DII_Invocation_Adapter::invoke_twoway().

00161 {
00162   return this->byte_order_;
00163 }

ACE_INLINE void CORBA::Request::_tao_lazy_evaluation ( bool lazy_evaluation )

Set the lazy evaluation flag.

Definition at line 154 of file Request.inl.

References lazy_evaluation_.

00155 {
00156   this->lazy_evaluation_ = lazy_evaluation;
00157 }

void CORBA::Request::_tao_reply_stub	(	TAO_InputCDR &	_tao_reply_cdr,
		Messaging::ReplyHandler_ptr	_tao_reply_handler,
		CORBA::ULong	reply_status
	)			`[static]`

Definition at line 260 of file Request.cpp.

References TAO_DII_Reply_Handler::handle_excep(), TAO_DII_Reply_Handler::handle_location_forward(), and TAO_DII_Reply_Handler::handle_response().

Referenced by TAO_DII_Asynch_Reply_Dispatcher::connection_closed(), TAO_DII_Asynch_Reply_Dispatcher::dispatch_reply(), and sendc().

00263 {
00264   // Retrieve Reply Handler object.
00265   TAO_DII_Reply_Handler* reply_handler =
00266     dynamic_cast<TAO_DII_Reply_Handler*> (rh);
00267 
00268   // Exception handling
00269   switch (reply_status)
00270     {
00271     case TAO_AMI_REPLY_OK:
00272     case TAO_AMI_REPLY_NOT_OK:
00273       {
00274         reply_handler->handle_response(_tao_in);
00275         break;
00276       }
00277     case TAO_AMI_REPLY_USER_EXCEPTION:
00278     case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
00279       {
00280         reply_handler->handle_excep (_tao_in, reply_status);
00281         break;
00282       }
00283     case TAO_AMI_REPLY_LOCATION_FORWARD:
00284     case TAO_AMI_REPLY_LOCATION_FORWARD_PERM:
00285       {
00286         reply_handler->handle_location_forward (_tao_in, reply_status);
00287         break;
00288       }
00289     }
00290 }

CORBA::Any& CORBA::Request::add_in_arg ( const char * name )

ACE_INLINE CORBA::Any & CORBA::Request::add_in_arg ( void )

Definition at line 94 of file Request.inl.

References args_.

00095 {
00096   return this->args_->add_element (CORBA::ARG_IN)->any_;
00097 }

CORBA::Any& CORBA::Request::add_inout_arg ( const char * name )

ACE_INLINE CORBA::Any & CORBA::Request::add_inout_arg ( void )

Definition at line 106 of file Request.inl.

References args_.

00107 {
00108   return this->args_->add_element (CORBA::ARG_INOUT)->any_;
00109 }

CORBA::Any& CORBA::Request::add_out_arg ( const char * name )

ACE_INLINE CORBA::Any & CORBA::Request::add_out_arg ( void )

Definition at line 118 of file Request.inl.

References args_.

00119 {
00120   return this->args_->add_element (CORBA::ARG_OUT)->any_;
00121 }

ACE_INLINE CORBA::NVList_ptr CORBA::Request::arguments ( void )

Return the arguments for the request.

Definition at line 58 of file Request.inl.

References args_.

00059 {
00060   return this->args_;
00061 }

ACE_INLINE CORBA::ContextList_ptr CORBA::Request::contexts ( void )

Return a list of the request's result's contexts. Since TAO does not implement Contexts, this will always be 0.

Definition at line 79 of file Request.inl.

References contexts_.

00080 {
00081   return this->contexts_;
00082 }

ACE_INLINE void CORBA::Request::ctx ( CORBA::Context_ptr )

Mutator for the Context member.

Definition at line 148 of file Request.inl.

References ctx(), and ctx_.

00149 {
00150   this->ctx_ = ctx;
00151 }

ACE_INLINE CORBA::Context_ptr CORBA::Request::ctx ( void ) const

Accessor for the Context member.

Definition at line 142 of file Request.inl.

References ctx_.

Referenced by ctx().

00143 {
00144   return this->ctx_;
00145 }

ACE_INLINE CORBA::ExceptionList_ptr CORBA::Request::exceptions ( void )

Return the exceptions resulting from this request.

Definition at line 72 of file Request.inl.

References exceptions_, and TAO_Pseudo_Var_T< T >::in().

00073 {
00074   return this->exceptions_.in ();
00075 }

void CORBA::Request::get_response ( void )

Definition at line 294 of file Request.cpp.

References args_.

00295 {
00296   while (!this->response_received_)
00297     {
00298       (void) this->orb_->perform_work ();
00299     }
00300 
00301   if (this->lazy_evaluation_)
00302     {
00303       this->args_->evaluate ();
00304     }
00305 }

void CORBA::Request::handle_response	(	TAO_InputCDR &	incoming,
		GIOP::ReplyStatusType	reply_status
	)

Callback method for deferred synchronous requests.

Definition at line 341 of file Request.cpp.

References ACE_ERROR, ACE_GUARD, ACE_TEXT, args_, ACE_InputCDR::byte_order(), byte_order_, LM_ERROR, NO_EXCEPTION, response_received_, result_, SYSTEM_EXCEPTION, TAO_SYNCH_MUTEX, and USER_EXCEPTION.

Referenced by TAO_DII_Deferred_Reply_Dispatcher::connection_closed(), and TAO_DII_Deferred_Reply_Dispatcher::dispatch_reply().

00343 {
00344   // If this request was created by a gateway, then result_
00345   // and/or args_ are shared by a CORBA::ServerRequest, whose
00346   // reply must be in the same byte order as the reply we are
00347   // handling here. So we set the member to be accessed later.
00348   this->byte_order_ = incoming.byte_order ();
00349 
00350   switch (reply_status)
00351   {
00352     case GIOP::NO_EXCEPTION:
00353       if (this->result_ != 0)
00354         {
00355           // We can be sure that the impl is a TAO::Unknown_IDL_Type.
00356           this->result_->value ()->impl ()->_tao_decode (incoming);
00357         }
00358 
00359       this->args_->_tao_incoming_cdr (incoming,
00360                                       CORBA::ARG_OUT | CORBA::ARG_INOUT,
00361                                       this->lazy_evaluation_);
00362 
00363       {
00364         ACE_GUARD (TAO_SYNCH_MUTEX,
00365                    ace_mon,
00366                    this->lock_);
00367 
00368         this->response_received_ = true;
00369       }
00370 
00371       break;
00372     case GIOP::USER_EXCEPTION:
00373     case GIOP::SYSTEM_EXCEPTION:
00374     case GIOP::LOCATION_FORWARD:
00375     case GIOP::LOCATION_FORWARD_PERM:
00376     default:
00377       // @@ (JP) Don't know what to do about any of these yet.
00378       ACE_ERROR ((LM_ERROR,
00379                   ACE_TEXT ("(%P|%t) unhandled reply status\n")));
00380   }
00381 }

void CORBA::Request::invoke ( void )

Perform method resolution and invoke an appropriate method.

If the method returns successfully, its result is placed in the result argument specified on create_request. The behavior is undefined if this Request has already been used with a previous call to invoke>, send>, or .

Note:: A default argument is set, but please note that this not recommended as the user may not be able to propagate the exceptions.

Definition at line 133 of file Request.cpp.

References byte_order_, response_received_, and ACE_OS::strlen().

00134 {
00135   TAO::NamedValue_Argument _tao_retval (this->result_);
00136 
00137   TAO::NVList_Argument _tao_in_list (this->args_,
00138                                      this->lazy_evaluation_);
00139 
00140   TAO::Argument *_tao_arg_list [] = {
00141     &_tao_retval,
00142     &_tao_in_list
00143   };
00144 
00145   TAO::DII_Invocation_Adapter _tao_call (
00146        this->target_,
00147        _tao_arg_list,
00148        sizeof( _tao_arg_list ) / sizeof( TAO::Argument* ),
00149        this->opname_,
00150        static_cast<CORBA::ULong> (ACE_OS::strlen (this->opname_)),
00151        this->exceptions_.in (),
00152        this);
00153 
00154   _tao_call.invoke (0, 0);
00155 
00156   // If we returned without an exception being thrown the response
00157   // (if any) is assumed to be received.
00158   this->response_received_ = true;
00159   
00160   // If this request was created by a gateway, then result_
00161   // and/or args_ are shared by a CORBA::ServerRequest, whose
00162   // reply must be in the same byte order as the reply we are
00163   // handling here. So we set the member to be accessed later.
00164   this->byte_order_ = _tao_retval.byte_order ();
00165 }

ACE_INLINE const CORBA::Char * CORBA::Request::operation ( void ) const

Return the operation name for the request.

Definition at line 51 of file Request.inl.

References opname_.

00052 {
00053   return this->opname_;
00054 }

CORBA::Boolean CORBA::Request::poll_response ( void )

Definition at line 308 of file Request.cpp.

References ACE_GUARD_RETURN, response_received(), response_received_, and TAO_SYNCH_MUTEX.

00309 {
00310   CORBA::Boolean response_received = false;
00311 
00312   {
00313     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
00314                       ace_mon,
00315                       this->lock_,
00316                       false);
00317     response_received = this->response_received_;
00318   }
00319 
00320   if (!response_received)
00321     {
00322       // If we're single-threaded, the application could starve the ORB,
00323       // and the response never gets received, so let the ORB do an
00324       // atom of work, if necessary, each time we poll.
00325       ACE_Time_Value tv (0, 0);
00326       (void) this->orb_->perform_work (&tv);
00327 
00328       {
00329         ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
00330                           ace_mon,
00331                           this->lock_,
00332                           false);
00333         response_received = this->response_received_;
00334       }
00335     }
00336 
00337   return response_received;
00338 }

ACE_INLINE ACE_CString & CORBA::Request::raw_user_exception ( void )

Accessor for the input stream containing the exception.

Definition at line 180 of file Request.inl.

References raw_user_exception_.

00181 {
00182   return this->raw_user_exception_;
00183 }

ACE_INLINE void CORBA::Request::raw_user_exception ( TAO_InputCDR & cdr )

Definition at line 172 of file Request.inl.

References ACE_Message_Block::length(), raw_user_exception_, ACE_Message_Block::rd_ptr(), ACE_String_Base< CHAR >::set(), and ACE_InputCDR::start().

Referenced by TAO::DII_Invocation::handle_user_exception().

00173 {
00174   this->raw_user_exception_.set (cdr.start ()->rd_ptr (),
00175                                  cdr.start ()->length (),
00176                                  1);
00177 }

ACE_INLINE CORBA::Boolean CORBA::Request::response_received ( void )

Proprietary method to check whether a response has been received.

Definition at line 186 of file Request.inl.

References ACE_GUARD_RETURN, response_received_, and TAO_SYNCH_MUTEX.

Referenced by poll_response().

00187 {
00188   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
00189                     ace_mon,
00190                     this->lock_,
00191                     false);
00192 
00193   return this->response_received_;
00194 }

ACE_INLINE CORBA::NamedValue_ptr CORBA::Request::result ( void )

Return the result for the request.

Definition at line 65 of file Request.inl.

References result_.

00066 {
00067   return this->result_;
00068 }

ACE_INLINE CORBA::Any & CORBA::Request::return_value ( void )

Returns reference to Any for extraction using >>=.

Definition at line 136 of file Request.inl.

References result_.

00137 {
00138   return this->result_->any_;
00139 }

void CORBA::Request::send_deferred ( void )

Definition at line 192 of file Request.cpp.

References ACE_GUARD, args_, response_received_, ACE_OS::strlen(), and TAO_SYNCH_MUTEX.

00193 {
00194   {
00195     ACE_GUARD (TAO_SYNCH_MUTEX,
00196                ace_mon,
00197                this->lock_);
00198 
00199     this->response_received_ = false;
00200   }
00201   CORBA::Boolean const argument_flag = this->args_->count () ? true : false;
00202 
00203   TAO::NamedValue_Argument _tao_retval (this->result_);
00204 
00205   TAO::NVList_Argument _tao_in_list (this->args_,
00206                                      this->lazy_evaluation_);
00207 
00208   TAO::Argument *_tao_arg_list [] = {
00209     &_tao_retval,
00210     &_tao_in_list
00211   };
00212 
00213   size_t number_args = 0;
00214 
00215   if (argument_flag)
00216     number_args = 2;
00217   else
00218     number_args = 1;
00219 
00220   TAO::DII_Deferred_Invocation_Adapter _tao_call (
00221       this->target_,
00222       _tao_arg_list,
00223       number_args,
00224       this->opname_,
00225       static_cast<CORBA::ULong> (ACE_OS::strlen (this->opname_)),
00226       0,
00227       this->orb_->orb_core (),
00228       this);
00229 
00230   _tao_call.invoke (0, 0);
00231 }

void CORBA::Request::send_oneway ( void )

Send a oneway request.

Note:: A default argument is set, but please note that this not recommended as the user may not be able to propagate the exceptions.

Definition at line 168 of file Request.cpp.

References ACE_OS::strlen(), and TAO::TAO_SYNCHRONOUS_INVOCATION.

00169 {
00170   TAO::NamedValue_Argument _tao_retval (this->result_);
00171 
00172   TAO::NVList_Argument _tao_in_list (this->args_,
00173                                      this->lazy_evaluation_);
00174 
00175   TAO::Argument *_tao_arg_list [] = {
00176     &_tao_retval,
00177     &_tao_in_list
00178   };
00179 
00180   TAO::DII_Oneway_Invocation_Adapter _tao_call (
00181       this->target_,
00182       _tao_arg_list,
00183       sizeof( _tao_arg_list ) / sizeof( TAO::Argument* ),
00184       this->opname_,
00185       static_cast<CORBA::ULong> (ACE_OS::strlen (this->opname_)),
00186       TAO::TAO_SYNCHRONOUS_INVOCATION);
00187 
00188   _tao_call.invoke (0, 0);
00189 }

void CORBA::Request::sendc ( CORBA::Object_ptr handler )

The 'asychronous' send method. The object is a DSI based callback handler. This handler must implement Messaging::ReplyHandler

Definition at line 235 of file Request.cpp.

References _tao_reply_stub(), and ACE_OS::strlen().

00236 {
00237   TAO::NamedValue_Argument _tao_retval (this->result_);
00238 
00239   TAO::NVList_Argument _tao_in_list (this->args_,
00240                                      this->lazy_evaluation_);
00241 
00242   TAO::Argument *_tao_arg_list [] = {
00243     &_tao_retval,
00244     &_tao_in_list
00245   };
00246 
00247   TAO::Asynch_Invocation_Adapter _tao_call (
00248        this->target_,
00249        _tao_arg_list,
00250        sizeof( _tao_arg_list ) / sizeof( TAO::Argument* ),
00251        const_cast<char *> (this->opname_),
00252        static_cast<CORBA::ULong> (ACE_OS::strlen (this->opname_)),
00253        0); // collocation proxy broker
00254 
00255   _tao_call.invoke (dynamic_cast<Messaging::ReplyHandler_ptr>(handler),
00256                     &CORBA::Request::_tao_reply_stub);
00257 }

ACE_INLINE void CORBA::Request::set_return_type ( CORBA::TypeCode_ptr tc )

Initialize the return type.

Definition at line 130 of file Request.inl.

References result_.

00131 {
00132   this->result_->any_._tao_set_typecode (tc);
00133 }

ACE_INLINE CORBA::Object_ptr CORBA::Request::target ( void ) const

Return the target of this request.

Definition at line 44 of file Request.inl.

References target_.

00045 {
00046   return this->target_;
00047 }

friend class ::TAO_Dynamic_Adapter_Impl [friend]

Definition at line 205 of file Request.h.

CORBA::NVList_ptr CORBA::Request::args_ [private]

Parameter list.

Definition at line 236 of file Request.h.

Referenced by add_in_arg(), add_inout_arg(), add_out_arg(), arguments(), get_response(), handle_response(), send_deferred(), and ~Request().

int CORBA::Request::byte_order_ [private]

Can be reset by a gateway when passing along a request.

Definition at line 269 of file Request.h.

Referenced by _tao_byte_order(), handle_response(), and invoke().

CORBA::ContextList_ptr CORBA::Request::contexts_ [private]

List of the request's result's contexts.

Definition at line 251 of file Request.h.

Referenced by contexts().

CORBA::Context_ptr CORBA::Request::ctx_ [private]

Context associated with this request.

Definition at line 254 of file Request.h.

Referenced by ctx().

CORBA::ExceptionList_var CORBA::Request::exceptions_ [private]

List of exceptions raised by the operation.

Deprecated:: Holds exceptions.

Definition at line 248 of file Request.h.

Referenced by exceptions(), and Request().

CORBA::Flags CORBA::Request::flags_ [private]

Invocation flags.

Definition at line 242 of file Request.h.

bool CORBA::Request::lazy_evaluation_ [private]

If not zero then the NVList is not evaluated by default.

Definition at line 263 of file Request.h.

Referenced by _tao_lazy_evaluation().

TAO_SYNCH_MUTEX CORBA::Request::lock_ [private]

Protect the response_received_.

Definition at line 260 of file Request.h.

const char* CORBA::Request::opname_ [private]

Operation name.

Definition at line 233 of file Request.h.

Referenced by operation(), and ~Request().

CORBA::ORB_var CORBA::Request::orb_ [private]

Pointer to our ORB.

Definition at line 230 of file Request.h.

ACE_CString CORBA::Request::raw_user_exception_ [private]

Stores user exception as a CDR stream when this request is used in a TAO gateway.

Definition at line 273 of file Request.h.

Referenced by raw_user_exception().

ACE_Atomic_Op<TAO_SYNCH_MUTEX, unsigned long> CORBA::Request::refcount_ [private]

Reference counting.

Definition at line 257 of file Request.h.

Referenced by _decr_refcnt(), _incr_refcnt(), and ~Request().

CORBA::Boolean CORBA::Request::response_received_ [private]

Set to true upon completion of invoke() or handle_response().

Definition at line 266 of file Request.h.

Referenced by handle_response(), invoke(), poll_response(), response_received(), and send_deferred().

CORBA::NamedValue_ptr CORBA::Request::result_ [private]

Result of the operation.

Definition at line 239 of file Request.h.

Referenced by handle_response(), result(), return_value(), set_return_type(), and ~Request().

CORBA::Object_ptr CORBA::Request::target_ [private]

Target object.

Definition at line 227 of file Request.h.

Referenced by target(), and ~Request().

CORBA::Request Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation


Public Types
typedef CORBA::Request_ptr	_ptr_type
typedef CORBA::Request_var	_var_type
typedef CORBA::Request_out	_out_type
Public Member Functions
CORBA::Object_ptr	target (void) const
	Return the target of this request.
const CORBA::Char *	operation (void) const
	Return the operation name for the request.
CORBA::NVList_ptr	arguments (void)
	Return the arguments for the request.
CORBA::NamedValue_ptr	result (void)
	Return the result for the request.
CORBA::ExceptionList_ptr	exceptions (void)
	Return the exceptions resulting from this request.
CORBA::Context_ptr	ctx (void) const
	Accessor for the Context member.
void	ctx (CORBA::Context_ptr)
	Mutator for the Context member.
CORBA::ContextList_ptr	contexts (void)
void	set_return_type (CORBA::TypeCode_ptr tc)
	Initialize the return type.
CORBA::Any &	return_value (void)
	Returns reference to Any for extraction using >>=.
void	invoke (void)
	Perform method resolution and invoke an appropriate method.
void	send_oneway (void)
	Send a oneway request.
void	handle_response (TAO_InputCDR &incoming, GIOP::ReplyStatusType reply_status)
	Callback method for deferred synchronous requests.
void	sendc (CORBA::Object_ptr handler)
CORBA::ULong	_incr_refcnt (void)
CORBA::ULong	_decr_refcnt (void)
void	_tao_lazy_evaluation (bool lazy_evaluation)
	Set the lazy evaluation flag.
int	_tao_byte_order (void) const
	Get the byte order member.
void	_tao_byte_order (int byte_order)
	Set the byte order member.
void	raw_user_exception (TAO_InputCDR &cdr)
ACE_CString &	raw_user_exception (void)
	Accessor for the input stream containing the exception.
CORBA::Boolean	response_received (void)
Argument manipulation helper functions.
Arg adders, one for each type of parameter, with and without optional name. Returns reference to Any for insertion using <<=.
CORBA::Any &	add_in_arg (void)
CORBA::Any &	add_in_arg (const char *name)
CORBA::Any &	add_inout_arg (void)
CORBA::Any &	add_inout_arg (const char *name)
CORBA::Any &	add_out_arg (void)
CORBA::Any &	add_out_arg (const char *name)
The 'deferred synchronous' methods.
The 'deferred synchronous' methods.
void	send_deferred (void)
void	get_response (void)
CORBA::Boolean	poll_response (void)
Static Public Member Functions
static void	_tao_reply_stub (TAO_InputCDR &_tao_reply_cdr, Messaging::ReplyHandler_ptr _tao_reply_handler, CORBA::ULong reply_status)
static CORBA::Request *	_duplicate (CORBA::Request *)
	Pseudo object methods.
static CORBA::Request *	_nil (void)
Private Member Functions
	Request (CORBA::Object_ptr obj, CORBA::ORB_ptr orb, const CORBA::Char *op, CORBA::NVList_ptr args, CORBA::NamedValue_ptr result, CORBA::Flags flags, CORBA::ExceptionList_ptr exceptions)
	Request (CORBA::Object_ptr obj, CORBA::ORB_ptr orb, const CORBA::Char *op)
	~Request (void)
Private Attributes
CORBA::Object_ptr	target_
	Target object.
CORBA::ORB_var	orb_
	Pointer to our ORB.
const char *	opname_
	Operation name.
CORBA::NVList_ptr	args_
	Parameter list.
CORBA::NamedValue_ptr	result_
	Result of the operation.
CORBA::Flags	flags_
	Invocation flags.
CORBA::ExceptionList_var	exceptions_
	List of exceptions raised by the operation.
CORBA::ContextList_ptr	contexts_
	List of the request's result's contexts.
CORBA::Context_ptr	ctx_
	Context associated with this request.
ACE_Atomic_Op< TAO_SYNCH_MUTEX, unsigned long >	refcount_
	Reference counting.
TAO_SYNCH_MUTEX	lock_
	Protect the response_received_.
bool	lazy_evaluation_
	If not zero then the NVList is not evaluated by default.
CORBA::Boolean	response_received_
	Set to true upon completion of invoke() or handle_response().
int	byte_order_
	Can be reset by a gateway when passing along a request.
ACE_CString	raw_user_exception_
Friends
class	::TAO_Dynamic_Adapter_Impl