void ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { ACE_NEW_THROW_EX (this->interceptor_, ServerRequestInterceptor, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ServerRequestInterceptor_var sr_interceptor = this->interceptor_; info->add_server_request_interceptor (sr_interceptor.in ()); PortableInterceptor::ServerRequestInterceptor_ptr reject_interceptor; ACE_NEW_THROW_EX (reject_interceptor, TAO_LB_ServerRequestInterceptor (this->load_alert_), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ServerRequestInterceptor_var safe_reject_interceptor = reject_interceptor; info->add_server_request_interceptor (safe_reject_interceptor.in ()); }
void ORB_Initializer::post_init (PortableInterceptor::ORBInitInfo_ptr info) { // Allocate slot id. // state_slot_id (info->allocate_slot_id ()); // Register replica controller as server request interceptor. // TAO_ORBInitInfo* tao_info = dynamic_cast<TAO_ORBInitInfo*> (info); CORBA::ORB_var orb (tao_info->orb_core ()->orb ()); PortableInterceptor::ServerRequestInterceptor_var interceptor; { PortableInterceptor::ServerRequestInterceptor *tmp_interceptor = 0; ACE_NEW_THROW_EX (tmp_interceptor, ReplicaController (orb.in ()), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); interceptor = tmp_interceptor; } info->add_server_request_interceptor (interceptor.in ()); }
void ClientInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info ) { // get Codec factory IOP::CodecFactory_var codec_factory = info->codec_factory(); // Create and register the request interceptors. PortableInterceptor::ClientRequestInterceptor_ptr ci = PortableInterceptor::ClientRequestInterceptor::_nil (); try { ci = new ClientInterceptor (codec_factory); } catch(...) { std::cerr << "Exception occurred trying to create ClientInterceptor." << std::endl; } PortableInterceptor::ClientRequestInterceptor_var ci_interceptor = ci; info->add_client_request_interceptor (ci_interceptor.in ()); }
void FOO_IORInterceptor_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { IOP::CodecFactory_var codec_factory = info->codec_factory (); // Set up a structure that contains information necessary to // create a GIOP 1.2 CDR encapsulation Codec. IOP::Encoding encoding; encoding.format = IOP::ENCODING_CDR_ENCAPS; encoding.major_version = 1; encoding.minor_version = 2; // Obtain the CDR encapsulation Codec. IOP::Codec_var codec = codec_factory->create_codec (encoding); PortableInterceptor::IORInterceptor_ptr foo; ACE_NEW_THROW_EX (foo, FOO_IORInterceptor (codec.in ()), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::IORInterceptor_var ior_interceptor = foo; info->add_ior_interceptor (ior_interceptor.in ()); }
void Client_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { CORBA::String_var orb_id = info->orb_id (); CORBA::StringSeq_var args = info->arguments (); CORBA::String_var forward_str; // Extract the last forward reference from the argument list. CORBA::ULong args_len = args->length (); for (CORBA::ULong i = 0; i < args_len; ++i) if (ACE_OS::strcmp ("-k", args[i]) == 0 && i < (args_len - 1)) forward_str = args[i + 1]; PortableInterceptor::ClientRequestInterceptor_ptr interceptor = PortableInterceptor::ClientRequestInterceptor::_nil (); // Install the client request interceptor. ACE_NEW_THROW_EX (interceptor, Client_Request_Interceptor (orb_id.in (), forward_str.in ()), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ClientRequestInterceptor_var client_interceptor = interceptor; info->add_client_request_interceptor (client_interceptor.in ()); }
void ClientInitializer::post_init (PortableInterceptor::ORBInitInfo_ptr info) { // get Codec factory IOP::CodecFactory_var codec_factory = info->codec_factory(); // Create and register the request interceptors. PortableInterceptor::ClientRequestInterceptor_var ci = new ClientInterceptor (codec_factory); info->add_client_request_interceptor (ci.in()); }
TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO::SSLIOP::Server_Invocation_Interceptor::Server_Invocation_Interceptor ( PortableInterceptor::ORBInitInfo_ptr info, ::Security::QOP default_qop, size_t tss_slot ) : qop_ (default_qop) { /* * Cache references to the "Current" objects that we'll need during * during invocations. */ CORBA::Object_var obj = info->resolve_initial_references ("SSLIOPCurrent"); this->ssliop_current_ = ::SSLIOP::Current::_narrow (obj.in ()); if (!CORBA::is_nil (this->ssliop_current_.in ())) { TAO::SSLIOP::Current *tao_current = dynamic_cast<TAO::SSLIOP::Current *> (this->ssliop_current_.in ()); if (tao_current != 0) { if (TAO_debug_level > 3) ORBSVCS_DEBUG ((LM_DEBUG, "TAO (%P|%t) SSLIOP_Invocation_Interceptor::CTOR--setting up SSLIOP Current with slot %d\n", tss_slot)); tao_current->tss_slot (tss_slot); } else throw CORBA::INTERNAL (); } obj = info->resolve_initial_references ("SecurityLevel2:SecurityManager"); this->sec2manager_ = SecurityLevel2::SecurityManager::_narrow (obj.in ()); if (! CORBA::is_nil (this->sec2manager_.in ())) { // set the slot id? things seem to work without doing this } #if 0 // Don't need this now that we're not using access_allowed(), but // I'm leaving the code here just in case it would become convenient // for some other use. obj = info->resolve_initial_references ("POACurrent"); this->poa_current_ = PortableServer::Current::_narrow (obj.in ()); #endif }
void ServerORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { CORBA::Object_var obj = info->resolve_initial_references ("POACurrent"); PortableServer::Current_var poa_current = PortableServer::Current::_narrow (obj.in ()); ACE_ASSERT (!CORBA::is_nil (poa_current.in ())); CORBA::String_var orb_id = info->orb_id (); // Create and register the test's ServerRequestInterceptor PortableInterceptor::ServerRequestInterceptor_ptr tmp; ACE_NEW_THROW_EX (tmp, ServerRequestInterceptor (orb_id.in (), poa_current.in ()), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ServerRequestInterceptor_var server_interceptor = tmp; info->add_server_request_interceptor (server_interceptor.in ()); // Create and register the test's IORInterceptor PortableInterceptor::IORInterceptor_ptr ort_test_interceptor; ACE_NEW_THROW_EX (ort_test_interceptor, ORT_test_IORInterceptor, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::IORInterceptor_var ior_interceptor = ort_test_interceptor; info->add_ior_interceptor (ior_interceptor.in ()); }
void TAO::SSLIOP::ORBInitializer::pre_init ( PortableInterceptor::ORBInitInfo_ptr info) { TAO_ORBInitInfo_var tao_info = TAO_ORBInitInfo::_narrow (info); if (CORBA::is_nil (tao_info.in ())) throw CORBA::INV_OBJREF (); // SSLIOP doesn't use the ORB Core until a request invocation occurs // so there is no problem in retrieving the ORB Core pointer in this // pre_init() method. TAO_ORB_Core *orb_core = tao_info->orb_core (); // Create the SSLIOP::Current object. // Note that a new SSLIOP::Current object is created for each ORB. // It wouldn't be very useful to share security context information // with another ORB that isn't configured with security, for // example. SSLIOP::Current_ptr current; ACE_NEW_THROW_EX (current, TAO::SSLIOP::Current (orb_core), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); SSLIOP::Current_var ssliop_current = current; // Register the SSLIOP::Current object reference with the ORB. info->register_initial_reference ("SSLIOPCurrent", ssliop_current.in ()); }
void ServerInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { // get reference to the codec_factory IOP::CodecFactory_var codec_factory = info->codec_factory(); // Create and register the request interceptors. PortableInterceptor::ServerRequestInterceptor_var si = new ServerInterceptor (codec_factory); info->add_server_request_interceptor (si.in()); // add IOR Interceptor PortableInterceptor::IORInterceptor_var iori = new ServerIORInterceptor; info->add_ior_interceptor (iori.in()); }
size_t TAO::SSLIOP::ORBInitializer::get_tss_slot_id ( PortableInterceptor::ORBInitInfo_ptr info) { // Obtain the Security Service TSS slot ID from the SecurityCurrent // object. CORBA::Object_var obj = info->resolve_initial_references ("SecurityLevel3:SecurityCurrent"); SecurityLevel3::SecurityCurrent_var current = SecurityLevel3::SecurityCurrent::_narrow (obj.in ()); TAO::SL3::SecurityCurrent * security_current = dynamic_cast<TAO::SL3::SecurityCurrent *> (current.in ()); if (security_current == 0) { ORBSVCS_DEBUG ((LM_DEBUG, "Unable to obtain TSS slot ID from " "\"SecurityCurrent\" object.\n")); throw CORBA::INTERNAL (); } return security_current->tss_slot (); }
void TAO_RTScheduler_ORB_Initializer::post_init (PortableInterceptor::ORBInitInfo_ptr info) { // @@ This is busted. TAO_ORBInitInfo should do proper reference // counting. // Narrow to a TAO_ORBInitInfo object to get access to the // orb_core() TAO extension. //TAO_ORBInitInfo_var tao_info = TAO_ORBInitInfo::_narrow (info // ); if (TAO_debug_level > 0) TAOLIB_DEBUG ((LM_DEBUG, "In post_init\n")); CORBA::Object_var rt_current_obj = info->resolve_initial_references (TAO_OBJID_RTCURRENT); RTCORBA::Current_var rt_current = RTCORBA::Current::_narrow (rt_current_obj.in ()); if (CORBA::is_nil (rt_current.in ())) { TAOLIB_DEBUG ((LM_DEBUG, "(%P|%t) ::post_init\n" "(%P|%t) Unable to narrow to RTCORBA::Current\n")); throw ::CORBA::INTERNAL (); } this->current_->rt_current (rt_current.in ()); }
void Current_ORBInitializer_Base::pre_init ( PortableInterceptor::ORBInitInfo_ptr info) { // Narrow to a TAO_ORBInitInfo object to get access to the // allocate_tss_slot_id() TAO extension. TAO_ORBInitInfo_var tao_info = TAO_ORBInitInfo::_narrow (info); if (CORBA::is_nil (tao_info.in ())) { if (TAO_debug_level > 0) TAOLIB_ERROR ((LM_ERROR, "TAO (%P|%t) TAO::Transport::ORBInitializer::pre_init - " "Panic: unable to narrow the ORBInitInfo_ptr\n")); throw ::CORBA::INTERNAL (); } // Reserve a TSS slot in the ORB core internal TSS resources for the // thread-specific portion of the Current object. size_t tss_slot = tao_info->allocate_tss_slot_id (0); // Create the Current Current_var current (this->make_current_instance (tao_info->orb_core (), tss_slot)); info->register_initial_reference (ACE_TEXT_ALWAYS_CHAR (this->id_.fast_rep ()), current.in ()); }
void TAO_FT_ServerORBInitializer::register_policy_factories ( PortableInterceptor::ORBInitInfo_ptr info) { // Register the FTCORBA policy factories. PortableInterceptor::PolicyFactory_ptr temp_factory = PortableInterceptor::PolicyFactory::_nil (); PortableInterceptor::PolicyFactory_var policy_factory; // This policy factory is used for all FTCORBA related policies. ACE_NEW_THROW_EX (temp_factory, TAO_FT_ServerPolicyFactory, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); policy_factory = temp_factory; // Bind the same policy factory to all FTCORBA related policy // types since a single policy factory is used to create each of // the different types of FTCORBA policies. CORBA::PolicyType type = FT::HEARTBEAT_ENABLED_POLICY; info->register_policy_factory (type, policy_factory.in ()); }
void ClientInitializer::post_init (PortableInterceptor::ORBInitInfo_ptr info) { // Find the Naming Service CORBA::Object_var naming_obj = info->resolve_initial_references("NameService"); CosNaming::NamingContext_var root = CosNaming::NamingContext::_narrow(naming_obj.in()); if( CORBA::is_nil(root.in())) { std::cerr << "Nil Naming Context reference" << std::endl; ACE_ASSERT(false); } // Resolve the Messenger object CosNaming::Name name; name.length( 1 ); name[0].id = CORBA::string_dup( "Messenger" ); CORBA::Object_var obj = CORBA::Object::_nil(); while ( CORBA::is_nil( obj.in() ) ) { try { obj = root->resolve( name ); } catch (const CosNaming::NamingContext::NotFound&) { // Sleep for a second and try again ACE_OS::sleep(1); } } Messenger_var messenger = Messenger::_narrow( obj.in() ); if( CORBA::is_nil( messenger.in() ) ) { std::cerr << "Not a Messenger reference" << std::endl; ACE_ASSERT(false); } // allocate slot slot_ = info->allocate_slot_id(); // get PICurrent CORBA::Object_var current_obj = info->resolve_initial_references("PICurrent"); current_ = PortableInterceptor::Current::_narrow(current_obj.in()); // Create and register the request interceptors. PortableInterceptor::ClientRequestInterceptor_var ci = new ClientInterceptor(messenger, current_.in(), slot_); info->add_client_request_interceptor (ci.in()); }
void TAO_RT_ORBInitializer::register_policy_factories ( PortableInterceptor::ORBInitInfo_ptr info) { // The RTCorba policy factory is stateless and reentrant, so share a // single instance between all ORBs. if (CORBA::is_nil (this->policy_factory_.in ())) { PortableInterceptor::PolicyFactory_ptr policy_factory; ACE_NEW_THROW_EX (policy_factory, TAO_RT_PolicyFactory, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); this->policy_factory_ = policy_factory; } // Bind the same policy factory to all RTCORBA related policy // types since a single policy factory is used to create each of // the different types of RTCORBA policies. static CORBA::PolicyType const type[] = { RTCORBA::PRIORITY_MODEL_POLICY_TYPE, RTCORBA::THREADPOOL_POLICY_TYPE, RTCORBA::SERVER_PROTOCOL_POLICY_TYPE, RTCORBA::CLIENT_PROTOCOL_POLICY_TYPE, RTCORBA::PRIVATE_CONNECTION_POLICY_TYPE, RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE }; const CORBA::PolicyType *end = type + sizeof (type) / sizeof (type[0]); for (CORBA::PolicyType const * i = type; i != end; ++i) { try { info->register_policy_factory (*i, this->policy_factory_.in ()); } catch (const ::CORBA::BAD_INV_ORDER& ex) { if (ex.minor () == (CORBA::OMGVMCID | 16)) { // The factory is already there, it happens because the // magic initializer in PortableServer.cpp registers // with the ORB multiple times. This is an indication // that we should do no more work in this // ORBInitializer. return; } throw; } } }
void Server_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { // Create and register the test request interceptors. PortableInterceptor::ServerRequestInterceptor_ptr si = PortableInterceptor::ServerRequestInterceptor::_nil (); ACE_NEW_THROW_EX (si, Server_Request_Interceptor ("SERVER A"), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ServerRequestInterceptor_var si_interceptor = si; info->add_server_request_interceptor (si_interceptor.in ()); ACE_NEW_THROW_EX (si, Server_Request_Interceptor ("SERVER B"), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); si_interceptor = si; info->add_server_request_interceptor (si_interceptor.in ()); ACE_NEW_THROW_EX (si, Server_Request_Interceptor ("SERVER C"), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); si_interceptor = si; info->add_server_request_interceptor (si_interceptor.in ()); }
void Client_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { // Create and register the test request interceptors. PortableInterceptor::ClientRequestInterceptor_ptr ci = PortableInterceptor::ClientRequestInterceptor::_nil (); ACE_NEW_THROW_EX (ci, Client_Request_Interceptor ("CLIENT A"), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ClientRequestInterceptor_var ci_interceptor = ci; info->add_client_request_interceptor (ci_interceptor.in ()); ACE_NEW_THROW_EX (ci, Client_Request_Interceptor ("CLIENT B"), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); ci_interceptor = ci; info->add_client_request_interceptor (ci_interceptor.in ()); ACE_NEW_THROW_EX (ci, Client_Request_Interceptor ("CLIENT C"), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); ci_interceptor = ci; info->add_client_request_interceptor (ci_interceptor.in ()); }
void Collocated_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { CORBA::String_var orb_id = info->orb_id (); if (!ACE_OS::strcmp (orb_id.in (), "client_orb")) { PortableInterceptor::ClientRequestInterceptor_ptr interceptor = PortableInterceptor::ClientRequestInterceptor::_nil (); // Install the Echo client request interceptor ACE_NEW_THROW_EX (interceptor, Echo_Client_Request_Interceptor (orb_id.in ()), CORBA::NO_MEMORY ()); PortableInterceptor::ClientRequestInterceptor_var client_interceptor = interceptor; info->add_client_request_interceptor (client_interceptor.in ()); } else if (!ACE_OS::strcmp (orb_id.in (), "server_orb")) { PortableInterceptor::ServerRequestInterceptor_ptr interceptor = PortableInterceptor::ServerRequestInterceptor::_nil (); // Install the Echo server request interceptor ACE_NEW_THROW_EX (interceptor, Echo_Server_Request_Interceptor, CORBA::NO_MEMORY ()); PortableInterceptor::ServerRequestInterceptor_var server_interceptor = interceptor; info->add_server_request_interceptor (server_interceptor.in ()); } else { //Throw exception? } }
void TAO_LB_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { CORBA::Object_var obj = info->resolve_initial_references ("LoadManager"); CosLoadBalancing::LoadManager_var lm = CosLoadBalancing::LoadManager::_narrow (obj.in ()); CORBA::String_var orbid = info->orb_id (); PortableInterceptor::IORInterceptor_ptr tmp; ACE_NEW_THROW_EX (tmp, TAO_LB_IORInterceptor (this->object_groups_, this->repository_ids_, this->location_.in (), lm.in (), orbid.in (), this->load_alert_), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::IORInterceptor_var ior_interceptor = tmp; info->add_ior_interceptor (ior_interceptor.in ()); // ---------------- PortableInterceptor::ServerRequestInterceptor_ptr sri; ACE_NEW_THROW_EX (sri, TAO_LB_ServerRequestInterceptor (this->load_alert_), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ServerRequestInterceptor_var sr_interceptor = sri; info->add_server_request_interceptor (sr_interceptor.in ()); }
void Client_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { PortableInterceptor::ClientRequestInterceptor_var interceptor( new Echo_Client_Request_Interceptor); info->add_client_request_interceptor (interceptor.in ()); }
void TAO::Security::ORBInitializer::register_policy_factories ( PortableInterceptor::ORBInitInfo_ptr info) { // Register the security policy factories. if (CORBA::is_nil (this->policy_factory_.in ())) { PortableInterceptor::PolicyFactory_ptr policy_factory; ACE_NEW_THROW_EX (policy_factory, TAO::Security::PolicyFactory, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); this->policy_factory_ = policy_factory; } // Bind the same policy factory to all security related policy // types since a single policy factory is used to create each of // the different types of security policies. CORBA::PolicyType type; type = ::Security::SecQOPPolicy; info->register_policy_factory (type, this->policy_factory_.in ()); type = ::Security::SecMechanismsPolicy; info->register_policy_factory (type, this->policy_factory_.in ()); type = ::Security::SecInvocationCredentialsPolicy; info->register_policy_factory (type, this->policy_factory_.in ()); type = ::Security::SecFeaturePolicy; // Deprecated info->register_policy_factory (type, this->policy_factory_.in ()); type = ::Security::SecDelegationDirectivePolicy; info->register_policy_factory (type, this->policy_factory_.in ()); type = ::Security::SecEstablishTrustPolicy; info->register_policy_factory (type, this->policy_factory_.in ()); type = SecurityLevel3::ContextEstablishmentPolicyType; info->register_policy_factory (type, this->policy_factory_.in ()); type = SecurityLevel3::ObjectCredentialsPolicyType; info->register_policy_factory (type, this->policy_factory_.in ()); // ---------------------------------------------------------------- }
void Client_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { PortableInterceptor::SlotId slot_id = info->allocate_slot_id (); PortableInterceptor::ClientRequestInterceptor_ptr interceptor = PortableInterceptor::ClientRequestInterceptor::_nil (); // Install the Echo client request interceptor ACE_NEW_THROW_EX (interceptor, Echo_Client_Request_Interceptor (), CORBA::NO_MEMORY ()); PortableInterceptor::ClientRequestInterceptor_var client_interceptor = interceptor; info->add_client_request_interceptor (client_interceptor.in ()); ACE_UNUSED_ARG (slot_id); }
void Client_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { CORBA::String_var orb_id = info->orb_id (); PortableInterceptor::ClientRequestInterceptor_ptr interceptor = PortableInterceptor::ClientRequestInterceptor::_nil (); // Install the Echo client request interceptor ACE_NEW_THROW_EX (interceptor, Client_Request_Interceptor (orb_id.in ()), CORBA::NO_MEMORY ()); PortableInterceptor::ClientRequestInterceptor_var client_interceptor = interceptor; info->add_client_request_interceptor (client_interceptor.in ()); }
void Server_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { // Install the Echo server request interceptor ACE_NEW_THROW_EX (this->server_interceptor_, ForwardTest_Request_Interceptor, CORBA::NO_MEMORY ()); PortableInterceptor::ServerRequestInterceptor_var interceptor = this->server_interceptor_; info->add_server_request_interceptor (interceptor.in ()); }
void ClientORBInitializer::post_init (PortableInterceptor::ORBInitInfo_ptr info) { PortableInterceptor::ClientRequestInterceptor_ptr cri = PortableInterceptor::ClientRequestInterceptor::_nil (); ACE_NEW_THROW_EX (cri, ClientRequest_Interceptor, CORBA::NO_MEMORY ()); PortableInterceptor::ClientRequestInterceptor_var client_interceptor = cri; info->add_client_request_interceptor (client_interceptor.in ()); }
void Server_ORBInitializer2::register_server_request_interceptors ( PortableInterceptor::ORBInitInfo_ptr info ) { TAO249_ServerRequest_Interceptor2 *sri = 0; ACE_NEW_THROW_EX (sri, TAO249_ServerRequest_Interceptor2, CORBA::NO_MEMORY ()); PortableInterceptor::ServerRequestInterceptor_var server_interceptor = sri; this->sri_ = sri; info->add_server_request_interceptor (server_interceptor.in ()); }
void Server_ORBInitializer2::register_server_request_interceptors ( PortableInterceptor::ORBInitInfo_ptr info) { PortableInterceptor::ServerRequestInterceptor_ptr sri = PortableInterceptor::ServerRequestInterceptor::_nil (); ACE_NEW_THROW_EX (sri, ServerRequest_Interceptor2, CORBA::NO_MEMORY ()); PortableInterceptor::ServerRequestInterceptor_var server_interceptor = sri; info->add_server_request_interceptor (server_interceptor.in ()); }
void TAO_LB_ClientORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { PortableInterceptor::ClientRequestInterceptor_ptr tmp; ACE_NEW_THROW_EX (tmp, TAO_LB_ClientRequestInterceptor, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ClientRequestInterceptor_var client_interceptor = tmp; info->add_client_request_interceptor (client_interceptor.in ()); }
void Client_ORBInitializer::post_init (PortableInterceptor::ORBInitInfo_ptr info) { // Install the client request interceptor. ACE_NEW_THROW_EX (client_interceptor_, Client_Request_Interceptor, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableInterceptor::ClientRequestInterceptor_var client_interceptor = client_interceptor_; info->add_client_request_interceptor (client_interceptor.in ()); }