TAO_ServerRequest Class Reference

Class representing a ServerRequest object. More...

#include <TAO_Server_Request.h>

Collaboration diagram for TAO_ServerRequest:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 TAO_ServerRequest (TAO_GIOP_Message_Base *mesg_base, TAO_InputCDR &input, TAO_OutputCDR &output, TAO_Transport *transport, TAO_ORB_Core *orb_core)
 TAO_ServerRequest (TAO_GIOP_Message_Base *mesg_base, CORBA::ULong request_id, CORBA::Boolean response_expected, CORBA::Boolean deferred_flag, TAO::ObjectKey &object_key, const char *operation, TAO_OutputCDR &output, TAO_Transport *transport, TAO_ORB_Core *orb_core, int &parse_error)
 TAO_ServerRequest (TAO_ORB_Core *orb_core, TAO_Operation_Details const &details, CORBA::Object_ptr target)
 Constructor used by thru-POA collocated invocation path.
 ~TAO_ServerRequest (void)
 Destructor.
CORBA::ORB_ptr orb (void)
 Return the underlying ORB.
TAO_ORB_Core * orb_core (void) const
 Return the ORB core pointer member.
void init_reply (void)
 Start a Reply message.
TAO_InputCDR * incoming (void) const
 Retrieve the incoming stream.
TAO_OutputCDR * outgoing (void) const
 Retrieve the outgoing stream.
CORBA::Boolean response_expected (void) const
 Is the response expected?
CORBA::Boolean deferred_reply (void) const
 Should the reply be deferred?
void response_expected (CORBA::Boolean response)
 Set the response expected flag.
CORBA::Boolean sync_with_server (void) const
 Should we return before dispatching the servant?
void sync_with_server (CORBA::Boolean sync_flag)
 Set the sync_with_server flag.
void send_no_exception_reply (void)
 Used with reliable oneway requests.
TAO::ObjectKey & object_key (void)
TAO_Service_Context & request_service_context (void)
 Return the request TAO_Service_Context.
TAO_Service_Context & reply_service_context (void)
 Return the reply TAO_Service_Context.
IOP::ServiceContextList & reply_service_info (void)
IOP::ServiceContextList & request_service_info (void)
TAO_Transport * transport ()
 Return the underlying transport.
void forward_location (CORBA::Object_ptr forward_reference)
CORBA::Object_ptr forward_location (void)
 Get the forward_location.
bool is_forwarded (void) const
GIOP::ReplyStatusType reply_status (void)
 Get the reply status.
void reply_status (GIOP::ReplyStatusType except_type)
 Set the reply status.
void requesting_principal (const CORBA::OctetSeq &principal)
 Set the requesting principal.
TAO_Tagged_Profile & profile (void)
 Return the reference to the tagged profile.
void tao_send_reply (void)
void tao_send_reply_exception (const CORBA::Exception &ex)
void is_dsi (void)
 Set the boolean member to 1.
void dsi_nvlist_align (ptrdiff_t alignment)
 Set the member.
TAO_Operation_Details const * operation_details (void) const
void argument_flag (CORBA::Boolean flag)
 Set the argument_flag.
CORBA::Boolean argument_flag (void)
 Get the argument_flag.
bool collocated (void) const
 Returns true if the current request is collocated.
void send_cached_reply (CORBA::OctetSeq &ocs)
size_t & interceptor_count (void)
TAO::PICurrent_Impl * rs_pi_current (void)
 Return a reference to the "request scope" PICurrent object.
CORBA::Exception * caught_exception (void)
void caught_exception (CORBA::Exception *exception)
void pi_reply_status (PortableInterceptor::ReplyStatus s)
 Set the status of the received reply.
PortableInterceptor::ReplyStatus pi_reply_status (void)
 Get the status of the received reply.
Request attributes.
const char * operation (void) const
 Return the operation name.
void operation (const char *operation, size_t length, int release)
 Set the operation name.
size_t operation_length (void) const
 Return the length of the operation.
CORBA::ULong request_id (void)
void request_id (CORBA::ULong req)

Private Member Functions

 TAO_ServerRequest (void)

Private Attributes

TAO_GIOP_Message_Base * mesg_base_
const char * operation_
 Operation name.
size_t operation_len_
 Operation length.
bool release_operation_
 Do we own the memory associated with operation_?
CORBA::Object_var forward_location_
bool is_forwarded_
TAO_InputCDR * incoming_
 Incoming stream.
TAO_OutputCDR * outgoing_
 Outgoing stream.
CORBA::Boolean response_expected_
CORBA::Boolean deferred_reply_
CORBA::Boolean sync_with_server_
CORBA::Boolean is_dsi_
 Did we get passed to a CORBA::ServerRequest?
GIOP::ReplyStatusType reply_status_
 Reply status (will be NO_EXCEPTION in the majority of the cases).
TAO_ORB_Core * orb_core_
TAO_Service_Context request_service_context_
 Service Context info.
TAO_Service_Context reply_service_context_
CORBA::ULong request_id_
 Unique identifier for a request.
TAO_Tagged_Profile profile_
 The tagged profile that has the addressing information.
CORBA::OctetSeq_var requesting_principal_
 Identifies the requester.
ptrdiff_t dsi_nvlist_align_
 Used to pad CDR stream if we have used DSI.
TAO_Operation_Details const * operation_details_
CORBA::Boolean argument_flag_
size_t interceptor_count_
TAO::PICurrent_Impl * rs_pi_current_
CORBA::Exception * caught_exception_
 Pointer to the caught exception.
PortableInterceptor::ReplyStatus pi_reply_status_
 Reply status for the current request.
TAO::Transport_Selection_Guard transport_

Friends

class TAO::CSD::FW_Server_Request_Wrapper
class TAO_AMH_Response_Handler
 Declare TAO_AMH_Response_Handler a friend.

Detailed Description

Class representing a ServerRequest object.

Encapsulates CDR, transport and pluggable messaging components on the server side.

Definition at line 82 of file TAO_Server_Request.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_ServerRequest::TAO_ServerRequest ( TAO_GIOP_Message_Base *  mesg_base,
TAO_InputCDR &  input,
TAO_OutputCDR &  output,
TAO_Transport *  transport,
TAO_ORB_Core *  orb_core 
)

Definition at line 51 of file TAO_Server_Request.cpp.

References ACE_FUNCTION_TIMEPROBE.

00056   : mesg_base_ (mesg_base),
00057     operation_ (0),
00058     operation_len_ (0),
00059     release_operation_ (false),
00060     is_forwarded_ (false),
00061     incoming_ (&input),
00062     outgoing_ (&output),
00063     response_expected_ (false),
00064     deferred_reply_ (false),
00065     sync_with_server_ (false),
00066     is_dsi_ (false),
00067     // @@ We shouldn't be using GIOP specific types here. Need to be revisited.
00068     reply_status_ (GIOP::NO_EXCEPTION),
00069     orb_core_ (orb_core),
00070     request_id_ (0),
00071     profile_ (orb_core),
00072     requesting_principal_ (0),
00073     dsi_nvlist_align_ (0),
00074     operation_details_ (0),
00075     argument_flag_ (true)
00076 #if TAO_HAS_INTERCEPTORS == 1
00077     , interceptor_count_ (0)
00078     , rs_pi_current_ (0)
00079     , caught_exception_ (0)
00080     , pi_reply_status_ (-1)
00081 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
00082     , transport_(transport) //already duplicated in TAO_Transport::process_parsed_messages ()
00083 {
00084   ACE_FUNCTION_TIMEPROBE (TAO_SERVER_REQUEST_START);
00085   // No-op.
00086 }

TAO_ServerRequest::TAO_ServerRequest ( TAO_GIOP_Message_Base *  mesg_base,
CORBA::ULong  request_id,
CORBA::Boolean  response_expected,
CORBA::Boolean  deferred_flag,
TAO::ObjectKey &  object_key,
const char *  operation,
TAO_OutputCDR &  output,
TAO_Transport *  transport,
TAO_ORB_Core *  orb_core,
int &  parse_error 
)

Definition at line 89 of file TAO_Server_Request.cpp.

References TAO_Tagged_Profile::object_key(), and profile_.

00099   : mesg_base_ (mesg_base),
00100     operation_ (CORBA::string_dup (operation)),
00101     operation_len_ (operation == 0 ? 0 : ACE_OS::strlen (operation)),
00102     release_operation_ (true),
00103     is_forwarded_ (false),
00104     incoming_ (0),
00105     outgoing_ (&output),
00106     response_expected_ (response_expected),
00107     deferred_reply_ (deferred_reply),
00108     sync_with_server_ (false),
00109     is_dsi_ (false),
00110     reply_status_ (GIOP::NO_EXCEPTION),
00111     orb_core_ (orb_core),
00112     request_id_ (request_id),
00113     profile_ (orb_core),
00114     requesting_principal_ (0),
00115     dsi_nvlist_align_ (0),
00116     operation_details_ (0),
00117     argument_flag_ (true)
00118 #if TAO_HAS_INTERCEPTORS == 1
00119   , interceptor_count_ (0)
00120   , rs_pi_current_ (0)
00121   , caught_exception_ (0)
00122   , pi_reply_status_ (-1)
00123 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
00124   , transport_(transport) //already duplicated in TAO_Transport::process_parsed_messages ()
00125 {
00126   this->profile_.object_key (object_key);
00127   parse_error = 0;
00128 }

TAO_ServerRequest::TAO_ServerRequest ( TAO_ORB_Core *  orb_core,
TAO_Operation_Details const &  details,
CORBA::Object_ptr  target 
)

Constructor used by thru-POA collocated invocation path.

Definition at line 131 of file TAO_Server_Request.cpp.

References CORBA::Object::_stubobj(), TAO_Stub::object_key(), TAO_Tagged_Profile::object_key(), profile_, request_service_context_, and TAO_Service_Context::service_info().

00134   : mesg_base_ (0),
00135     operation_ (details.opname ()),
00136     operation_len_ (details.opname_len ()),
00137     release_operation_ (false),
00138     is_forwarded_ (false),
00139     incoming_ (0),
00140     outgoing_ (0),
00141     response_expected_ (details.response_flags () == TAO_TWOWAY_RESPONSE_FLAG
00142                         || details.response_flags () == static_cast<CORBA::Octet> (Messaging::SYNC_WITH_SERVER)
00143                         || details.response_flags () == static_cast<CORBA::Octet> (Messaging::SYNC_WITH_TARGET)),
00144     deferred_reply_ (false),
00145     sync_with_server_ (details.response_flags () == static_cast<CORBA::Octet> (Messaging::SYNC_WITH_SERVER)),
00146     is_dsi_ (false),
00147     reply_status_ (GIOP::NO_EXCEPTION),
00148     orb_core_ (orb_core),
00149     request_id_ (0),
00150     profile_ (orb_core),
00151     requesting_principal_ (0),
00152     dsi_nvlist_align_ (0),
00153     operation_details_ (&details),
00154     argument_flag_ (false)
00155 #if TAO_HAS_INTERCEPTORS == 1
00156   , interceptor_count_ (0)
00157   , rs_pi_current_ (0)
00158   , caught_exception_ (0)
00159   , pi_reply_status_ (-1)
00160 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
00161   , transport_ (0)
00162 {
00163   // Have to use a const_cast<>.  *sigh*
00164   this->profile_.object_key (
00165     const_cast<TAO::ObjectKey &> (target->_stubobj ()->object_key ()));
00166 
00167   // Shallow copy the request service context list. This way the operation
00168   // details and server request share the request context.
00169   IOP::ServiceContextList & dest_request_contexts =
00170     this->request_service_context_.service_info ();
00171 
00172   IOP::ServiceContextList & src_request_contexts =
00173     (const_cast <TAO_Operation_Details&> (details)).request_service_info ();
00174 
00175   dest_request_contexts.replace (src_request_contexts.maximum (),
00176                                  src_request_contexts.length (),
00177                                  src_request_contexts.get_buffer (),
00178                                  false /* Do not release. */);
00179 
00180   // Don't shallow copy the reply service context. It is probably empty,
00181   // when then during the request it is used, the buffer gets allocated and
00182   // then the operation details don't get the reply service context
00183 }

TAO_ServerRequest::~TAO_ServerRequest ( void   ) 

Destructor.

Definition at line 185 of file TAO_Server_Request.cpp.

References orb_core_, TAO_ORB_Core::serverrequestinterceptor_adapter(), and CORBA::string_free().

00186 {
00187 #if TAO_HAS_INTERCEPTORS == 1
00188   if (this->rs_pi_current_)
00189     {
00190       TAO::ServerRequestInterceptor_Adapter *interceptor_adapter =
00191         this->orb_core_->serverrequestinterceptor_adapter ();
00192 
00193       if (interceptor_adapter)
00194         {
00195           interceptor_adapter->deallocate_pi_current (
00196             this->rs_pi_current_);
00197         }
00198     }
00199 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
00200   if (this->release_operation_)
00201     CORBA::string_free (const_cast<char*> (this->operation_));
00202 }

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE TAO_ServerRequest::TAO_ServerRequest ( void   )  [private]

Default ctor only used to create a TAO_ServerRequest that is about to be the target of a clone operation.

Definition at line 11 of file TAO_Server_Request.inl.

00012   : mesg_base_ (0),
00013     operation_ (0),
00014     operation_len_ (0),
00015     release_operation_ (false),
00016     incoming_ (0),
00017     outgoing_ (0),
00018     response_expected_ (false),
00019     deferred_reply_ (false),
00020     sync_with_server_ (false),
00021     is_dsi_ (false),
00022     reply_status_ (GIOP::NO_EXCEPTION),
00023     orb_core_ (0),
00024     request_id_ (0),
00025     profile_ (0),
00026     requesting_principal_ (0),
00027     dsi_nvlist_align_ (0),
00028     operation_details_ (0),
00029     argument_flag_ (true)
00030 #if TAO_HAS_INTERCEPTORS == 1
00031   , interceptor_count_ (0)
00032   , rs_pi_current_ ()
00033   , caught_exception_ (0)
00034   , pi_reply_status_ (-1)
00035 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
00036   ,  transport_(0)
00037 {
00038 }

Member Function Documentation

ACE_INLINE CORBA::Boolean TAO_ServerRequest::argument_flag ( void   ) 

Get the argument_flag.

Definition at line 218 of file TAO_Server_Request.inl.

References argument_flag_.

00219 {
00220   return this->argument_flag_;
00221 }

ACE_INLINE void TAO_ServerRequest::argument_flag ( CORBA::Boolean  flag  ) 

Set the argument_flag.

Definition at line 224 of file TAO_Server_Request.inl.

References argument_flag_.

00225 {
00226   this->argument_flag_ = flag;
00227 }

void TAO_ServerRequest::caught_exception ( CORBA::Exception *  exception  ) 

Definition at line 548 of file TAO_Server_Request.cpp.

References CORBA::UserException::_downcast(), CORBA::SystemException::_downcast(), caught_exception_, pi_reply_status_, CORBA::SYSTEM_EXCEPTION, and CORBA::USER_EXCEPTION.

00549 {
00550   if (CORBA::SystemException::_downcast (exception) != 0)
00551     this->pi_reply_status_ = PortableInterceptor::SYSTEM_EXCEPTION;
00552   else if (CORBA::UserException::_downcast (exception) != 0)
00553     this->pi_reply_status_ = PortableInterceptor::USER_EXCEPTION;
00554 
00555   this->caught_exception_ = exception;
00556 }

ACE_INLINE CORBA::Exception * TAO_ServerRequest::caught_exception ( void   ) 

Definition at line 244 of file TAO_Server_Request.inl.

References caught_exception_.

00245 {
00246   return this->caught_exception_;
00247 }

ACE_INLINE bool TAO_ServerRequest::collocated ( void   )  const

Returns true if the current request is collocated.

Definition at line 230 of file TAO_Server_Request.inl.

References transport_.

00231 {
00232   return this->transport_.get () == 0;
00233 }

ACE_INLINE CORBA::Boolean TAO_ServerRequest::deferred_reply ( void   )  const

Should the reply be deferred?

Definition at line 90 of file TAO_Server_Request.inl.

References deferred_reply_.

00091 {
00092   return this->deferred_reply_;
00093 }

ACE_INLINE void TAO_ServerRequest::dsi_nvlist_align ( ptrdiff_t  alignment  ) 

Set the member.

Definition at line 212 of file TAO_Server_Request.inl.

References dsi_nvlist_align_.

00213 {
00214   this->dsi_nvlist_align_ = alignment;
00215 }

ACE_INLINE CORBA::Object_ptr TAO_ServerRequest::forward_location ( void   ) 

Get the forward_location.

Definition at line 176 of file TAO_Server_Request.inl.

References CORBA::Object::_duplicate().

00177 {
00178   return CORBA::Object::_duplicate (this->forward_location_.in ());
00179 }

ACE_INLINE void TAO_ServerRequest::forward_location ( CORBA::Object_ptr  forward_reference  ) 

Set the reference to the object the request should be forwarded to. This reference will only be used if set prior to calling init_reply().

Definition at line 168 of file TAO_Server_Request.inl.

References CORBA::Object::_duplicate(), forward_location_, and is_forwarded_.

00169 {
00170   this->forward_location_ =
00171     CORBA::Object::_duplicate (forward_reference);
00172   this->is_forwarded_ = true;
00173 }

ACE_INLINE TAO_InputCDR * TAO_ServerRequest::incoming ( void   )  const

Retrieve the incoming stream.

Definition at line 47 of file TAO_Server_Request.inl.

References incoming_.

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header(), and TAO_GIOP_Message_Generator_Parser_10::parse_request_header().

00048 {
00049   return this->incoming_;
00050 }

void TAO_ServerRequest::init_reply ( void   ) 

Start a Reply message.

Definition at line 226 of file TAO_Server_Request.cpp.

References ACE_DEBUG, ACE_TEXT, argument_flag_, TAO_Pluggable_Reply_Params_Base::argument_flag_, dsi_nvlist_align_, TAO_Pluggable_Reply_Params_Base::dsi_nvlist_align_, TAO_GIOP_Message_Base::generate_reply_header(), is_dsi_, TAO_Pluggable_Reply_Params_Base::is_dsi_, TAO_ORB_Core::is_permanent_forward_condition(), LM_DEBUG, mesg_base_, TAO_OutputCDR::message_attributes(), orb_core_, outgoing_, TAO_Pluggable_Reply_Params_Base::reply_status(), request_id_, TAO_Pluggable_Reply_Params_Base::request_id_, request_service_context(), TAO_Pluggable_Reply_Params_Base::service_context_notowned(), TAO_Transport::TAO_REPLY, and transport_.

00227 {
00228   if (!this->outgoing_)
00229     return;  // Collocated
00230 
00231   // Construct our reply generator.
00232   TAO_Pluggable_Reply_Params_Base reply_params;
00233 
00234   // We put all the info that we have in to this <reply_params> and
00235   // call the <write_reply_header> in the
00236   // pluggable_messaging_interface. One point to be noted however is
00237   // that, it was the pluggable_messaging classes who created us and
00238   // delegated us to do work on its behalf. But we would be calling
00239   // back. As we don't have a LOCK or any such things we can call
00240   // pluggable_messaging guys again. We would be on the same thread of
00241   // invocation. So *theoretically* there should not be a problem.
00242   reply_params.request_id_ = this->request_id_;
00243   reply_params.is_dsi_ = this->is_dsi_;
00244   reply_params.dsi_nvlist_align_ = this->dsi_nvlist_align_;
00245 
00246   // Send back the reply service context.
00247   reply_params.service_context_notowned (&this->reply_service_info ());
00248 
00249   // Are we going to marshall any data with the reply?
00250   reply_params.argument_flag_ = this->argument_flag_;
00251 
00252   // Forward exception only.
00253   if (this->is_forwarded_)
00254     {
00255       CORBA::Boolean const permanent_forward_condition =
00256         this->orb_core_->is_permanent_forward_condition (this->forward_location_.in (),
00257                                                          this->request_service_context ());
00258 
00259       reply_params.reply_status (
00260         permanent_forward_condition
00261         ? GIOP::LOCATION_FORWARD_PERM
00262         : GIOP::LOCATION_FORWARD);
00263     }
00264   // Any exception at all.
00265   else
00266     {
00267       reply_params.reply_status (this->reply_status_);
00268     }
00269 
00270   this->outgoing_->message_attributes (this->request_id_,
00271                                        0,
00272                                        TAO_Transport::TAO_REPLY,
00273                                        0);
00274 
00275   // Construct a REPLY header.
00276   this->mesg_base_->generate_reply_header (*this->outgoing_, reply_params);
00277 
00278   // Finish the GIOP Reply header, then marshal the exception.
00279   if (reply_params.reply_status () == GIOP::LOCATION_FORWARD ||
00280       reply_params.reply_status () == GIOP::LOCATION_FORWARD_PERM)
00281     {
00282       // Marshal the forward location pointer.
00283       CORBA::Object_ptr object_ptr = this->forward_location_.in ();
00284 
00285       if ((*this->outgoing_ << object_ptr) == 0)
00286         {
00287           ACE_DEBUG ((LM_DEBUG,
00288                       ACE_TEXT ("TAO (%P|%t) - ServerRequest::init_reply, ")
00289                       ACE_TEXT ("TAO_GIOP_ServerRequest::marshal - ")
00290                       ACE_TEXT ("marshal encoding forwarded objref failed\n")));
00291         }
00292     }
00293   this->transport_->assign_translators (0, this->outgoing_);
00294 }

ACE_INLINE size_t & TAO_ServerRequest::interceptor_count ( void   ) 

Note:
It is a reference since the Portable Interceptor flow stack code must be able to modify this value and use that value at a later time without being forced to use TSS.

Definition at line 238 of file TAO_Server_Request.inl.

References interceptor_count_.

00239 {
00240   return this->interceptor_count_;
00241 }

ACE_INLINE void TAO_ServerRequest::is_dsi ( void   ) 

Set the boolean member to 1.

Definition at line 200 of file TAO_Server_Request.inl.

References is_dsi_.

00201 {
00202   this->is_dsi_ = true;
00203 }

ACE_INLINE bool TAO_ServerRequest::is_forwarded ( void   )  const

Since forward location is allowed to be nil then this is a proper method to check if the request is being forwarded.

Definition at line 182 of file TAO_Server_Request.inl.

References is_forwarded_.

Referenced by TAO_Adapter_Registry::dispatch(), TAO_GIOP_Message_Base::process_locate_request(), and TAO_GIOP_Message_Base::process_request().

00183 {
00184   return this->is_forwarded_;
00185 }

ACE_INLINE TAO::ObjectKey & TAO_ServerRequest::object_key ( void   ) 

Definition at line 114 of file TAO_Server_Request.inl.

References TAO_Tagged_Profile::object_key(), and profile_.

Referenced by TAO_Request_Dispatcher::dispatch().

00115 {
00116   return this->profile_.object_key ();
00117 }

ACE_INLINE void TAO_ServerRequest::operation ( const char *  operation,
size_t  length,
int  release 
)

Set the operation name.

Definition at line 65 of file TAO_Server_Request.inl.

References operation_, operation_len_, release_operation_, CORBA::string_free(), and ACE_OS::strlen().

00068 {
00069   if (this->release_operation_)
00070     CORBA::string_free (const_cast <char*> (this->operation_));
00071 
00072   this->operation_len_ = (length == 0 ? ACE_OS::strlen (operation) : length);
00073   this->release_operation_ = release;
00074   this->operation_ = operation;
00075 }

ACE_INLINE const char * TAO_ServerRequest::operation ( void   )  const

Return the operation name.

Definition at line 59 of file TAO_Server_Request.inl.

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header(), and TAO_GIOP_Message_Generator_Parser_10::parse_request_header().

00060 {
00061   return (this->operation_ == 0 ? "" : this->operation_);
00062 }

ACE_INLINE TAO_Operation_Details const * TAO_ServerRequest::operation_details ( void   )  const

Definition at line 206 of file TAO_Server_Request.inl.

References operation_details_.

00207 {
00208   return this->operation_details_;
00209 }

ACE_INLINE size_t TAO_ServerRequest::operation_length ( void   )  const

Return the length of the operation.

Definition at line 78 of file TAO_Server_Request.inl.

References operation_len_.

00079 {
00080   return this->operation_len_;
00081 }

CORBA::ORB_ptr TAO_ServerRequest::orb ( void   ) 

Return the underlying ORB.

Definition at line 205 of file TAO_Server_Request.cpp.

References TAO_ORB_Core::orb(), and orb_core_.

00206 {
00207   return this->orb_core_->orb ();
00208 }

ACE_INLINE TAO_ORB_Core * TAO_ServerRequest::orb_core ( void   )  const

Return the ORB core pointer member.

Definition at line 41 of file TAO_Server_Request.inl.

References orb_core_.

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header(), and TAO_GIOP_Message_Base::process_request().

00042 {
00043   return this->orb_core_;
00044 }

ACE_INLINE TAO_OutputCDR * TAO_ServerRequest::outgoing ( void   )  const

Retrieve the outgoing stream.

Definition at line 53 of file TAO_Server_Request.inl.

References outgoing_.

00054 {
00055   return this->outgoing_;
00056 }

ACE_INLINE PortableInterceptor::ReplyStatus TAO_ServerRequest::pi_reply_status ( void   ) 

Get the status of the received reply.

Definition at line 256 of file TAO_Server_Request.inl.

References pi_reply_status_.

00257 {
00258   return this->pi_reply_status_;
00259 }

ACE_INLINE void TAO_ServerRequest::pi_reply_status ( PortableInterceptor::ReplyStatus  s  ) 

Set the status of the received reply.

Definition at line 250 of file TAO_Server_Request.inl.

References pi_reply_status_.

00251 {
00252   this->pi_reply_status_ = s;
00253 }

ACE_INLINE TAO_Tagged_Profile & TAO_ServerRequest::profile ( void   ) 

Return the reference to the tagged profile.

Definition at line 162 of file TAO_Server_Request.inl.

References profile_.

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header(), and TAO_GIOP_Message_Generator_Parser_10::parse_request_header().

00163 {
00164   return this->profile_;
00165 }

TAO_Service_Context & TAO_ServerRequest::reply_service_context ( void   ) 

Return the reply TAO_Service_Context.

Definition at line 211 of file TAO_Server_Request.cpp.

References operation_details_, and reply_service_context_.

Referenced by reply_service_info().

00212 {
00213   if (!operation_details_)
00214     {
00215       return this->reply_service_context_;
00216     }
00217   else
00218     {
00219       return const_cast <TAO_Operation_Details*> (
00220         this->operation_details_)->reply_service_context ();
00221     }
00222 }

ACE_INLINE IOP::ServiceContextList & TAO_ServerRequest::reply_service_info ( void   ) 

Definition at line 126 of file TAO_Server_Request.inl.

References reply_service_context(), and TAO_Service_Context::service_info().

Referenced by TAO_GIOP_Message_Base::process_request().

00127 {
00128   return this->reply_service_context ().service_info ();
00129 }

ACE_INLINE void TAO_ServerRequest::reply_status ( GIOP::ReplyStatusType  except_type  ) 

Set the reply status.

Definition at line 194 of file TAO_Server_Request.inl.

References reply_status_.

00195 {
00196   this->reply_status_ = reply_status;
00197 }

ACE_INLINE GIOP::ReplyStatusType TAO_ServerRequest::reply_status ( void   ) 

Get the reply status.

Definition at line 188 of file TAO_Server_Request.inl.

References reply_status_.

Referenced by TAO_GIOP_Message_Base::process_locate_request().

00189 {
00190   return this->reply_status_;
00191 }

ACE_INLINE void TAO_ServerRequest::request_id ( CORBA::ULong  req  ) 

To handle System Exceptions at the lowest level, a method returning the request_id_ is needed.

Definition at line 150 of file TAO_Server_Request.inl.

References request_id_.

00151 {
00152   this->request_id_ = req;
00153 }

ACE_INLINE CORBA::ULong TAO_ServerRequest::request_id ( void   ) 

To handle System Exceptions at the lowest level, a method returning the request_id_ is needed.

Definition at line 144 of file TAO_Server_Request.inl.

References request_id_.

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header(), TAO_GIOP_Message_Generator_Parser_10::parse_request_header(), and TAO_GIOP_Message_Base::process_request().

00145 {
00146   return this->request_id_;
00147 }

ACE_INLINE TAO_Service_Context & TAO_ServerRequest::request_service_context ( void   ) 

Return the request TAO_Service_Context.

Definition at line 120 of file TAO_Server_Request.inl.

References request_service_context_.

Referenced by init_reply(), TAO_GIOP_Message_Base::process_request(), TAO_Service_Context_Registry::process_service_contexts(), and request_service_info().

00121 {
00122   return this->request_service_context_;
00123 }

ACE_INLINE IOP::ServiceContextList & TAO_ServerRequest::request_service_info ( void   ) 

Definition at line 132 of file TAO_Server_Request.inl.

References request_service_context(), and TAO_Service_Context::service_info().

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header(), and TAO_GIOP_Message_Generator_Parser_10::parse_request_header().

00133 {
00134   return this->request_service_context ().service_info ();
00135 }

ACE_INLINE void TAO_ServerRequest::requesting_principal ( const CORBA::OctetSeq &  principal  ) 

Set the requesting principal.

Definition at line 156 of file TAO_Server_Request.inl.

References requesting_principal_.

Referenced by TAO_GIOP_Message_Generator_Parser_10::parse_request_header().

00157 {
00158   this->requesting_principal_ = principal;
00159 }

ACE_INLINE void TAO_ServerRequest::response_expected ( CORBA::Boolean  response  ) 

Set the response expected flag.

Definition at line 96 of file TAO_Server_Request.inl.

References response_expected_.

00097 {
00098   this->response_expected_ = response;
00099 }

ACE_INLINE CORBA::Boolean TAO_ServerRequest::response_expected ( void   )  const

Is the response expected?

Definition at line 84 of file TAO_Server_Request.inl.

References response_expected_.

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header(), TAO_GIOP_Message_Generator_Parser_10::parse_request_header(), and TAO_GIOP_Message_Base::process_request().

00085 {
00086   return this->response_expected_;
00087 }

TAO::PICurrent_Impl * TAO_ServerRequest::rs_pi_current ( void   ) 

Return a reference to the "request scope" PICurrent object.

Definition at line 559 of file TAO_Server_Request.cpp.

References orb_core_, rs_pi_current_, and TAO_ORB_Core::serverrequestinterceptor_adapter().

00560 {
00561   if (!this->rs_pi_current_)
00562     {
00563       TAO::ServerRequestInterceptor_Adapter *interceptor_adapter =
00564         this->orb_core_->serverrequestinterceptor_adapter ();
00565 
00566       if (interceptor_adapter)
00567         {
00568           this->rs_pi_current_ = interceptor_adapter->allocate_pi_current ();
00569         }
00570     }
00571 
00572   return this->rs_pi_current_;
00573 }

void TAO_ServerRequest::send_cached_reply ( CORBA::OctetSeq &  ocs  ) 

Send cached reply. Used in scenarios where the FTORB thinks that this request is a duplicate

Append reply here....

Definition at line 466 of file TAO_Server_Request.cpp.

References ACE_ERROR, ACE_TEXT, TAO_Pluggable_Reply_Params_Base::argument_flag_, TAO_ORB_Parameters::cdr_memcpy_tradeoff(), ACE_CDR::DEFAULT_BUFSIZE, TAO_GIOP_Message_Base::fragmentation_strategy(), TAO_OutputCDR::get_version(), LM_ERROR, TAO_GIOP_Message_Version::major, mesg_base_, TAO_OutputCDR::message_attributes(), TAO_GIOP_Message_Version::minor, TAO_OutputCDR::more_fragments(), CORBA::NO_EXCEPTION, orb_core_, TAO_ORB_Core::orb_params(), outgoing_, TAO_ORB_Core::output_cdr_dblock_allocator(), TAO_ORB_Core::output_cdr_msgblock_allocator(), TAO_Pluggable_Reply_Params_Base::reply_status(), request_id_, TAO_Pluggable_Reply_Params_Base::request_id_, TAO_Pluggable_Reply_Params_Base::service_context_notowned(), TAO_Pluggable_Reply_Params_Base::svc_ctx_, TAO_ENCAP_BYTE_ORDER, TAO_Transport::TAO_REPLY, transport_, and ACE_OutputCDR::write_octet_array().

00467 {
00468 #if defined(ACE_HAS_PURIFY)
00469   // Only inititialize the buffer if we're compiling with Purify.
00470   // Otherwise, there is no real need to do so, especially since
00471   // we can avoid the initialization overhead at runtime if we
00472   // are not compiling with Purify support.
00473   char repbuf[ACE_CDR::DEFAULT_BUFSIZE] = { 0 };
00474 #else
00475   char repbuf[ACE_CDR::DEFAULT_BUFSIZE];
00476 #endif /* ACE_HAS_PURIFY */
00477   TAO_GIOP_Message_Version gv;
00478   if (this->outgoing_)
00479     this->outgoing_->get_version (gv);
00480   TAO_OutputCDR output (repbuf,
00481                         sizeof repbuf,
00482                         TAO_ENCAP_BYTE_ORDER,
00483                         this->orb_core_->output_cdr_buffer_allocator (),
00484                         this->orb_core_->output_cdr_dblock_allocator (),
00485                         this->orb_core_->output_cdr_msgblock_allocator (),
00486                         this->orb_core_->orb_params ()->cdr_memcpy_tradeoff (),
00487                         this->mesg_base_->fragmentation_strategy (),
00488                         gv.major,
00489                         gv.minor);
00490 
00491   this->transport_->assign_translators (0, &output);
00492 
00493   // A copy of the reply parameters
00494   TAO_Pluggable_Reply_Params_Base reply_params;
00495 
00496   reply_params.request_id_ = this->request_id_;
00497 
00498   reply_params.svc_ctx_.length (0);
00499 
00500   // Send back the empty reply service context.
00501   reply_params.service_context_notowned (&this->reply_service_info ());
00502 
00503   // We are going to send some data
00504   reply_params.argument_flag_ = true;
00505 
00506   // Make a default reply status
00507   reply_params.reply_status (GIOP::NO_EXCEPTION);
00508 
00509   this->outgoing_->message_attributes (this->request_id_,
00510                                        0,
00511                                        TAO_Transport::TAO_REPLY,
00512                                        0);
00513 
00514   // Make the reply message
00515   if (this->mesg_base_->generate_reply_header (*this->outgoing_,
00516                                                reply_params) == -1)
00517     {
00518       ACE_ERROR ((LM_ERROR,
00519                   ACE_TEXT ("TAO (%P|%t) - ServerRequest::send_cached_reply, ")
00520                   ACE_TEXT ("could not make cached reply\n")));
00521 
00522     }
00523 
00524   /// Append reply here....
00525   this->outgoing_->write_octet_array (
00526     s.get_buffer (),
00527     s.length ());
00528 
00529   if (!this->outgoing_->good_bit ())
00530     ACE_ERROR ((LM_ERROR,
00531                 ACE_TEXT ("TAO (%P|%t) - ServerRequest::send_cached_reply, ")
00532                 ACE_TEXT ("could not marshal reply\n")));
00533 
00534   this->outgoing_->more_fragments (false);
00535 
00536   // Send the message
00537   if (this->transport_->send_message (*this->outgoing_,
00538                                       0,
00539                                       TAO_Transport::TAO_REPLY) == -1)
00540     {
00541       ACE_ERROR ((LM_ERROR,
00542                   ACE_TEXT ("TAO (%P|%t) - ServerRequest::send_cached_reply, ")
00543                   ACE_TEXT ("could not send cached reply\n")));
00544     }
00545 }

void TAO_ServerRequest::send_no_exception_reply ( void   ) 

Used with reliable oneway requests.

Definition at line 297 of file TAO_Server_Request.cpp.

References ACE_ERROR, ACE_TEXT, TAO_Pluggable_Reply_Params_Base::argument_flag_, dsi_nvlist_align_, TAO_Pluggable_Reply_Params_Base::dsi_nvlist_align_, TAO_GIOP_Message_Base::generate_reply_header(), is_dsi_, TAO_Pluggable_Reply_Params_Base::is_dsi_, LM_ERROR, mesg_base_, TAO_OutputCDR::message_attributes(), TAO_OutputCDR::more_fragments(), CORBA::NO_EXCEPTION, outgoing_, TAO_Pluggable_Reply_Params_Base::reply_status(), request_id_, TAO_Pluggable_Reply_Params_Base::request_id_, TAO_Pluggable_Reply_Params_Base::service_context_notowned(), TAO_Pluggable_Reply_Params_Base::svc_ctx_, TAO_debug_level, TAO_Transport::TAO_REPLY, and transport_.

00298 {
00299   // Construct our reply generator.
00300   TAO_Pluggable_Reply_Params_Base reply_params;
00301   reply_params.request_id_ = this->request_id_;
00302   reply_params.is_dsi_ = this->is_dsi_;
00303   reply_params.dsi_nvlist_align_ = this->dsi_nvlist_align_;
00304 
00305   // Change this to pass back the same thing we received, as well as
00306   // leave a comment why this is important!
00307   reply_params.svc_ctx_.length (0);
00308 
00309   // Send back the reply service context.
00310   reply_params.service_context_notowned (&this->reply_service_info ());
00311 
00312   reply_params.reply_status (GIOP::NO_EXCEPTION);
00313 
00314   // No data anyway.
00315   reply_params.argument_flag_ = false;
00316 
00317   this->outgoing_->message_attributes (this->request_id_,
00318                                        0,
00319                                        TAO_Transport::TAO_REPLY,
00320                                        0);
00321 
00322   // Construct a REPLY header.
00323   this->mesg_base_->generate_reply_header (*this->outgoing_, reply_params);
00324 
00325   this->outgoing_->more_fragments (false);
00326 
00327   // Send the message.
00328   int result = this->transport_->send_message (*this->outgoing_,
00329                                                0,
00330                                                TAO_Transport::TAO_REPLY);
00331 
00332   if (result == -1)
00333     {
00334       if (TAO_debug_level > 0)
00335         {
00336           // No exception but some kind of error, yet a response
00337           // is required.
00338           ACE_ERROR ((
00339                       LM_ERROR,
00340                       ACE_TEXT ("TAO (%P|%t) - ServerRequest::send_no_exception_reply, ")
00341                       ACE_TEXT ("cannot send NO_EXCEPTION reply\n")
00342                       ));
00343         }
00344     }
00345 }

ACE_INLINE void TAO_ServerRequest::sync_with_server ( CORBA::Boolean  sync_flag  ) 

Set the sync_with_server flag.

Definition at line 108 of file TAO_Server_Request.inl.

References sync_with_server_.

00109 {
00110   this->sync_with_server_ = sync_flag;
00111 }

ACE_INLINE CORBA::Boolean TAO_ServerRequest::sync_with_server ( void   )  const

Should we return before dispatching the servant?

Definition at line 102 of file TAO_Server_Request.inl.

References sync_with_server_.

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header(), and TAO_GIOP_Message_Generator_Parser_10::parse_request_header().

00103 {
00104   return this->sync_with_server_;
00105 }

void TAO_ServerRequest::tao_send_reply ( void   ) 

Definition at line 348 of file TAO_Server_Request.cpp.

References ACE_ERROR, ACE_TEXT, LM_ERROR, TAO_OutputCDR::more_fragments(), outgoing_, TAO_debug_level, TAO_Transport::TAO_REPLY, and transport_.

00349 {
00350   if (this->collocated ())
00351     return;  // No transport in the collocated case.
00352 
00353   this->outgoing_->more_fragments (false);
00354 
00355   int result = this->transport_->send_message (*this->outgoing_,
00356                                                0,
00357                                                TAO_Transport::TAO_REPLY);
00358   if (result == -1)
00359     {
00360       if (TAO_debug_level > 0)
00361         {
00362           // No exception but some kind of error, yet a response
00363           // is required.
00364           ACE_ERROR ((LM_ERROR,
00365                       ACE_TEXT ("TAO (%P|%t) - ServerRequest::tao_send_reply, ")
00366                       ACE_TEXT ("cannot send reply\n")));
00367         }
00368     }
00369 }

void TAO_ServerRequest::tao_send_reply_exception ( const CORBA::Exception &  ex  ) 

Definition at line 372 of file TAO_Server_Request.cpp.

References CORBA::SystemException::_downcast(), ACE_ERROR, ACE_TEXT, TAO_ORB_Parameters::cdr_memcpy_tradeoff(), ACE_CDR::DEFAULT_BUFSIZE, TAO_GIOP_Message_Base::fragmentation_strategy(), TAO_OutputCDR::get_version(), LM_ERROR, TAO_GIOP_Message_Version::major, mesg_base_, TAO_GIOP_Message_Version::minor, TAO_OutputCDR::more_fragments(), orb_core_, TAO_ORB_Core::orb_params(), outgoing_, TAO_ORB_Core::output_cdr_dblock_allocator(), TAO_ORB_Core::output_cdr_msgblock_allocator(), request_id_, CORBA::SYSTEM_EXCEPTION, TAO_debug_level, TAO_ENCAP_BYTE_ORDER, TAO_Transport::TAO_REPLY, transport_, and CORBA::USER_EXCEPTION.

00373 {
00374   if (this->response_expected_ && !this->collocated ())
00375     {
00376       // A copy of the reply parameters
00377       TAO_Pluggable_Reply_Params_Base reply_params;
00378 
00379       reply_params.request_id_ = this->request_id_;
00380       reply_params.svc_ctx_.length (0);
00381 
00382       // Send back the reply service context.
00383       reply_params.service_context_notowned (&this->reply_service_info ());
00384 
00385       // We are going to send some data
00386       reply_params.argument_flag_ = true;
00387 
00388       // Make a default reply status
00389 
00390       // Check whether we are able to downcast the exception
00391       if (CORBA::SystemException::_downcast (&ex) != 0)
00392         {
00393           reply_params.reply_status (GIOP::SYSTEM_EXCEPTION);
00394         }
00395       else
00396         {
00397           reply_params.reply_status (GIOP::USER_EXCEPTION);
00398         }
00399 
00400       // Create a new output CDR stream
00401 #if defined(ACE_INITIALIZE_MEMORY_BEFORE_USE)
00402       // Only inititialize the buffer if we're compiling with a profiler.
00403       // Otherwise, there is no real need to do so, especially since
00404       // we can avoid the initialization overhead at runtime if we
00405       // are not compiling with memory profiler support.
00406       char repbuf[ACE_CDR::DEFAULT_BUFSIZE] = { 0 };
00407 #else
00408       char repbuf[ACE_CDR::DEFAULT_BUFSIZE];
00409 #endif /* ACE_INITIALIZE_MEMORY_BEFORE_USE */
00410       TAO_GIOP_Message_Version gv;
00411       if (this->outgoing_)
00412         this->outgoing_->get_version (gv);
00413 
00414       TAO_OutputCDR output (repbuf,
00415                             sizeof repbuf,
00416                             TAO_ENCAP_BYTE_ORDER,
00417                             this->orb_core_->output_cdr_buffer_allocator (),
00418                             this->orb_core_->output_cdr_dblock_allocator (),
00419                             this->orb_core_->output_cdr_msgblock_allocator (),
00420                             this->orb_core_->orb_params ()->cdr_memcpy_tradeoff (),
00421                             this->mesg_base_->fragmentation_strategy (),
00422                             gv.major,
00423                             gv.minor);
00424 
00425       this->transport_->assign_translators (0, &output);
00426       // Make the reply message
00427       if (this->mesg_base_->generate_exception_reply (*this->outgoing_,
00428                                                       reply_params,
00429                                                       ex) == -1)
00430         {
00431           ACE_ERROR ((LM_ERROR,
00432                       ACE_TEXT ("TAO (%P|%t) - ServerRequest::tao_send_reply_exception, ")
00433                       ACE_TEXT ("could not make exception reply\n")));
00434 
00435         }
00436 
00437       this->outgoing_->more_fragments (false);
00438 
00439       // Send the message
00440       if (this->transport_->send_message (*this->outgoing_,
00441                                           0,
00442                                           TAO_Transport::TAO_REPLY) == -1)
00443         {
00444           ACE_ERROR ((LM_ERROR,
00445                       ACE_TEXT ("TAO (%P|%t) - ServerRequest::tao_send_reply_exception, ")
00446                       ACE_TEXT ("could not send exception reply\n")));
00447         }
00448     }
00449   else if (TAO_debug_level > 0)
00450     {
00451       // It is unfortunate that an exception (probably a system
00452       // exception) was thrown by the upcall code (even by the
00453       // user) when the client was not expecting a response.
00454       // However, in this case, we cannot close the connection
00455       // down, since it really isn't the client's fault.
00456 
00457       ACE_ERROR ((LM_ERROR,
00458                   ACE_TEXT ("TAO (%P|%t) - ServerRequest::tao_send_reply_exception, ")
00459                   ACE_TEXT ("exception thrown ")
00460                   ACE_TEXT ("but client is not waiting a response\n")));
00461     }
00462 }

ACE_INLINE TAO_Transport * TAO_ServerRequest::transport (  ) 

Return the underlying transport.

Definition at line 138 of file TAO_Server_Request.inl.

References transport_.

00139 {
00140   return this->transport_.get ();
00141 }

Friends And Related Function Documentation

friend class TAO::CSD::FW_Server_Request_Wrapper [friend]

Declare FW_Server_Request_Wrapper a friend This friendship makes the FW_Server_Request_Wrapper be able to clone the TAO_ServerRequest.

Definition at line 89 of file TAO_Server_Request.h.

friend class TAO_AMH_Response_Handler [friend]

Declare TAO_AMH_Response_Handler a friend.

The TAO_AMH_Response_Handler class needs to copy part of the state in a TAO_ServerRequest, however, we do not want to expose that state as public members of this class, neither do we want to add modifiers to the TAO_AMH_Response_Handler class that would allow us (the TAO_ServerRequest class) to set the state.

Lucky for us, C++ is a language for adult developers, and allow us to use the evil "friend" declaration.

Definition at line 103 of file TAO_Server_Request.h.

Member Data Documentation

CORBA::Boolean TAO_ServerRequest::argument_flag_ [private]

An argument flag to indicate whether there is any data that is going to get marshaled along as a reply. The default will be 1 which indicates that we have some data that needs to be sent back to the client.

Definition at line 354 of file TAO_Server_Request.h.

Referenced by argument_flag(), and init_reply().

CORBA::Exception* TAO_ServerRequest::caught_exception_ [private]

Pointer to the caught exception.

Definition at line 366 of file TAO_Server_Request.h.

Referenced by caught_exception().

CORBA::Boolean TAO_ServerRequest::deferred_reply_ [private]

false: Reply would be sent by the object of this class which is the default. true: Reply would not be prepared by this class and it would be deferred for somebody.

Definition at line 314 of file TAO_Server_Request.h.

Referenced by deferred_reply().

ptrdiff_t TAO_ServerRequest::dsi_nvlist_align_ [private]

Used to pad CDR stream if we have used DSI.

Definition at line 344 of file TAO_Server_Request.h.

Referenced by dsi_nvlist_align(), init_reply(), and send_no_exception_reply().

CORBA::Object_var TAO_ServerRequest::forward_location_ [private]

Definition at line 295 of file TAO_Server_Request.h.

Referenced by forward_location().

TAO_InputCDR* TAO_ServerRequest::incoming_ [private]

Incoming stream.

Definition at line 300 of file TAO_Server_Request.h.

Referenced by incoming().

size_t TAO_ServerRequest::interceptor_count_ [private]

The number of interceptors pushed on to the current interceptor flow stack.

Definition at line 359 of file TAO_Server_Request.h.

Referenced by interceptor_count().

CORBA::Boolean TAO_ServerRequest::is_dsi_ [private]

Did we get passed to a CORBA::ServerRequest?

Definition at line 321 of file TAO_Server_Request.h.

Referenced by init_reply(), is_dsi(), and send_no_exception_reply().

bool TAO_ServerRequest::is_forwarded_ [private]

Definition at line 297 of file TAO_Server_Request.h.

Referenced by forward_location(), and is_forwarded().

TAO_GIOP_Message_Base* TAO_ServerRequest::mesg_base_ [private]

Definition at line 284 of file TAO_Server_Request.h.

Referenced by init_reply(), send_cached_reply(), send_no_exception_reply(), and tao_send_reply_exception().

const char* TAO_ServerRequest::operation_ [private]

Operation name.

Definition at line 287 of file TAO_Server_Request.h.

Referenced by operation().

TAO_Operation_Details const* TAO_ServerRequest::operation_details_ [private]

Definition at line 346 of file TAO_Server_Request.h.

Referenced by operation_details(), and reply_service_context().

size_t TAO_ServerRequest::operation_len_ [private]

Operation length.

Definition at line 290 of file TAO_Server_Request.h.

Referenced by operation(), and operation_length().

TAO_ORB_Core* TAO_ServerRequest::orb_core_ [private]

A pointer to the ORB Core for the context where the request was created.

Definition at line 328 of file TAO_Server_Request.h.

Referenced by init_reply(), orb(), orb_core(), rs_pi_current(), send_cached_reply(), tao_send_reply_exception(), and ~TAO_ServerRequest().

TAO_OutputCDR* TAO_ServerRequest::outgoing_ [private]

Outgoing stream.

Definition at line 302 of file TAO_Server_Request.h.

Referenced by init_reply(), outgoing(), send_cached_reply(), send_no_exception_reply(), tao_send_reply(), and tao_send_reply_exception().

PortableInterceptor::ReplyStatus TAO_ServerRequest::pi_reply_status_ [private]

Reply status for the current request.

Definition at line 369 of file TAO_Server_Request.h.

Referenced by caught_exception(), and pi_reply_status().

TAO_Tagged_Profile TAO_ServerRequest::profile_ [private]

The tagged profile that has the addressing information.

Definition at line 338 of file TAO_Server_Request.h.

Referenced by object_key(), profile(), and TAO_ServerRequest().

bool TAO_ServerRequest::release_operation_ [private]

Do we own the memory associated with operation_?

Definition at line 293 of file TAO_Server_Request.h.

Referenced by operation().

TAO_Service_Context TAO_ServerRequest::reply_service_context_ [private]

Definition at line 332 of file TAO_Server_Request.h.

Referenced by reply_service_context().

GIOP::ReplyStatusType TAO_ServerRequest::reply_status_ [private]

Reply status (will be NO_EXCEPTION in the majority of the cases).

Definition at line 324 of file TAO_Server_Request.h.

Referenced by reply_status().

CORBA::ULong TAO_ServerRequest::request_id_ [private]

Unique identifier for a request.

Definition at line 335 of file TAO_Server_Request.h.

Referenced by init_reply(), request_id(), send_cached_reply(), send_no_exception_reply(), and tao_send_reply_exception().

TAO_Service_Context TAO_ServerRequest::request_service_context_ [private]

Service Context info.

Definition at line 331 of file TAO_Server_Request.h.

Referenced by request_service_context(), and TAO_ServerRequest().

CORBA::OctetSeq_var TAO_ServerRequest::requesting_principal_ [private]

Identifies the requester.

Definition at line 341 of file TAO_Server_Request.h.

Referenced by requesting_principal().

CORBA::Boolean TAO_ServerRequest::response_expected_ [private]

false: oneway (SYNC_NONE or SYNC_WITH_TRANSPORT) true: twoway, or oneway (SYNC_WITH_SERVER or SYNC_WITH_TARGET)

Definition at line 306 of file TAO_Server_Request.h.

Referenced by response_expected().

TAO::PICurrent_Impl* TAO_ServerRequest::rs_pi_current_ [private]

The "Request Scope Current" (RSC) object, as required by Portable Interceptors.

Definition at line 363 of file TAO_Server_Request.h.

Referenced by rs_pi_current().

CORBA::Boolean TAO_ServerRequest::sync_with_server_ [private]

true: oneway (SYNC_WITH_SERVER) false: anything else

Definition at line 318 of file TAO_Server_Request.h.

Referenced by sync_with_server().

TAO::Transport_Selection_Guard TAO_ServerRequest::transport_ [private]

Transport class. An RAII (resource acquisition is initialization) class instance for interfacing with TSS storage for the "current" transport.

Definition at line 375 of file TAO_Server_Request.h.

Referenced by collocated(), init_reply(), send_cached_reply(), send_no_exception_reply(), tao_send_reply(), tao_send_reply_exception(), and transport().

The documentation for this class was generated from the following files:
Generated on Tue Feb 2 17:39:45 2010 for TAO by  doxygen 1.4.7