int make_ior (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, Hello * servant, const ACE_TCHAR *ior_file) { CORBA::String_var poa_name = poa->the_name(); ACE_DEBUG ((LM_DEBUG, "Creating IOR from %C\n", poa_name.in())); PortableServer::ObjectId_var oid = poa->activate_object (servant); CORBA::Object_var o = poa->id_to_reference (oid.in ()); if (host_form == from_hostname || host_form == use_localhost) { CORBA::String_var ior = orb->object_to_string (o.in ()); FILE *output_file= ACE_OS::fopen (ior_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file %s for writing IOR: %C", ior_file, ior.in ()), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); } return 0; }
CORBA::Object_ptr TAO_DLL_Parser::parse_string (const char *ior, CORBA::ORB_ptr orb) { // Skip the prefix, we know it is there because this method in only // called if <match_prefix> returns 1. const char *name = ior + sizeof (::dll_prefix) - 1; TAO_ORB_Core *oc = orb->orb_core (); TAO_Object_Loader *loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (oc->configuration(), name); if (loader == 0) { throw CORBA::INV_OBJREF (CORBA::SystemException::_tao_minor_code ( 0, EINVAL), CORBA::COMPLETED_NO); } return loader->create_object (orb, 0, 0); }
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 ()); }
bool test_string_to_object (CORBA::ORB_ptr orb, const char* ior, CORBA::ULong minor) { bool succeed = false; try { // Get the object reference with the IOR CORBA::Object_var object = orb->string_to_object (ior); } catch (const CORBA::BAD_PARAM& ex) { if ((ex.minor() & 0xFFFU) == minor) { succeed = true; } } catch (const CORBA::Exception&) { } if (!succeed) { ACE_ERROR ((LM_ERROR, "(%t) ERROR, test_string_to_object for <%C> didn't result in minor code %d\n", ior, minor)); } return succeed; }
int write_ior_to_file (CORBA::ORB_ptr orb, test_ptr test) { CORBA::String_var ior = orb->object_to_string (test); char filename[BUFSIZ]; ACE_OS::sprintf (filename, "%s_%d", ACE_TEXT_ALWAYS_CHAR (ior_output_file), ior_count++); FILE *output_file = ACE_OS::fopen (filename, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", filename), -1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); return 0; }
void insecure_invocation_test (CORBA::ORB_ptr orb, CORBA::Object_ptr obj) { // Disable protection for this insecure invocation test. Security::QOP qop = Security::SecQOPNoProtection; CORBA::Any no_protection; no_protection <<= qop; // Create the Security::QOPPolicy. CORBA::Policy_var policy = orb->create_policy (Security::SecQOPPolicy, no_protection); CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = CORBA::Policy::_duplicate (policy.in ()); // Create an object reference that uses plain IIOP (i.e. no // protection). CORBA::Object_var object = obj->_set_policy_overrides (policy_list, CORBA::SET_OVERRIDE); Foo::Bar_var server = Foo::Bar::_narrow (object.in ()); if (CORBA::is_nil (server.in ())) { ACE_ERROR ((LM_ERROR, "(%P|%t) ERROR: Object reference <%s> is " "nil.\n", ior)); throw CORBA::INTERNAL (); } try { // This invocation should result in a CORBA::NO_PERMISSION // exception. server->baz (); } catch (const CORBA::NO_PERMISSION&) { ACE_DEBUG ((LM_INFO, "(%P|%t) Received CORBA::NO_PERMISSION from " "server, as expected.\n")); return; } ACE_ERROR ((LM_ERROR, "(%P|%t) ERROR: CORBA::NO_PERMISSION was not thrown.\n" "(%P|%t) ERROR: It should have been thrown.\n")); throw CORBA::INTERNAL (); }
int FT_EventService::report_factory(CORBA::ORB_ptr orb, FtRtecEventChannelAdmin::EventChannel_ptr ec) { try{ char* addr = ACE_OS::getenv("EventChannelFactoryAddr"); if (addr != 0) { // instaniated by object factory, report my ior back to the factory ACE_INET_Addr factory_addr(addr); ACE_SOCK_Connector connector; ACE_SOCK_Stream stream; ORBSVCS_DEBUG((LM_DEBUG,"connecting to %s\n",addr)); if (connector.connect(stream, factory_addr) == -1) ORBSVCS_ERROR_RETURN((LM_ERROR, "(%P|%t) Invalid Factory Address\n"), -1); ORBSVCS_DEBUG((LM_DEBUG,"Factory connected\n")); CORBA::String_var my_ior_string = orb->object_to_string(ec); int len = ACE_OS::strlen(my_ior_string.in()) ; if (stream.send_n(my_ior_string.in(), len) != len) ORBSVCS_ERROR_RETURN((LM_ERROR, "(%P|%t) IOR Transmission Error\n"), -1); stream.close(); } } catch (...){ return -1; } return 0; }
int write_ior_to_file (const ACE_TCHAR *ior_file, CORBA::ORB_ptr orb, CORBA::Object_ptr object) { CORBA::String_var ior = orb->object_to_string (object); FILE *output_file = ACE_OS::fopen (ior_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_file), -1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); return 0; }
Components::Deployment::ServerActivator_ptr get_server_activator (CORBA::ORB_ptr orb, CosNaming::NamingContext_ptr ns, const char* hostname) { cout << "Getting Component Server Activator from Qedo/Activators/" << hostname << endl; CosNaming::Name server_activator_name; server_activator_name.length (3); server_activator_name[0].id = CORBA::string_dup ("Qedo"); server_activator_name[0].kind = CORBA::string_dup (""); server_activator_name[1].id = CORBA::string_dup ("Activators"); server_activator_name[1].kind = CORBA::string_dup (""); server_activator_name[2].id = CORBA::string_dup (hostname); server_activator_name[2].kind = CORBA::string_dup (""); Components::Deployment::ServerActivator_var server_activator; CORBA::Object_var server_activator_obj; try { server_activator_obj = ns->resolve (server_activator_name); } catch (CosNaming::NamingContext::NotFound&) { cerr << "Component Server Activator not found in Name Service" << endl; orb->destroy(); exit (1); } catch (CORBA::SystemException&) { cerr << "CORBA system exception during resolve()" << endl; orb->destroy(); exit (1); } try { server_activator = Components::Deployment::ServerActivator::_narrow (server_activator_obj); } catch (CORBA::SystemException&) { cerr << "Cannot narrow Component Server Activator" << endl; orb->destroy(); exit (1); } return server_activator._retn(); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { int status = 0; try { Consumer_Client client; status = client.init (argc, argv); ACE_UNUSED_ARG(status); ACE_ASSERT(status == 0); CosNotifyChannelAdmin::EventChannel_var ec = client.create_event_channel ("MyEventChannel", 1); CORBA::ORB_ptr orb = client.orb (); CORBA::Object_var object = orb->string_to_object (ior); sig_var sig = sig::_narrow (object.in ()); ACE_ASSERT(! CORBA::is_nil (sig.in ())); CosNotifyChannelAdmin::ConsumerAdmin_var admin = create_consumeradmin (ec.in ()); ACE_ASSERT(!CORBA::is_nil (admin.in ())); create_consumers (admin.in (), &client); // Tell the supplier to go sig->go (); ACE_DEBUG((LM_DEBUG, "Consumer waiting for events...\n")); client.ORB_run( ); ACE_DEBUG((LM_DEBUG, "Consumer done.\n")); consumer_1->disconnect(); sig->done (); } catch (const CORBA::Exception& e) { e._tao_print_exception ("Error: "); status = 1; } return status; }
int run(CORBA::ORB_ptr orb, int argc, char* argv[]) { // // Resolve Root POA // CORBA::Object_var poaObj = orb -> resolve_initial_references("RootPOA"); PortableServer::POA_var rootPOA = PortableServer::POA::_narrow(poaObj); // // Get a reference to the POA manager // PortableServer::POAManager_var manager = rootPOA -> the_POAManager(); // // Create implementation object // Testing_impl* testingImpl = new Testing_impl(rootPOA); PortableServer::ServantBase_var servant = testingImpl; Testing_var testing = testingImpl->_this(); // // Save reference // CORBA::String_var s = orb->object_to_string(testing); const char* refFile = "testing.ref"; ofstream out(refFile); if(out.fail()) { cerr << argv[0] << ": can't open `" << refFile << "': " << strerror(errno) << endl; return EXIT_FAILURE; } out << s << endl; out.close(); // // Run implementation // manager->activate(); orb->run(); return EXIT_SUCCESS; }
MIF_Scheduler::MIF_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<MIF_Scheduler_Traits>::DSRT_Dispatcher_Auto_Ptr tmp( Kokyu::DSRT_Dispatcher_Factory<MIF_Scheduler_Traits>:: create_DSRT_dispatcher (config) ); 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); }
void Lorica_MapperRegistry::init_mappers(PortableServer::POAManager_ptr outward, PortableServer::POAManager_ptr inward, CORBA::ORB_ptr orb, bool has_security) { // first, prevent multiple activation if (this->mappers_ready_) return; // consolidate the mapper list, to append first the generic mapper and // then the null mapper. if (this->generic_mapper_ != 0) { if (Lorica_debug_level > 0) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - adding generic mapper\n"))); } this->add_proxy_mapper(this->generic_mapper_); this->generic_mapper_ = 0; } if (this->null_mapper_ != 0) { if (Lorica_debug_level > 0) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - adding null mapper\n"))); } this->add_proxy_mapper (this->null_mapper_); this->null_mapper_ = 0; } if (this->mappers_ != 0) { if (Lorica_debug_level > 0) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - calling mapper init on the root.\n"))); } this->mappers_->proxy_mapper_init(outward, inward, orb); } this->has_security_ = has_security; #if !defined (LORICA_LACKS_SSLIOP) if (has_security) { this->sec_policies_.length(1); Security::QOP qop = Security::SecQOPIntegrityAndConfidentiality; CORBA::Any i_and_c; i_and_c <<= qop; // Create the Security::QOPPolicy. sec_policies_[0] = orb->create_policy(Security::SecQOPPolicy, i_and_c); } else #endif // LORICA_LACKS_SSLIOP this->sec_policies_.length(0); this->mappers_ready_ = true; }
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(); }
CORBA::Policy_ptr create_min_ratio_policy (CORBA::ORB_ptr orb) { CORBA::Any min_compression_ratio_any; Compression::CompressionRatio min_compression_ratio = 0.50; min_compression_ratio_any <<= min_compression_ratio; return orb->create_policy (ZIOP::COMPRESSION_MIN_RATIO_POLICY_ID, min_compression_ratio_any); }
/*! * @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(); }
int ACE_TMAIN (int argc, ACE_TCHAR* argv[]) { int status = 0; try { Consumer_Client client; status = client.init (argc, argv); if (status != 0) ACE_ERROR_RETURN ((LM_ERROR, "Error: Client init failed.\n"),1); CosNotifyChannelAdmin::EventChannel_var ec = client.create_event_channel ("MyEventChannel", 1); CORBA::ORB_ptr orb = client.orb (); CORBA::Object_var object = orb->string_to_object (ior); sig_var sig = sig::_narrow (object.in ()); CosNotifyChannelAdmin::ConsumerAdmin_var admin = create_consumeradmin (ec.in ()); if (CORBA::is_nil (admin.in ())) ACE_ERROR_RETURN ((LM_ERROR, "Error: nil ConsumerAdmin.\n"),1); create_consumers (admin.in (), &client); ACE_DEBUG ((LM_DEBUG, "\nConsumer waiting for events...\n")); sig->go (); ACE_Time_Value tv (5); orb->run (tv); ACE_DEBUG ((LM_DEBUG, "Consumer done.\n")); } catch (const CORBA::Exception& e) { e._tao_print_exception ("Consumer Error: "); status = 1; } return status; }
static void test_forward_permanent (CORBA::ORB_ptr orb) { CORBA::Object_var obj1 = orb->string_to_object ("corbaloc:iiop:192.168.1.2:1111,iiop:192.168.1.3:1111/NameService"); // the permanent profile CORBA::Object_var obj4 = orb->string_to_object ("corbaloc:iiop:192.168.1.2:4444,iiop:192.168.1.3:4444/NameService"); TAO_Stub *stub1 = obj1->_stubobj (); TAO_Stub *stub4 = obj4->_stubobj (); TAO_Profile *profile = 0; profile = stub1->profile_in_use (); FRANKS_ASSERT (is_endpoint (profile, "192.168.1.2", 1111)); // ----- forward to obj2 permanently stub1->add_forward_profiles (stub4->base_profiles(), true /* permanent */ ); FRANKS_ASSERT (stub1->forward_profiles () != 0); profile = stub1->next_profile (); FRANKS_ASSERT (is_endpoint (profile, "192.168.1.2", 4444)); // ----- stringified object reference must be equal to obj4->base_prpfiles(). FRANKS_ASSERT (marshaled_equal_to_other (orb, obj1.in (), &(stub4->base_profiles())) ); // ----- consume second profile of obj2 profile = stub1->next_profile (); FRANKS_ASSERT (is_endpoint (profile, "192.168.1.3", 4444)); // ----- reached end, next_profile() must yield NULL profile = stub1->next_profile (); FRANKS_ASSERT (profile == 0); FRANKS_ASSERT (stub1->forward_profiles () != 0); }
CORBA::Policy_ptr create_compression_enabled_policy (CORBA::ORB_ptr orb) { // Setting policy whether compression is used. CORBA::Boolean compression_enabling = true; CORBA::Any compression_enabling_any; compression_enabling_any <<= CORBA::Any::from_boolean(compression_enabling); return orb->create_policy (ZIOP::COMPRESSION_ENABLING_POLICY_ID, compression_enabling_any); }
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(); }
TAO_BEGIN_VERSIONED_NAMESPACE_DECL CORBA::Object_ptr TAO_CodecFactory_Loader::create_object (CORBA::ORB_ptr orb, int, ACE_TCHAR *[]) { CORBA::Object_ptr obj = CORBA::Object_ptr (); ACE_NEW_RETURN (obj, TAO_CodecFactory (orb->orb_core ()), CORBA::Object::_nil ()); return obj; }
//---------------------------------------------------------// bool CServer::destroy_corba() { try { int count = 0; char** args = 0; CORBA::ORB_ptr orb = CORBA::ORB_init(count, args); CORBA::release(orb); orb->shutdown(true); orb->destroy(); omniORB::setLogFunction(0); } catch(CORBA::SystemException& err) { LOG4CPLUS_ERROR(CServer::server_logger(), "corba::SystemException: " << ToString(err)); } catch(CORBA::Exception& err) { LOG4CPLUS_ERROR(CServer::server_logger(), "corba::Exception: " << ToString(err)); } catch(omniORB::fatalException& err) { LOG4CPLUS_ERROR(CServer::server_logger(), "omniORB::FatalException: " << ToString(err)); } catch (std::exception err) { LOG4CPLUS_ERROR(CServer::server_logger(), "std::exception occured while destroy_corba()" << err.what()); } catch (...) { LOG4CPLUS_ERROR(CServer::server_logger(), "Unknown exception occured while destroying corba."); }; return true; }
void sync_server (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr flusher) { // Get back in sync with the server... flusher->flush (); flusher->sync (); // Drain responses from the queue ACE_Time_Value tv (0, 100000); orb->run (tv); }
CORBA::Policy_ptr create_low_value_policy (CORBA::ORB_ptr orb) { // Setting policy for minimum amount of bytes that needs to be // compressed. If a message is smaller than this, it doesn't get // compressed CORBA::ULong compression_low_value = 100; CORBA::Any low_value_any; low_value_any <<= compression_low_value; return orb->create_policy (ZIOP::COMPRESSION_LOW_VALUE_POLICY_ID, low_value_any); }
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 ()); }
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; }
AMH_Servant::AMH_Servant (CORBA::ORB_ptr orb) : sleep_time_ (0) { // @@ Mayur, why do you obtain the reactor each time this method is // called? Why not just cache it once in the constructor. // Furthermore, you don't appear to need the ORB pseudo-reference // anything other than to obtain the Reactor. Why not just // remove the cached ORB pseudo-reference altogether? // // Mayur: Good point. Never crossed my mind :) this->reactor_ = orb->orb_core ()->reactor (); }
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(...){ }; };