void POA_Load_Balancer::Object_Group_Factory::make_random_skel (
TAO_ServerRequest & server_request,
TAO::Portable_Server::Servant_Upcall *TAO_INTERCEPTOR (servant_upcall),
TAO_ServantBase *servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::Load_Balancer::Object_Group>::ret_val retval;
TAO::SArg_Traits< char *>::in_arg_val _tao_id;
TAO::Argument * const args[] =
{
&retval,
&_tao_id
};
static size_t const nargs = 2;
POA_Load_Balancer::Object_Group_Factory * const impl =
dynamic_cast<POA_Load_Balancer::Object_Group_Factory *> (servant);
if (!impl)
{
throw ::CORBA::INTERNAL ();
}
make_random_Object_Group_Factory command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_Receiver::receive_payload_skel (
TAO_ServerRequest & server_request,
TAO::Portable_Server::Servant_Upcall *TAO_INTERCEPTOR (servant_upcall),
TAO_ServantBase *servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< void>::ret_val retval;
TAO::SArg_Traits< ::Receiver::Payload>::in_arg_val _tao_pay;
TAO::Argument * const args[] =
{
&retval,
&_tao_pay
};
static size_t const nargs = 2;
POA_Receiver * const impl =
dynamic_cast<POA_Receiver *> (servant);
if (!impl)
{
throw ::CORBA::INTERNAL ();
}
receive_payload_Receiver command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_Messenger::call_message_skel (
TAO_ServerRequest & server_request,
TAO::Portable_Server::Servant_Upcall *TAO_INTERCEPTOR (servant_upcall),
TAO_ServantBase *servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::ACE_InputCDR::to_boolean>::ret_val retval;
TAO::SArg_Traits< char *>::in_arg_val _tao_user_name;
TAO::Argument * const args[] =
{
&retval,
&_tao_user_name
};
static size_t const nargs = 2;
POA_Messenger * const impl =
dynamic_cast<POA_Messenger *> (servant);
if (!impl)
{
throw ::CORBA::INTERNAL ();
}
call_message_Messenger command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_Test::Session_Factory::create_new_session_skel (
TAO_ServerRequest & server_request,
TAO::Portable_Server::Servant_Upcall *TAO_INTERCEPTOR (servant_upcall),
TAO_ServantBase *servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::Test::Session>::ret_val retval;
TAO::SArg_Traits< ::Test::Callback>::in_arg_val _tao_the_callback;
TAO::Argument * const args[] =
{
&retval,
&_tao_the_callback
};
static size_t const nargs = 2;
POA_Test::Session_Factory * const impl =
dynamic_cast<POA_Test::Session_Factory *> (servant);
if (!impl)
{
throw ::CORBA::INTERNAL ();
}
create_new_session_Session_Factory command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_ChatRoom::sendLocation_skel (
TAO_ServerRequest & server_request,
void * TAO_INTERCEPTOR (servant_upcall),
void * servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< void>::ret_val retval;
TAO::SArg_Traits< ::CORBA::Long>::in_arg_val _tao_x;
TAO::SArg_Traits< ::CORBA::Long>::in_arg_val _tao_y;
TAO::SArg_Traits< ::CORBA::Char *>::in_arg_val _tao_fromNickname;
TAO::Argument * const args[] =
{
&retval,
&_tao_x,
&_tao_y,
&_tao_fromNickname
};
static size_t const nargs = 4;
POA_ChatRoom * const impl =
static_cast<POA_ChatRoom *> (servant);
sendLocation_ChatRoom command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_Test::Hello::get_stringList_skel (
TAO_ServerRequest & server_request,
TAO::Portable_Server::Servant_Upcall *TAO_INTERCEPTOR (servant_upcall),
TAO_ServantBase *servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::Test::StringList>::ret_val retval;
TAO::Argument * const args[] =
{
&retval
};
static size_t const nargs = 1;
POA_Test::Hello * const impl =
dynamic_cast<POA_Test::Hello *> (servant);
if (!impl)
{
throw ::CORBA::INTERNAL ();
}
get_stringList_Hello command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_Test::Crashed_Callback::are_you_there_skel (
TAO_ServerRequest & server_request,
TAO::Portable_Server::Servant_Upcall *TAO_INTERCEPTOR (servant_upcall),
TAO_ServantBase *servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::ACE_InputCDR::to_boolean>::ret_val retval;
TAO::Argument * const args[] =
{
&retval
};
static size_t const nargs = 1;
POA_Test::Crashed_Callback * const impl =
dynamic_cast<POA_Test::Crashed_Callback *> (servant);
if (!impl)
{
throw ::CORBA::INTERNAL ();
}
are_you_there_Crashed_Callback command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_Skeleton_Inheritance::Interface_2::_get_attribute_2_skel (
TAO_ServerRequest & server_request,
TAO::Portable_Server::Servant_Upcall *TAO_INTERCEPTOR (servant_upcall),
TAO_ServantBase *servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< char *>::ret_val retval;
TAO::Argument * const args[] =
{
&retval
};
static size_t const nargs = 1;
POA_Skeleton_Inheritance::Interface_2 * const impl =
dynamic_cast<POA_Skeleton_Inheritance::Interface_2 *> (servant);
if (!impl)
{
throw ::CORBA::INTERNAL ();
}
_get_attribute_2_Interface_2 command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_ExampleInterfaces::IAdder::add_skel (
TAO_ServerRequest & server_request,
void * TAO_INTERCEPTOR (servant_upcall),
void * servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::CORBA::Double>::ret_val retval;
TAO::SArg_Traits< ::CORBA::Double>::in_arg_val _tao_arg1;
TAO::SArg_Traits< ::CORBA::Double>::in_arg_val _tao_arg2;
TAO::Argument * const args[] =
{
&retval,
&_tao_arg1,
&_tao_arg2
};
static size_t const nargs = 3;
POA_ExampleInterfaces::IAdder * const impl =
static_cast<POA_ExampleInterfaces::IAdder *> (servant);
add_IAdder command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_Echo::_is_a_skel (
TAO_ServerRequest & server_request,
void * TAO_INTERCEPTOR (servant_upcall),
void * servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::ACE_InputCDR::to_boolean>::ret_val retval;
TAO::SArg_Traits< ::CORBA::Char *>::in_arg_val _tao_repository_id;
TAO::Argument * const args[] =
{
&retval,
&_tao_repository_id
};
static size_t const nargs = 2;
POA_Echo * const impl =
static_cast<POA_Echo *> (servant);
_is_a_Echo_Upcall_Command command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_Echo::_component_skel (
TAO_ServerRequest & server_request,
void * TAO_INTERCEPTOR (servant_upcall),
void * servant
)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::CORBA::Object>::ret_val retval;
TAO::Argument * const args[] =
{
&retval
};
static size_t const nargs = 1;
POA_Echo * const impl =
static_cast<POA_Echo *> (servant);
_get_component_Echo_Upcall_Command command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void POA_ExampleInterfaces::IAdder::_non_existent_skel (
TAO_ServerRequest & server_request,
void * TAO_INTERCEPTOR (servant_upcall),
void * servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::ACE_InputCDR::to_boolean>::ret_val retval;
TAO::Argument * const args[] =
{
&retval
};
static size_t const nargs = 1;
POA_ExampleInterfaces::IAdder * const impl =
static_cast<POA_ExampleInterfaces::IAdder *> (servant);
_non_existent_IAdder_Upcall_Command command (
impl,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
void
ImR_DSI_Forwarder::_dispatch (TAO_ServerRequest &request,
TAO::Portable_Server::Servant_Upcall * /*context */ )
{
// No need to do any of this if the client isn't waiting.
if (request.response_expected ())
{
if (!CORBA::is_nil (request.forward_location ()))
{
request.init_reply ();
request.tao_send_reply ();
// No need to invoke in this case.
return;
}
}
// Create DSI request object.
CORBA::ServerRequest *dsi_request = 0;
ACE_NEW (dsi_request,
CORBA::ServerRequest (request));
try
{
TAO_AMH_DSI_Response_Handler_ptr rhp;
ACE_NEW (rhp, TAO_AMH_DSI_Response_Handler(request));
TAO_AMH_DSI_Response_Handler_var rh(rhp);
rh->init (request, 0);
// Delegate to user.
this->invoke (dsi_request, rh.in());
}
catch (const CORBA::Exception& ex)
{
// Only if the client is waiting.
if (request.response_expected () && !request.sync_with_server ())
{
request.tao_send_reply_exception (ex);
}
}
CORBA::release (dsi_request);
}
int
TAO_Async_Table_Adapter::dispatch (TAO::ObjectKey &key,
TAO_ServerRequest &request,
CORBA::Object_out forward_to)
{
TAO_IOR_Table_Impl_var rootref;
{
ACE_GUARD_RETURN (ACE_Lock,
ace_mon,
*this->lock_,
TAO_Adapter::DS_MISMATCHED_KEY);
if (this->closed_)
{
return TAO_Adapter::DS_MISMATCHED_KEY;
}
rootref = this->root_;
}
if (this->root_->async_available ())
{
// construct a callback handler
TAO_AMH_Locate_ResponseHandler_ptr rhp;
ACE_NEW_RETURN (rhp,
TAO_AMH_Locate_ResponseHandler (request),
DS_MISMATCHED_KEY);
TAO_AMH_Locate_ResponseHandler_var rh (rhp);
this->find_object (rh, key);
return 0;
}
if (this->TAO_Table_Adapter::find_object (key, forward_to))
{
request.forward_location (forward_to);
return TAO_Adapter::DS_FORWARD;
}
else
return TAO_Adapter::DS_MISMATCHED_KEY;
}
int
TAO_Table_Adapter::dispatch (TAO::ObjectKey &key,
TAO_ServerRequest &request,
CORBA::Object_out forward_to)
{
TAO_IOR_Table_Impl_var rootref;
{
ACE_GUARD_RETURN (ACE_Lock,
ace_mon,
*this->lock_,
TAO_Adapter::DS_MISMATCHED_KEY);
if (this->closed_)
return TAO_Adapter::DS_MISMATCHED_KEY;
rootref = this->root_;
}
if (this->find_object (key, forward_to))
{
request.forward_location (forward_to);
return TAO_Adapter::DS_FORWARD;
}
else
return TAO_Adapter::DS_MISMATCHED_KEY;
}
void
TAO_AMH_Skeletons::_component_amh_skel (TAO_ServerRequest & server_request,
TAO::Portable_Server::Servant_Upcall* TAO_INTERCEPTOR (servant_upcall),
TAO_ServantBase *servant)
{
#if TAO_HAS_INTERCEPTORS == 1
static ::CORBA::TypeCode_ptr const * const exceptions = 0;
static ::CORBA::ULong const nexceptions = 0;
#endif /* TAO_HAS_INTERCEPTORS */
TAO::SArg_Traits< ::CORBA::Object>::ret_val retval;
TAO::Argument * const args[] =
{
&retval
};
static size_t const nargs = 1;
_get_component_amh_Upcall_Command command (
servant,
server_request.operation_details (),
args);
TAO::Upcall_Wrapper upcall_wrapper;
upcall_wrapper.upcall (server_request
, args
, nargs
, command
#if TAO_HAS_INTERCEPTORS == 1
, servant_upcall
, exceptions
, nexceptions
#endif /* TAO_HAS_INTERCEPTORS == 1 */
);
}
TAO_AMH_DSI_Response_Handler::TAO_AMH_DSI_Response_Handler (
TAO_ServerRequest & sr)
: TAO_AMH_Response_Handler (),
orb_core_ (sr.orb_core ())
{
}
void
TAO_DynamicImplementation::_dispatch (
TAO_ServerRequest &request,
TAO::Portable_Server::Servant_Upcall * /* context */)
{
// No need to do any of this if the client isn't waiting.
if (request.response_expected ())
{
if (request.is_forwarded ())
{
request.init_reply ();
request.tao_send_reply ();
// No need to invoke in this case.
return;
}
else if (request.sync_with_server ())
{
// The last line before the call to this function
// was an ACE_CHECK_RETURN, so if we're here, we
// know there is no exception so far, and that's all
// a SYNC_WITH_SERVER client request cares about.
request.send_no_exception_reply ();
}
}
// Create DSI request object.
CORBA::ServerRequest *dsi_request = 0;
ACE_NEW (dsi_request,
CORBA::ServerRequest (request));
try
{
// Delegate to user.
this->invoke (dsi_request);
// Only if the client is waiting.
if (request.response_expected () && !request.sync_with_server ())
{
dsi_request->dsi_marshal ();
}
}
catch (::CORBA::Exception& ex)
{
// Only if the client is waiting.
if (request.response_expected () && !request.sync_with_server ())
{
if (request.collocated ()
&& request.operation_details ()->cac () != 0)
{
// If we have a cac it will handle the exception and no
// need to do any further processing
request.operation_details ()->cac ()->handle_corba_exception (
request, &ex);
return;
}
else
request.tao_send_reply_exception (ex);
}
}
::CORBA::release (dsi_request);
}
TAO::CSD::Strategy_Base::DispatchResult
TAO_DTP_POA_Strategy::dispatch_collocated_request_i
(TAO_ServerRequest& server_request,
const PortableServer::ObjectId& object_id,
PortableServer::POA_ptr poa,
const char* operation,
PortableServer::Servant servant)
{
TAO::CSD::TP_Servant_State::HandleType servant_state =
this->get_servant_state (servant);
bool is_sync_with_server = server_request.sync_with_server ();
bool is_synchronous = server_request.response_expected ();
TAO::CSD::TP_Collocated_Synch_Request_Handle
synch_request;
TAO::CSD::TP_Collocated_Synch_With_Server_Request_Handle
synch_with_server_request;
TAO::CSD::TP_Request_Handle
request;
// Create the request object using the appropriate concrete type.
if (is_sync_with_server)
{
TAO::CSD::TP_Collocated_Synch_With_Server_Request *req_ptr;
ACE_NEW_RETURN (req_ptr,
TAO::CSD::TP_Collocated_Synch_With_Server_Request
(server_request,
object_id,
poa,
operation,
servant,
servant_state.in ()),
DISPATCH_REJECTED);
synch_with_server_request = req_ptr;
// Give the request handle its own "copy".
synch_with_server_request->_add_ref ();
request = synch_with_server_request.in ();
}
else if (is_synchronous)
{
TAO::CSD::TP_Collocated_Synch_Request *req_ptr;
ACE_NEW_RETURN (req_ptr,
TAO::CSD::TP_Collocated_Synch_Request (
server_request,
object_id,
poa,
operation,
servant,
servant_state.in ()),
DISPATCH_REJECTED);
synch_request = req_ptr;
// Give the request handle its own "copy".
synch_request->_add_ref ();
request = synch_request.in ();
}
else
{
TAO::CSD::TP_Collocated_Asynch_Request *req_ptr;
ACE_NEW_RETURN (req_ptr,
TAO::CSD::TP_Collocated_Asynch_Request (server_request,
object_id,
poa,
operation,
servant,
servant_state.in ()),
DISPATCH_REJECTED);
// Just use the (base) request handle to hold the request object.
request = req_ptr;
}
// Hand the request object to our task so that it can add the request
// to its "request queue".
if (!this->dtp_task_.add_request (request.in ()))
{
// Return the DISPATCH_REJECTED return code so that the caller (our
// base class' dispatch_request() method) knows that we did
// not handle the request, and that it should be rejected.
return DISPATCH_REJECTED;
}
// We need to wait on the request object if the request type is a
// synchronous request.
if (!synch_request.is_nil ())
{
int srw = synch_request->wait ();
if (srw == false)
{
// Raise exception when request was cancelled.
throw ::CORBA::NO_IMPLEMENT ();
}
}
else if (!synch_with_server_request.is_nil())
{
bool swsr = synch_with_server_request->wait();
if (swsr == false)
{
// Raise exception when request was cancelled.
throw ::CORBA::NO_IMPLEMENT ();
}
}
return DISPATCH_HANDLED;
}
int
TAO_Object_Adapter::dispatch (TAO::ObjectKey &key,
TAO_ServerRequest &request,
CORBA::Object_out forward_to)
{
if (key.length() < TAO_Root_POA::TAO_OBJECTKEY_PREFIX_SIZE
|| ACE_OS::memcmp (key.get_buffer (),
&TAO_Root_POA::objectkey_prefix[0],
TAO_Root_POA::TAO_OBJECTKEY_PREFIX_SIZE) != 0)
{
return TAO_Adapter::DS_MISMATCHED_KEY;
}
int result = 0;
#if TAO_HAS_INTERCEPTORS == 1
TAO::ServerRequestInterceptor_Adapter *sri_adapter =
orb_core_.serverrequestinterceptor_adapter ();
try
{
if (sri_adapter != 0)
{
#if TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1
CORBA::OctetSeq_var ocs;
sri_adapter->tao_ft_interception_point (request,
0, // args
0, // nargs
0, // servant_upcall
0, // exceptions
0, // nexceptions
ocs.out ());
/// If we have a cached result, just go ahead and send the reply
/// and let us return
if (ocs.ptr () != 0)
{
// request.result_seq (
request.send_cached_reply (ocs.inout ());
return TAO_Adapter::DS_OK;
}
// If a PortableInterceptor::ForwardRequest exception was
// thrown, then set the forward_to object reference and return
// with the appropriate return status.
forward_to.ptr () = request.forward_location ();
if (request.is_forwarded ())
{
return TAO_Adapter::DS_FORWARD;
}
#endif /*TAO_HAS_EXTENDED_FT_INTERCEPTORS*/
// The receive_request_service_contexts() interception point
// must be invoked before the operation is dispatched to the
// servant.
sri_adapter->receive_request_service_contexts (request,
0, // args
0, // nargs
0, // servant_upcall
0, // exceptions
0); // nexceptions
// If a PortableInterceptor::ForwardRequest exception was
// thrown, then set the forward_to object reference and return
// with the appropriate return status.
forward_to.ptr () = request.forward_location ();
if (request.is_forwarded ())
{
return TAO_Adapter::DS_FORWARD;
}
}
#endif /* TAO_HAS_INTERCEPTORS == 1 */
result = this->dispatch_servant (key, request, forward_to);
#if TAO_HAS_INTERCEPTORS == 1
if (result == TAO_Adapter::DS_FORWARD)
{
request.reply_status (GIOP::LOCATION_FORWARD);
request.pi_reply_status (PortableInterceptor::LOCATION_FORWARD);
request.forward_location (forward_to.ptr ());
if (sri_adapter != 0)
{
sri_adapter->send_other (request,
0, // args
0, // nargs
0, // servant_upcall
0, // exceptions
0 // nexceptions
);
}
}
}
catch ( ::CORBA::Exception& ex)
{
// Just assume the current exception is a system exception, the
// status can only change when the interceptor changes this
// and this is only done when the sri_adapter is available. If we
// don't have an sri_adapter we just rethrow the exception
PortableInterceptor::ReplyStatus status =
PortableInterceptor::SYSTEM_EXCEPTION;
if (sri_adapter != 0)
{
request.caught_exception (&ex);
sri_adapter->send_exception (request,
0, // args
0, // nargs
0, // servant_upcall
0, // exceptions
0); // nexceptions
status = request.pi_reply_status ();
}
// Only re-throw the exception if it hasn't been transformed by
// the send_exception() interception point (e.g. to a
// LOCATION_FORWARD).
if (status == PortableInterceptor::SYSTEM_EXCEPTION
|| status == PortableInterceptor::USER_EXCEPTION)
{
throw;
}
}
#endif /* TAO_HAS_INTERCEPTORS == 1 */
return result;
}
