Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

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_Pluggable_Messaging *mesg_base, TAO_InputCDR &input, TAO_OutputCDR &output, TAO_Transport *transport, TAO_ORB_Core *orb_core)
 TAO_ServerRequest (TAO_Pluggable_Messaging *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.

CORBA::ULong exception_type (void)
 Get the exception type.

void exception_type (CORBA::ULong except_type)
 Set the exception type.

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 reply_status (PortableInterceptor::ReplyStatus s)
 Set the status of the received reply.

PortableInterceptor::ReplyStatus 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_Pluggable_Messaging * 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_
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?

CORBA::ULong exception_type_
 Exception type (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 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 81 of file TAO_Server_Request.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_ServerRequest::TAO_ServerRequest (  TAO_Pluggable_Messaging *  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, and TAO_GIOP_NO_EXCEPTION. 

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

TAO_ServerRequest::TAO_ServerRequest (  TAO_Pluggable_Messaging *  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 88 of file TAO_Server_Request.cpp.

References TAO_Tagged_Profile::object_key(), and TAO_GIOP_NO_EXCEPTION. 

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

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 129 of file TAO_Server_Request.cpp.

References CORBA::Object::_stubobj(), TAO_Stub::object_key(), TAO_Tagged_Profile::object_key(), CORBA::Object_ptr, request_service_context_, TAO_Service_Context::service_info(), IOP::ServiceContextList, TAO_GIOP_NO_EXCEPTION, and TAO_TWOWAY_RESPONSE_FLAG. 

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

TAO_ServerRequest::~TAO_ServerRequest (  void   ) 
 

Destructor.

Definition at line 182 of file TAO_Server_Request.cpp.

References TAO::ServerRequestInterceptor_Adapter::deallocate_pi_current(), release_operation_, rs_pi_current_, TAO_ORB_Core::serverrequestinterceptor_adapter(), and CORBA::string_free(). 

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

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.

References TAO_GIOP_NO_EXCEPTION. 

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     exception_type_ (TAO_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   , 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 211 of file TAO_Server_Request.inl. 

00212 {
00213   return this->argument_flag_;
00214 }

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

Set the argument_flag.

Definition at line 217 of file TAO_Server_Request.inl. 

00218 {
00219   this->argument_flag_ = flag;
00220 }

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

Definition at line 547 of file TAO_Server_Request.cpp.

References CORBA::UserException::_downcast(), and CORBA::SystemException::_downcast(). 

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

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

Definition at line 237 of file TAO_Server_Request.inl. 

00238 {
00239   return this->caught_exception_;
00240 }

ACE_INLINE bool TAO_ServerRequest::collocated (  void   )  const
 

Returns true if the current request is collocated.

Definition at line 223 of file TAO_Server_Request.inl.

References TAO::Transport_Selection_Guard::get().

Referenced by tao_send_reply(), and tao_send_reply_exception(). 

00224 {
00225   return this->transport_.get () == 0;
00226 }

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 205 of file TAO_Server_Request.inl. 

00206 {
00207   this->dsi_nvlist_align_ = alignment;
00208 }

ACE_INLINE void TAO_ServerRequest::exception_type (  CORBA::ULong  except_type  ) 
 

Set the exception type.

Definition at line 187 of file TAO_Server_Request.inl.

References exception_type_. 

00188 {
00189   this->exception_type_ = except_type;
00190 }

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

Get the exception type.

Definition at line 181 of file TAO_Server_Request.inl.

References exception_type_.

Referenced by TAO_GIOP_Message_Base::process_locate_request(). 

00182 {
00183   return this->exception_type_;
00184 }

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

Get the forward_location.

Definition at line 175 of file TAO_Server_Request.inl.

References CORBA::Object::_duplicate(). 

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

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 CORBA::Object_ptr.

Referenced by TAO_GIOP_Message_Base::process_locate_request(). 

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

ACE_INLINE TAO_InputCDR * TAO_ServerRequest::incoming (  void   )  const
 

Retrieve the incoming stream.

Definition at line 47 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(). 

00048 {
00049   return this->incoming_;
00050 }

void TAO_ServerRequest::init_reply (  void   ) 
 

Start a Reply message.

Definition at line 223 of file TAO_Server_Request.cpp.

References ACE_DEBUG, ACE_TEXT, TAO_Pluggable_Reply_Params_Base::argument_flag_, TAO_Pluggable_Reply_Params_Base::dsi_nvlist_align_, exception_type_, forward_location_, TAO_Pluggable_Messaging::generate_reply_header(), TAO_Pseudo_Var_T< T >::in(), TAO_Pluggable_Reply_Params_Base::is_dsi_, CORBA::is_nil(), TAO_ORB_Core::is_permanent_forward_condition(), LM_DEBUG, mesg_base_, TAO_OutputCDR::message_attributes(), CORBA::Object_ptr, outgoing_, TAO_Pluggable_Reply_Params_Base::reply_status_, TAO_Pluggable_Reply_Params_Base::request_id_, request_service_context(), TAO_Pluggable_Reply_Params_Base::service_context_notowned(), TAO_GIOP_NO_EXCEPTION, TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD, TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD_PERM, and TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION. 

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

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 231 of file TAO_Server_Request.inl.

References interceptor_count_. 

00232 {
00233   return this->interceptor_count_;
00234 }

ACE_INLINE void TAO_ServerRequest::is_dsi (  void   ) 
 

Set the boolean member to 1.

Definition at line 193 of file TAO_Server_Request.inl. 

00194 {
00195   this->is_dsi_ = true;
00196 }

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().

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_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 199 of file TAO_Server_Request.inl.

References operation_details_. 

00200 {
00201   return this->operation_details_;
00202 }

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 202 of file TAO_Server_Request.cpp.

References TAO_ORB_Core::orb(). 

00203 {
00204   return this->orb_core_->orb ();
00205 }

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.

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 TAO_Tagged_Profile & TAO_ServerRequest::profile (  void   ) 
 

Return the reference to the tagged profile.

Definition at line 162 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(). 

00163 {
00164   return this->profile_;
00165 }

TAO_Service_Context & TAO_ServerRequest::reply_service_context (  void   ) 
 

Return the reply TAO_Service_Context.

Definition at line 208 of file TAO_Server_Request.cpp.

References operation_details_, and reply_service_context_.

Referenced by reply_service_info(). 

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

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 PortableInterceptor::ReplyStatus TAO_ServerRequest::reply_status (  void   ) 
 

Get the status of the received reply.

Definition at line 249 of file TAO_Server_Request.inl. 

00250 {
00251   return this->reply_status_;
00252 }

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

Set the status of the received reply.

Definition at line 243 of file TAO_Server_Request.inl.

References PortableInterceptor::ReplyStatus. 

00244 {
00245   this->reply_status_ = s;
00246 }

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. 

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.

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 TAO_GIOP_Message_Generator_Parser_12::check_bidirectional_context(), init_reply(), TAO_GIOP_Message_Base::process_request(), 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 CORBA::OctetSeq, and 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. 

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.

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 558 of file TAO_Server_Request.cpp.

References TAO::ServerRequestInterceptor_Adapter::allocate_pi_current(), rs_pi_current_, and TAO_ORB_Core::serverrequestinterceptor_adapter(). 

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

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

Definition at line 465 of file TAO_Server_Request.cpp.

References ACE_ERROR, ACE_TEXT, TAO_Pluggable_Reply_Params_Base::argument_flag_, TAO_ORB_Parameters::cdr_memcpy_tradeoff(), TAO_Pluggable_Messaging::fragmentation_strategy(), TAO_Pluggable_Messaging::generate_reply_header(), TAO_OutputCDR::get_version(), ACE_OutputCDR::good_bit(), LM_ERROR, TAO_GIOP_Message_Version::major, mesg_base_, TAO_OutputCDR::message_attributes(), TAO_GIOP_Message_Version::minor, TAO_OutputCDR::more_fragments(), CORBA::OctetSeq, 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_, 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_GIOP_NO_EXCEPTION, and ACE_OutputCDR::write_octet_array(). 

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

void TAO_ServerRequest::send_no_exception_reply (  void   ) 
 

Used with reliable oneway requests.

Definition at line 299 of file TAO_Server_Request.cpp.

References ACE_ERROR, ACE_TEXT, TAO_Pluggable_Reply_Params_Base::argument_flag_, TAO_Pluggable_Reply_Params_Base::dsi_nvlist_align_, TAO_Pluggable_Messaging::generate_reply_header(), TAO_Pluggable_Reply_Params_Base::is_dsi_, LM_ERROR, mesg_base_, TAO_OutputCDR::message_attributes(), TAO_OutputCDR::more_fragments(), outgoing_, TAO_Pluggable_Reply_Params_Base::reply_status_, 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, and TAO_GIOP_NO_EXCEPTION. 

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

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 350 of file TAO_Server_Request.cpp.

References ACE_ERROR, ACE_TEXT, collocated(), LM_ERROR, TAO_OutputCDR::more_fragments(), outgoing_, and TAO_debug_level. 

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

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

Definition at line 374 of file TAO_Server_Request.cpp.

References CORBA::SystemException::_downcast(), ACE_ERROR, ACE_TEXT, TAO_Pluggable_Reply_Params_Base::argument_flag_, TAO_ORB_Parameters::cdr_memcpy_tradeoff(), collocated(), TAO_Pluggable_Messaging::fragmentation_strategy(), TAO_Pluggable_Messaging::generate_exception_reply(), TAO_OutputCDR::get_version(), LM_ERROR, TAO_GIOP_Message_Version::major, mesg_base_, TAO_GIOP_Message_Version::minor, TAO_OutputCDR::more_fragments(), 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_, 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_ENCAP_BYTE_ORDER, TAO_GIOP_SYSTEM_EXCEPTION, and TAO_GIOP_USER_EXCEPTION. 

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

ACE_INLINE TAO_Transport * TAO_ServerRequest::transport (   ) 
 

Return the underlying transport.

Definition at line 138 of file TAO_Server_Request.inl.

References TAO::Transport_Selection_Guard::get().

Referenced by TAO_GIOP_Message_Generator_Parser_12::check_bidirectional_context(). 

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 88 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 102 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 347 of file TAO_Server_Request.h.

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

Pointer to the caught exception.

Definition at line 359 of file TAO_Server_Request.h.

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 307 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 337 of file TAO_Server_Request.h.

CORBA::ULong TAO_ServerRequest::exception_type_ [private]
 

Exception type (will be NO_EXCEPTION in the majority of the cases).

Definition at line 317 of file TAO_Server_Request.h.

Referenced by exception_type(), and init_reply().

CORBA::Object_var TAO_ServerRequest::forward_location_ [private]
 

Definition at line 290 of file TAO_Server_Request.h.

Referenced by forward_location(), and init_reply().

TAO_InputCDR* TAO_ServerRequest::incoming_ [private]
 

Incoming stream.

Definition at line 293 of file TAO_Server_Request.h.

size_t TAO_ServerRequest::interceptor_count_ [private]
 

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

Definition at line 352 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 314 of file TAO_Server_Request.h.

TAO_Pluggable_Messaging* TAO_ServerRequest::mesg_base_ [private]
 

Definition at line 279 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 282 of file TAO_Server_Request.h.

TAO_Operation_Details const* TAO_ServerRequest::operation_details_ [private]
 

Definition at line 339 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 285 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 321 of file TAO_Server_Request.h.

TAO_OutputCDR* TAO_ServerRequest::outgoing_ [private]
 

Outgoing stream.

Definition at line 295 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().

TAO_Tagged_Profile TAO_ServerRequest::profile_ [private]
 

The tagged profile that has the addressing information.

Definition at line 331 of file TAO_Server_Request.h.

bool TAO_ServerRequest::release_operation_ [private]
 

Do we own the memory associated with operation_?

Definition at line 288 of file TAO_Server_Request.h.

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

TAO_Service_Context TAO_ServerRequest::reply_service_context_ [private]
 

Definition at line 325 of file TAO_Server_Request.h.

Referenced by reply_service_context().

PortableInterceptor::ReplyStatus TAO_ServerRequest::reply_status_ [private]
 

Reply status for the current request.

Definition at line 362 of file TAO_Server_Request.h.

CORBA::ULong TAO_ServerRequest::request_id_ [private]
 

Unique identifier for a request.

Definition at line 328 of file TAO_Server_Request.h.

TAO_Service_Context TAO_ServerRequest::request_service_context_ [private]
 

Service Context info.

Definition at line 324 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 334 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 299 of file TAO_Server_Request.h.

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

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

Definition at line 356 of file TAO_Server_Request.h.

Referenced by rs_pi_current(), and ~TAO_ServerRequest().

CORBA::Boolean TAO_ServerRequest::sync_with_server_ [private]
 

true: oneway (SYNC_WITH_SERVER) false: anything else

Definition at line 311 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 368 of file TAO_Server_Request.h.

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 13:16:17 2008 for TAO by doxygen 1.3.6