void TAO_RT_Notify_Service::init_i (CORBA::ORB_ptr orb) { //Init the base class. TAO_CosNotify_Service::init_i (orb); TAO_Notify_RT_Properties* properties = TAO_Notify_RT_PROPERTIES::instance(); // Resolve RTORB CORBA::Object_var object = orb->resolve_initial_references ("RTORB"); RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in ()); // Resolve RTCurrent object = orb->resolve_initial_references ("RTCurrent"); RTCORBA::Current_var current = RTCORBA::Current::_narrow (object.in ()); /// Set the properties properties->rt_orb (rt_orb.in ()); properties->current (current.in ()); }
Test::Hello_var prepare_tests (CORBA::ORB_ptr orb, PortableServer::POA_ptr root_poa) { register_factories(orb); CORBA::Object_var objectman = orb->resolve_initial_references ("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (objectman.in ()); PortableServer::POA_var my_compress_poa = 0; CORBA::PolicyList policies(4); policies.length(4); try { policies[0] = create_compressor_id_level_list_policy (orb); policies[1] = create_low_value_policy (orb); policies[2] = create_compression_enabled_policy (orb); policies[3] = create_min_ratio_policy (orb); my_compress_poa = root_poa->create_POA("My_Compress_Poa", 0, policies); } catch(const CORBA::PolicyError&) { policies.length(0); my_compress_poa = root_poa->create_POA("My_Compress_Poa", 0, policies); } policy_manager->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); CORBA::Object_var pcobject = orb->resolve_initial_references ("PolicyCurrent"); CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (pcobject.in ()); policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); PortableServer::POAManager_var poa_manager = my_compress_poa->the_POAManager (); Hello *hello_impl = 0; ACE_NEW_RETURN (hello_impl, Hello (orb), 0); PortableServer::ServantBase_var owner_transfer(hello_impl); PortableServer::ObjectId_var id = my_compress_poa->activate_object (hello_impl); CORBA::Object_var object = my_compress_poa->id_to_reference (id.in ()); Test::Hello_var hello = Test::Hello::_narrow (object.in ()); poa_manager->activate (); return hello._retn (); }
int main(int argc, char ** argv) { try { // init ORB CORBA::ORB_ptr orb = CORBA::ORB_init(argc, argv); // init POA CORBA::Object_var poa_obj = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow(poa_obj); PortableServer::POAManager_var manager = poa->the_POAManager(); // create service Math_operation * service = new Math_operation; // register within the naming service try { CORBA::Object_var ns_obj = orb->resolve_initial_references("NameService"); if (!CORBA::is_nil(ns_obj)) { CosNaming::NamingContext_ptr nc = CosNaming::NamingContext::_narrow(ns_obj); CosNaming::Name name; name.length(1); name[0].id = CORBA::string_dup("TestServer"); name[0].kind = CORBA::string_dup(""); nc->rebind(name, service->_this()); cout << argv[0] << ": server 'TestServer' bound" << endl; } } catch (CosNaming::NamingContext::NotFound &) { cerr << "not found" << endl; } catch (CosNaming::NamingContext::InvalidName &) { cerr << "invalid name" << endl; } catch (CosNaming::NamingContext::CannotProceed &) { cerr << "cannot proceed" << endl; } // run manager->activate(); orb->run(); // clean up delete service; // quit orb->destroy(); } catch (CORBA::UNKNOWN) { cerr << "unknown exception" << endl; } catch (CORBA::SystemException &) { cerr << "system exception" << endl; } }
EDF_Scheduler::EDF_Scheduler (CORBA::ORB_ptr orb, Kokyu::DSRT_Dispatcher_Impl_t disp_impl_type, int ace_sched_policy, int ace_sched_scope) : orb_ (CORBA::ORB::_duplicate (orb)), disp_impl_type_ (disp_impl_type), ace_sched_policy_ (ace_sched_policy), ace_sched_scope_ (ace_sched_scope) { Kokyu::DSRT_ConfigInfo config; config.impl_type_ = this->disp_impl_type_; config.sched_policy_ = ace_sched_policy_; config.sched_scope_ = ace_sched_scope_; Kokyu::DSRT_Dispatcher_Factory<EDF_Scheduler_Traits>::DSRT_Dispatcher_Auto_Ptr tmp( Kokyu::DSRT_Dispatcher_Factory<EDF_Scheduler_Traits>:: create_DSRT_dispatcher (config) ); DSUI_EVENT_LOG (EDF_SCHED_FAM, CONSTRUCTOR, 0, 0, 0); kokyu_dispatcher_ = tmp; CORBA::Object_var object = orb->resolve_initial_references ("RTScheduler_Current"); this->current_ = RTScheduling::Current::_narrow (object.in ()); IOP::CodecFactory_var codec_factory; CORBA::Object_var obj = orb->resolve_initial_references ("CodecFactory"); if (CORBA::is_nil(obj.in ())) { ACE_ERROR ((LM_ERROR, "Nil Codec factory\n")); } else { codec_factory = IOP::CodecFactory::_narrow (obj.in ()); } IOP::Encoding encoding; encoding.format = IOP::ENCODING_CDR_ENCAPS; encoding.major_version = 1; encoding.minor_version = 2; codec_ = codec_factory->create_codec (encoding); }
int TAO_IFR_Server::init_with_orb (int argc, ACE_TCHAR *argv [], CORBA::ORB_ptr orb, int use_multicast_server) { try { // Get the POA from the ORB. CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA"); if (CORBA::is_nil (poa_object.in ())) { ORBSVCS_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) IFR_Service::init_with_orb ") ACE_TEXT ("Unable to initialize the POA.\n")), -1); } PortableServer::POA_var rp = PortableServer::POA::_narrow (poa_object.in ()); return this->init_with_poa (argc, argv, orb, rp.in(), use_multicast_server); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("IFR_Service::init_with_orb"); throw; } return 0; }
void TAO_Notify_Service_Driver::apply_timeout (CORBA::ORB_ptr orb) { #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0 if (this->timeout_ != 0) { // convert from msec to "TimeT" CORBA::Any timeout; TimeBase::TimeT value = 10000 * this->timeout_; timeout <<= value; CORBA::Object_var object = orb->resolve_initial_references ("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (object.in ()); if (CORBA::is_nil (policy_manager.in ())) throw CORBA::INTERNAL (); CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = orb->create_policy ( Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, timeout); policy_manager->set_policy_overrides (policy_list, CORBA::SET_OVERRIDE); policy_list[0]->destroy (); } #else ACE_UNUSED_ARG (orb); #endif /* TAO_HAS_CORBA_MESSAGING != 0 */ }
int TAO_Naming_Server::init (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, size_t context_size, ACE_Time_Value *timeout, bool resolve_for_existing_naming_service, const ACE_TCHAR *persistence_location, void *base_addr, int enable_multicast, int use_storable_context, int round_trip_timeout, int use_round_trip_timeout) { if (resolve_for_existing_naming_service) { try { // Try to find an existing Naming Service. CORBA::Object_var naming_obj = orb->resolve_initial_references ("NameService", timeout); if (!CORBA::is_nil (naming_obj.in ())) { // // Success in finding a Naming Service. // if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG, "\nNameService found!\n")); this->naming_context_ = CosNaming::NamingContext::_narrow (naming_obj.in ()); this->naming_service_ior_ = orb->object_to_string (naming_obj.in ()); return 0; } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("TAO_Naming_Server::init"); } } if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG, "\nWe'll become a NameService\n")); // Become a Naming Service. return this->init_new_naming (orb, poa, persistence_location, base_addr, context_size, enable_multicast, use_storable_context, round_trip_timeout, use_round_trip_timeout); }
void TAO_CosNotify_Service::init_i2 (CORBA::ORB_ptr orb, CORBA::ORB_ptr dispatching_orb) { // Obtain the Root POA CORBA::Object_var object = orb->resolve_initial_references("RootPOA"); if (CORBA::is_nil (object.in ())) ORBSVCS_ERROR ((LM_ERROR, " (%P|%t) Unable to resolve the RootPOA.\n")); PortableServer::POA_var default_poa = PortableServer::POA::_narrow (object.in ()); // Set the properties TAO_Notify_Properties* properties = TAO_Notify_PROPERTIES::instance(); properties->orb (orb); properties->dispatching_orb (dispatching_orb); properties->separate_dispatching_orb (true); properties->default_poa (default_poa.in ()); // Init the factory and builder this->factory_.reset (this->create_factory ()); ACE_ASSERT( this->factory_.get() != 0 ); TAO_Notify_PROPERTIES::instance()->factory (this->factory_.get()); this->builder_.reset (this->create_builder ()); ACE_ASSERT( this->builder_.get() != 0 ); TAO_Notify_PROPERTIES::instance()->builder (this->builder_.get()); }
static int init_compressor(::CORBA::ORB_ptr orb) { try { ::CORBA::Object_var compression_manager = orb->resolve_initial_references(TAO_OBJID_COMPRESSIONMANAGER); ::Compression::CompressionManager_var manager = ::Compression::CompressionManager::_narrow(compression_manager.in()); if (::CORBA::is_nil(manager.in())) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("ERROR: nil compression manager.\n")),-1); } Compression::CompressorFactory_ptr compressor_factory; ACE_NEW_RETURN (compressor_factory, TAO::RLE_CompressorFactory (), 1); Compression::CompressorFactory_var compr_fact = compressor_factory; manager->register_factory (compr_fact.in ()); } catch (...) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("ERROR: Unable to initialise RLE compressor manager.\n")),-1); } return 0; }
CORBA::InterfaceDef_ptr TAO_IFR_Client_Adapter_Impl::get_interface ( CORBA::ORB_ptr orb, const char *repo_id) { CORBA::Object_var obj = orb->resolve_initial_references ("InterfaceRepository"); if (CORBA::is_nil (obj.in ())) { throw ::CORBA::INTF_REPOS (); } CORBA::Repository_var repo = CORBA::Repository::_narrow (obj.in () ); if (CORBA::is_nil (repo.in ())) { throw ::CORBA::INTF_REPOS (); } CORBA::Contained_var result = repo->lookup_id (repo_id); if (CORBA::is_nil (result.in ())) { return CORBA::InterfaceDef::_nil (); } else { return CORBA::InterfaceDef::_narrow (result.in ()); } }
TAO_Scheduler::TAO_Scheduler (CORBA::ORB_ptr orb) { CORBA::Object_var current_obj = orb->resolve_initial_references ("RTScheduler_Current"); current_ = RTScheduling::Current::_narrow (current_obj.in ()); }
int register_factories (CORBA::ORB_ptr orb) { CORBA::Object_var compression_manager_obj = orb->resolve_initial_references("CompressionManager"); compression_manager = ::Compression::CompressionManager::_narrow ( compression_manager_obj.in ()); if (CORBA::is_nil(compression_manager.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil compression manager\n"), 1); //register Zlib compressor ::Compression::CompressorFactory_ptr compressor_factory; ACE_NEW_RETURN (compressor_factory, TAO::Zlib_CompressorFactory (), 1); ::Compression::CompressorFactory_var compr_fact = compressor_factory; compression_manager->register_factory(compr_fact.in ()); // register bzip2 compressor ACE_NEW_RETURN (compressor_factory, TAO::Bzip2_CompressorFactory (), 1); compr_fact = compressor_factory; compression_manager->register_factory(compr_fact.in ()); // register test compressor ACE_NEW_RETURN (compressor_factory, TAO::Test_CompressorFactory (), 1); compr_fact = compressor_factory; compression_manager->register_factory(compr_fact.in ()); return 0; }
int configure_policies (CORBA::ORB_ptr orb, const TAO::BufferingConstraint &buffering_constraint, Test::AMI_Buffering_ptr ami_buffering, Test::AMI_Buffering_out flusher) { CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent"); CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (object.in ()); if (CORBA::is_nil (policy_current.in ())) { ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n")); return 1; } CORBA::Any scope_as_any; scope_as_any <<= Messaging::SYNC_NONE; CORBA::Any buffering_as_any; buffering_as_any <<= buffering_constraint; CORBA::PolicyList policies (2); policies.length (2); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, scope_as_any); policies[1] = orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, buffering_as_any); policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); policies[0]->destroy (); policies[1]->destroy (); TAO::BufferingConstraint flush_constraint; flush_constraint.mode = TAO::BUFFER_FLUSH; flush_constraint.message_count = 0; flush_constraint.message_bytes = 0; flush_constraint.timeout = 0; buffering_as_any <<= flush_constraint; policies.length (1); policies[0] = orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, buffering_as_any); object = ami_buffering->_set_policy_overrides (policies, CORBA::ADD_OVERRIDE); policies[0]->destroy (); flusher = Test::AMI_Buffering::_narrow (object.in ()); return 0; }
static CORBA::Object_ptr getObjectReference(CORBA::ORB_ptr orb) { CosNaming::NamingContext_var rootContext; try { // Obtain a reference to the root context of the Name service: CORBA::Object_var obj; obj = orb->resolve_initial_references("NameService"); // Narrow the reference returned. rootContext = CosNaming::NamingContext::_narrow(obj); if( CORBA::is_nil(rootContext) ) { cerr << "Failed to narrow the root naming context." << endl; return CORBA::Object::_nil(); } } catch (CORBA::NO_RESOURCES&) { cerr << "Caught NO_RESOURCES exception. You must configure omniORB " << "with the location" << endl << "of the naming service." << endl; return 0; } catch(CORBA::ORB::InvalidName& ex) { // This should not happen! cerr << "Service required is invalid [does not exist]." << endl; return CORBA::Object::_nil(); } // Create a name object, containing the name test/context: CosNaming::Name name; name.length(2); name[0].id = (const char*) "test"; // string copied name[0].kind = (const char*) "my_context"; // string copied name[1].id = (const char*) "IdServer"; name[1].kind = (const char*) "Object"; // Note on kind: The kind field is used to indicate the type // of the object. This is to avoid conventions such as that used // by files (name.type -- e.g. test.ps = postscript etc.) try { // Resolve the name to an object reference. return rootContext->resolve(name); } catch(CosNaming::NamingContext::NotFound& ex) { // This exception is thrown if any of the components of the // path [contexts or the object] aren't found: cerr << "Context not found." << endl; } catch(CORBA::TRANSIENT& ex) { cerr << "Caught system exception TRANSIENT -- unable to contact the " << "naming service." << endl << "Make sure the naming server is running and that omniORB is " << "configured correctly." << endl; } catch(CORBA::SystemException& ex) { cerr << "Caught a CORBA::" << ex._name() << " while using the naming service." << endl; return 0; } return CORBA::Object::_nil(); }
/*! * @brief Constructor */ OrganizationProxyTests() { int argc = 0; char** argv = NULL; m_pORB = CORBA::ORB_init(argc, argv); m_pPOA = PortableServer::POA::_narrow( m_pORB->resolve_initial_references("RootPOA")); m_pPOA->the_POAManager()->activate(); }
Stock_Publisher (CORBA::ORB_ptr orb, CORBA::StringSeq &stocks) { CORBA::Object_var obj = orb->resolve_initial_references ("RTCurrent"); rt_current_ = RTCORBA::Current::_narrow (obj.in ()); // Create the message sn_ = new OBV_Stock::StockNames (); sn_->names (stocks); }
// Implementation skeleton constructor CDBPropertySet::CDBPropertySet (CORBA::ORB_ptr orb, PortableServer::POAManager_ptr poa_manager, PortableServer::POA_ptr root_poa) : poa_m(PortableServer::POA::_nil()), poaCurrent_m(PortableServer::Current::_nil()) { ACS_TRACE("baci::CDBPropertySet::CDBPropertySet"); CORBA::PolicyList policies (5); policies.length (5); // ID Assignment Policy policies[0] = root_poa->create_id_assignment_policy (PortableServer::USER_ID); // Lifespan Policy policies[1] = root_poa->create_lifespan_policy (PortableServer::PERSISTENT); // Request Processing Policy policies[2] = root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT); // Servant Retention Policy policies[3] = root_poa->create_servant_retention_policy (PortableServer::RETAIN); // Id Uniqueness Policy policies[4] = root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID); ACE_CString name = "DefaultServantPOA"; poa_m = root_poa->create_POA (name.c_str (), poa_manager, policies); for (CORBA::ULong i = 0UL; i < policies.length (); ++i) { CORBA::Policy_ptr policy_p = policies[i]; policy_p->destroy(); } // Get the POA Current object reference CORBA::Object_var obj = orb->resolve_initial_references ("POACurrent"); // Narrow the object reference to a POA Current reference this->poaCurrent_m = PortableServer::Current::_narrow (obj.in()); // Set default servant poa_m->set_servant (this); instance_mp = this; }
/*! * @brief Constructor */ OutPortConnectorTests() { int argc(0); char** argv(NULL); m_pORB = CORBA::ORB_init(argc, argv); m_pPOA = PortableServer::POA::_narrow( m_pORB->resolve_initial_references("RootPOA")); m_pPOA->the_POAManager()->activate(); }
void LiveCheck::init (CORBA::ORB_ptr orb, const ACE_Time_Value &pi) { this->ping_interval_ = pi; ACE_Reactor *r = orb->orb_core()->reactor(); this->reactor (r); CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA"); this->poa_ = PortableServer::POA::_narrow (obj.in()); this->running_ = true; }
int test_transport_current (CORBA::ORB_ptr orb) { // Get the Current object. CORBA::Object_var tcobject = orb->resolve_initial_references ("TAO::Transport::IIOP::Current"); if (TAO_debug_level >= 1) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Tester (%P|%t) Resolved initial reference for IIOP::Current\n"))); Transport::IIOP::Current_var tc = Transport::IIOP::Current::_narrow (tcobject.in ()); if (TAO_debug_level >= 1) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Tester (%P|%t) Narowed the IIOP Transport Current\n"))); if (CORBA::is_nil (tc.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Tester (%P|%t) ERROR: Could not resolve ") ACE_TEXT ("TAO::Transport::IIOP::Current object.\n"))); throw CORBA::INTERNAL (); } ::CORBA::String_var rhost (tc->remote_host ()); ::CORBA::String_var lhost (tc->local_host ()); ::CORBA::Long id = tc->id (); ::TAO::CounterT bs = tc->bytes_sent (); ::TAO::CounterT br = tc->bytes_received (); ::TAO::CounterT rs = tc->messages_sent (); ::TAO::CounterT rr = tc->messages_received (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Tester (%P|%t) Transport [%q] [%C:%d -> %C:%d] ") ACE_TEXT ("Sent/Received [bytes=%q/%q, messages=%q/%q]\n"), (ACE_UINT64)id, rhost.in (), tc->remote_port (), lhost.in (), tc->local_port (), (ACE_UINT64)bs, (ACE_UINT64)br, (ACE_UINT64)rs, (ACE_UINT64)rr)); return 0; }
OrbContext() { orb = ossie::corba::Orb(); rootPOA = ossie::corba::RootPOA(); namingService = ossie::corba::InitialNamingContext(); namingServiceCtx = CosNaming::NamingContextExt::_nil(); try { CORBA::Object_ptr obj; obj=orb->resolve_initial_references("NameService"); namingServiceCtx = CosNaming::NamingContextExt::_narrow(obj); } catch(...){ }; };
MIF_Scheduler::MIF_Scheduler (CORBA::ORB_ptr orb) : wait_cond_ (lock_), wait_ (0) { try { CORBA::Object_var object = orb->resolve_initial_references ("RTScheduler_Current"); this->current_ = RTScheduling::Current::_narrow (object.in ()); object = orb->resolve_initial_references ("PriorityMappingManager"); this->mapping_manager_ = RTCORBA::PriorityMappingManager::_narrow (object.in ()); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); } }
CORBA::Object_ptr getObjectReference(CORBA::ORB_ptr orb, const char serviceName[]) { CosNaming::NamingContext_var rootContext; try { // Obtain a reference to the root context of the name service: CORBA::Object_var initServ; initServ = orb->resolve_initial_references("NameService"); // Narrow the object returned by resolve_initial_references() to a CosNaming::NamingContext // object rootContext = CosNaming::NamingContext::_narrow(initServ); if (CORBA::is_nil(rootContext)) { cerr << "Failed to narrow naming context." << endl; return CORBA::Object::_nil(); } } catch (CORBA::ORB::InvalidName&) { cerr << "Name service does not exist." << endl; return CORBA::Object::_nil(); } // Create a name object, containing the name corejava/SysProp: CosNaming::Name name; name.length(1); name[0].id = serviceName; name[0].kind = "Object"; CORBA::Object_ptr obj; try { // Resolve the name to an object reference, and assign the returned reference to a // CORBA::Object: obj = rootContext->resolve(name); } catch (CosNaming::NamingContext::NotFound&) { // This exception is thrown if any of the components of the path [contexts or the object] // aren't found: cerr << "Context not found." << endl; return CORBA::Object::_nil(); } return obj; }
// Creates DynUnion using typecodes generated through IDL compiler. int runStatic(CORBA::ORB_ptr orb) { try { CORBA::Object_var obj = orb->resolve_initial_references("DynAnyFactory"); DynamicAny::DynAnyFactory_var dfact = DynamicAny::DynAnyFactory::_narrow(obj.in ()); if (CORBA::is_nil (dfact.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Nil dynamic any factory after narrow\n"), -1); } DynamicAny::DynAny_var dany = dfact->create_dyn_any_from_type_code(DynAnyTest::_tc_EventData); DynamicAny::DynUnion_var dunion = DynamicAny::DynUnion::_narrow(dany.in ()); DynamicAny::DynAny_var disc = dunion->get_discriminator(); DynamicAny::DynEnum_var denum = DynamicAny::DynEnum::_narrow(disc.in ()); if (CORBA::is_nil (denum.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Nil dynamic enum after narrow\n"), -1); } ACE_DEBUG ((LM_DEBUG, "Static Test Passed\n")); } catch (const CORBA::Exception & ex) { ex._tao_print_exception ("runStatic"); return -1; } return 0; }
void ImR_DSI_Forwarder::init (CORBA::ORB_ptr orb) { ACE_ASSERT (! CORBA::is_nil(orb)); this->orb_ = orb; try { CORBA::Object_var tmp = orb->resolve_initial_references ("POACurrent"); this->poa_current_var_ = PortableServer::Current::_narrow (tmp.in ()); } catch (const CORBA::Exception&) { } ACE_ASSERT (!CORBA::is_nil (this->poa_current_var_.in ())); }
// Implementation skeleton constructor Stock_StockBroker_i::Stock_StockBroker_i (CORBA::ORB_ptr orb, Stock::StockDistributor_ptr dist, const char *stock_name) : orb_ (CORBA::ORB::_duplicate (orb)), quoter_ (Stock::StockQuoter::_nil()), consumer_ (0), distributor_ (Stock::StockDistributor::_duplicate (dist)) { // Get a reference to the <RTORB>. CORBA::Object_var obj = orb->resolve_initial_references ("RTORB"); RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (obj.in ()); // Create a <CORBA::PolicyList> for the child POA. TAO::Utils::PolicyList_Destroyer consumer_policies (1); consumer_policies.length (1); // Create a <CLIENT_PROPAGATED> priority model policy. consumer_policies[0] = rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, Stock::Priority_Mapping::MEDIUM); PortableServer::POA_var poa = this->_default_POA (); PortableServer::POAManager_var poa_mgr = poa->the_POAManager (); // Create a child POA with CLIENT_PROPAGATED policies. The name of // the POA will be <StockNameConsumer_POA>. Instances of the // Stock_StockNameConsumer_i will be activated under this POA. PortableServer::POA_var child_poa = poa->create_POA ("StockNameConsumer_POA", poa_mgr. in(), consumer_policies); // Narrow the POA to a <RTPortableServer::POA>. RTPortableServer::POA_var rt_poa = RTPortableServer::POA::_narrow (child_poa.in ()); // Create and activate the <consumer_>. this->consumer_ = new Stock_StockNameConsumer_i (*this, stock_name); PortableServer::ServantBase_var nameconsumer_owner_transfer = this->consumer_; rt_poa->activate_object (this->consumer_); }
int test_transport_current (CORBA::ORB_ptr orb) { // Get the Current object. CORBA::Object_var tcobject = orb->resolve_initial_references ("TAO::Transport::Current"); Transport::Current_var tc = Transport::Current::_narrow (tcobject.in ()); if (CORBA::is_nil (tc.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) client - ERROR: Could not resolve ") ACE_TEXT ("TAOTransportCurrent object.\n"))); throw CORBA::INTERNAL (); } return test_transport_current (tc.in ()); }
static CORBA::Object_ptr get_distributor_reference (CORBA::ORB_ptr orb) { if (use_naming) { CORBA::Object_var tmp = orb->resolve_initial_references ("NameService"); CosNaming::NamingContext_var pns = CosNaming::NamingContext::_narrow (tmp.in ()); CosNaming::Name name (1); name.length (1); name[0].id = distributor_name.c_str (); return pns->resolve (name); } else // Read and destringify the Stock_Distributor object's IOR. return orb->string_to_object (ior.c_str ()); }
bool NameServiceBase::initNameService(CORBA::ORB_ptr orb) { // get naming service CORBA::Object_var obj; try { obj = orb->resolve_initial_references("NameService"); } catch (const CORBA::ORB::InvalidName&) { std::cerr << "Can't resolve NameService" << std::endl; return false; } if (CORBA::is_nil(obj.in())) { std::cerr << "NameService is a nil object reference" << std::endl; return false; } try { nameService_ = CosNaming::NamingContext::_narrow(obj.in()); } catch (const CORBA::Exception&) { std::cerr << "NameService is not running" << std::endl; return false; } if (CORBA::is_nil(nameService_.in())) { std::cerr << "NameService is not a NamingContext object reference" << std::endl; return false; } return true; }
void Checkpointable:: associate_state (CORBA::ORB_ptr orb, CORBA::Any const& state) { try { CORBA::Object_var pic_obj = orb->resolve_initial_references ("PICurrent"); PortableInterceptor::Current_var pic = PortableInterceptor::Current::_narrow ( pic_obj.in ()); pic->set_slot (state_slot_id (), state); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); } }