Callback_ptr
ServerApp::create_callback(
PortableServer::POA_ptr poa,
const char* servant_name)
{
PortableServer::ServantBase_var servant
= new Callback_i();
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId("callback");
poa->activate_object_with_id(id.in(), servant.in());
CORBA::Object_var obj = poa->id_to_reference(id.in());
if (CORBA::is_nil(obj.in()))
{
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to activate servant (%s).\n",
servant_name));
throw TestException();
}
Callback_var callback = Callback::_narrow (obj.in ());
return callback._retn ();
}
void
test_reference_to_servant_active_object(PortableServer::POA_ptr root_poa)
{
test_i test;
CORBA::ULong expected_refcount = 1;
PortableServer::ObjectId_var id =
root_poa->activate_object (&test);
expected_refcount++;
CORBA::Object_var object =
root_poa->id_to_reference (id.in ());
PortableServer::ServantBase_var servant =
root_poa->reference_to_servant (object.in ());
++expected_refcount;
root_poa->deactivate_object (id.in ());
--expected_refcount;
CORBA::ULong refcount =
test._refcount_value ();
ACE_UNUSED_ARG (refcount);
ACE_UNUSED_ARG (expected_refcount);
ACE_ASSERT (expected_refcount == refcount);
}
void
activate (T & obj_ref,
PortableServer::POA_ptr poa,
PortableServer::ServantBase * servant,
TAO_EC_Object_Deactivator & suggested_object_deactivator)
{
// Activate the servant into the POA.
PortableServer::ObjectId_var obj_id =
poa->activate_object (servant);
suggested_object_deactivator.set_values (poa, obj_id.in ());
// Get the object reference of the activated object.
CORBA::Object_var obj =
poa->id_to_reference (obj_id.in ());
// Don't try to use T::_obj_type::_narrow, some compilers don't like it so
// do this in two steps
typedef typename T::_obj_type my_object_type;
obj_ref =
my_object_type::_narrow (obj.in());
if (CORBA::is_nil (obj_ref.in ()))
{
throw CORBA::INTERNAL ();
}
}
void
TAO_Notify_POA_Helper::create_i (
PortableServer::POA_ptr parent_poa,
const char* poa_name,
CORBA::PolicyList &policy_list)
{
PortableServer::POAManager_var manager =
parent_poa->the_POAManager ();
// Create the child POA.
this->poa_ = parent_poa->create_POA (poa_name, manager.in (), policy_list);
if (DEBUG_LEVEL > 0)
{
CORBA::String_var the_name = this->poa_->the_name ();
ORBSVCS_DEBUG ((LM_DEBUG, "Created POA : %C\n", the_name.in ()));
}
/*
// Destroy the policies
for (CORBA::ULong index = 0; index < policy_list.length (); ++index)
{
policy_list[index]->destroy ();
}
*/
}
CosNotifyFilter::FilterFactory_ptr
TAO_Notify_ETCL_FilterFactory::create (PortableServer::POA_ptr filter_poa)
{
this->filter_poa_ = PortableServer::POA::_duplicate(filter_poa);
CORBA::Object_var object = CORBA::Object::_nil();
try
{
PortableServer::ObjectId_var id = filter_poa->activate_object (this);
object = filter_poa->id_to_reference (id.in());
}
catch (PortableServer::POA::ServantAlreadyActive&)
{
try
{
object = filter_poa->servant_to_reference (this);
}
catch (CORBA::Exception& )
{
return CosNotifyFilter::FilterFactory::_nil();
}
}
return CosNotifyFilter::FilterFactory::_narrow (object.in ());
}
PortableServer::POA_ptr
createPOA (PortableServer::POA_ptr root_poa,
bool share_mgr,
const char* poa_name)
{
PortableServer::LifespanPolicy_var life =
root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
PortableServer::IdAssignmentPolicy_var assign =
root_poa->create_id_assignment_policy(PortableServer::USER_ID);
CORBA::PolicyList pols;
pols.length(2);
pols[0] = PortableServer::LifespanPolicy::_duplicate(life.in());
pols[1] = PortableServer::IdAssignmentPolicy::_duplicate(assign.in());
PortableServer::POAManager_var mgr = PortableServer::POAManager::_nil();
if (share_mgr)
{
mgr = root_poa->the_POAManager();
}
PortableServer::POA_var poa =
root_poa->create_POA(poa_name, mgr.in(), pols);
life->destroy();
assign->destroy();
return poa._retn();
}
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;
}
void
LiveEntry::do_ping (PortableServer::POA_ptr poa)
{
this->callback_ = new PingReceiver (this, poa);
PortableServer::ObjectId_var oid = poa->activate_object (this->callback_.in());
CORBA::Object_var obj = poa->id_to_reference (oid.in());
ImplementationRepository::AMI_ServerObjectHandler_var cb =
ImplementationRepository::AMI_ServerObjectHandler::_narrow (obj.in());
{
ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
this->liveliness_ = LS_PING_AWAY;
}
try
{
this->ref_->sendc_ping (cb.in());
if (ImR_Locator_i::debug () > 3)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) LiveEntry::do_ping, ")
ACE_TEXT ("sendc_ping returned OK\n")));
}
}
catch (const CORBA::Exception &ex)
{
if (ImR_Locator_i::debug () > 3)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) LiveEntry::do_ping, ")
ACE_TEXT ("sendc_ping threw %C\n"), ex._name()));
}
this->status (LS_DEAD);
}
}
int
create_object (PortableServer::POA_ptr poa,
CORBA::ORB_ptr orb,
Test_i *server_impl,
const ACE_TCHAR *filename)
{
// Register with poa.
PortableServer::ObjectId_var id =
poa->activate_object (server_impl);
CORBA::Object_var server =
poa->id_to_reference (id.in ());
// Print out the IOR.
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG, "<%C>\n\n", ior.in ()));
// Print ior to the file.
if (filename != 0)
{
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;
}
PortableServer::POA_ptr
setup_poa (PortableServer::POA_ptr root_poa)
{
// Policies for the childPOA to be created.
CORBA::PolicyList policies (2);
policies.length (2);
// Tell the POA to use a servant manager.
policies[0] =
root_poa->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER);
// Allow implicit activation.
policies[1] =
root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Create POA as child of RootPOA with the above policies. This POA
// will use a SERVANT_ACTIVATOR because of RETAIN policy.
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Creation of childPOAs is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
return child_poa._retn ();
}
CORBA::Boolean
ImR_Adapter::unknown_adapter (PortableServer::POA_ptr parent,
const char *name)
{
ACE_ASSERT (! CORBA::is_nil(parent));
ACE_ASSERT (name != 0);
CORBA::PolicyList policies (3);
const char *exception_message = "Null Message";
policies.length (3);
try
{
// Servant Retention Policy
exception_message = "While PortableServer::POA::create_servant_retention_policy";
policies[0] =
parent->create_servant_retention_policy (PortableServer::NON_RETAIN);
// Request Processing Policy
exception_message = "While PortableServer::POA::create_request_processing_policy";
policies[1] =
parent->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT);
policies[2] =
parent->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID);
PortableServer::POAManager_var poa_manager =
parent->the_POAManager ();
exception_message = "While create_POA";
PortableServer::POA_var child =
parent->create_POA (name,
poa_manager.in (),
policies);
exception_message = "While policy->destroy";
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
exception_message = "While child->the_activator";
child->the_activator (this);
exception_message = "While set_servant";
child->set_servant (this->default_servant_);
}
catch (const CORBA::Exception& ex)
{
ORBSVCS_ERROR ((LM_ERROR,
"IMR_Adapter_Activator::unknown_adapter - %s\n",
exception_message));
ex._tao_print_exception ("System Exception");
return 0;
}
// Finally, now everything is fine
return 1;
}
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 ();
}
/*!
* @brief tests for is_master(), createINSManager(), findManager(), add_master_manager(), get_master_managers(), remove_master_manager()
*
*
*/
void test_add_master_manager()
{
::RTM::ManagerServant *pman = new ::RTM::ManagerServant();
RTM::ManagerList* list;
try
{
::RTC::ReturnCode_t ret;
CORBA::Boolean cbret;
cbret = pman->is_master();
// is_master(), default is false
CPPUNIT_ASSERT(!cbret);
// get_master_managers()
list = pman->get_master_managers();
CPPUNIT_ASSERT_EQUAL(0, (int)list->length());
// createINSManager()
bool bret = pman->createINSManager();
CPPUNIT_ASSERT(bret);
bret = pman->createINSManager();
CPPUNIT_ASSERT(!bret);
std::string host_port("localhost:2810");
RTM::Manager_var owner;
// findManager()
owner = pman->findManager(host_port.c_str());
// add_master_manager()
ret = pman->add_master_manager(owner);
CPPUNIT_ASSERT_EQUAL(RTC::RTC_OK, ret);
list = pman->get_master_managers();
CPPUNIT_ASSERT_EQUAL(1, (int)list->length());
// remove_master_manager()
ret = pman->remove_master_manager(RTM::Manager::_duplicate(owner));
CPPUNIT_ASSERT_EQUAL(RTC::RTC_OK, ret);
list = pman->get_master_managers();
CPPUNIT_ASSERT_EQUAL(0, (int)list->length());
CORBA::Object_var obj;
obj = m_pORB->resolve_initial_references("omniINSPOA");
PortableServer::POA_ptr poa = PortableServer::POA::_narrow(obj);
poa->the_POAManager()->deactivate(false, true);
}
catch(CORBA::SystemException& e)
{
std::cout << "test_add_master_manager() SystemException: " << e._name() << std::endl;
}
catch (...)
{
std::cout << "test_add_master_manager() other Exception" << std::endl;
}
delete list;
delete pman;
}
int
create_POA_and_register_servant (CORBA::Policy_ptr threadpool_policy,
const char *poa_name,
PortableServer::POAManager_ptr poa_manager,
PortableServer::POA_ptr root_poa,
CORBA::ORB_ptr orb,
RTCORBA::RTORB_ptr rt_orb)
{
// Policies for the firstPOA to be created.
CORBA::PolicyList policies (3); policies.length (3);
// Implicit_activation policy.
policies[0] =
root_poa->create_implicit_activation_policy
(PortableServer::IMPLICIT_ACTIVATION);
// Thread pool policy.
policies[1] =
CORBA::Policy::_duplicate (threadpool_policy);
// Priority Model policy.
policies[2] =
rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, 0);
// Create the POA under the RootPOA.
PortableServer::POA_var poa =
root_poa->create_POA (poa_name,
poa_manager,
policies);
// Creation of POAs is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
test_i *servant =
new test_i (orb,
poa.in (),
nap_time);
PortableServer::ServantBase_var safe_servant (servant);
ACE_UNUSED_ARG (safe_servant);
PortableServer::ObjectId_var id =
poa->activate_object (servant);
CORBA::Object_var object = poa->id_to_reference (id.in ());
test_var test = test::_narrow (object.in ());
int const result = write_ior_to_file (orb, test.in ());
return result;
}
Test_i::Test_i (CORBA::Short server_num,
Terminator &terminator,
PortableServer::POA_ptr pa,
PortableServer::POA_ptr pb)
: mgr_a (pa->the_POAManager ()),
mgr_b (pb->the_POAManager ()),
server_num_ (server_num),
terminator_ (terminator)
{
}
void
TAO_Notify_POA_Helper::set_persistent_policy (PortableServer::POA_ptr parent_poa, CORBA::PolicyList &policy_list)
{
policy_list.length (2);
policy_list[0] =
parent_poa->create_lifespan_policy (PortableServer::PERSISTENT);
policy_list[1] =
parent_poa->create_id_assignment_policy (PortableServer::USER_ID);
}
void
TAO_Notify_POA_Helper::set_policy (PortableServer::POA_ptr parent_poa, CORBA::PolicyList &policy_list)
{
policy_list.length (2);
policy_list[0] =
parent_poa->create_id_uniqueness_policy (PortableServer::UNIQUE_ID);
policy_list[1] =
parent_poa->create_id_assignment_policy (PortableServer::USER_ID);
}
CosNotifyFilter::FilterFactory_ptr
TAO_Notify_Tests_RT_Test_FilterFactory::create (PortableServer::POA_ptr filter_poa)
{
this->filter_poa_ = PortableServer::POA::_duplicate(filter_poa); // save the filter poa.
PortableServer::ObjectId_var id = filter_poa->activate_object (this);
CORBA::Object_var object = filter_poa->id_to_reference (id.in ());
CosNotifyFilter::FilterFactory_var filter = CosNotifyFilter::FilterFactory::_narrow (object.in ());
return filter._retn();
}
void
Quoter_Stock_Factory_i::load_stock_objects (
PortableServer::POA_ptr poa,
PortableServer::POAManager_ptr poa_manager,
RtecEventChannelAdmin::SupplierAdmin_ptr supplier_admin)
{
if (!CORBA::is_nil (this->stock_factory_poa_.in ()))
return;
CORBA::PolicyList policies (2);
policies.length (2);
policies[0] =
poa->create_id_assignment_policy (PortableServer::USER_ID);
policies[1] =
poa->create_implicit_activation_policy (PortableServer::NO_IMPLICIT_ACTIVATION);
this->stock_factory_poa_ =
poa->create_POA ("Stock_Factory_POA",
poa_manager,
policies);
for (CORBA::ULong i = 0; i != policies.length (); ++i) {
policies[i]->destroy ();
}
while (!cin.eof () && cin.peek () != EOF) {
const int max_symbol_length = 8;
char symbol[max_symbol_length];
const int max_full_name_length = 64;
char full_name[max_full_name_length];
double price;
cin.getline (symbol, max_symbol_length, '\n');
cin.getline (full_name, max_full_name_length, '\n');
cin >> price;
cin.ignore (1, '\n');
Quoter_Stock_i *stock =
new Quoter_Stock_i (symbol, full_name, price);
PortableServer::ServantBase_var servant = stock;
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId (symbol);
this->stock_factory_poa_->activate_object_with_id (oid.in (),
servant.in ());
stock->connect (supplier_admin);
}
}
void
test_get_servant_manager (PortableServer::POA_ptr poa)
{
bool succeed = false;
try
{
// Getting the servant manager should give a wrong policy exception
// exception
PortableServer::ServantManager_ptr servant_manager =
poa->get_servant_manager ();
ACE_UNUSED_ARG (servant_manager);
}
catch (const PortableServer::POA::WrongPolicy& )
{
succeed = true;
}
catch (const CORBA::Exception&)
{
}
if (!succeed)
{
ACE_ERROR ((LM_ERROR,
"(%t) ERROR, get servant manager failed, should give an exception\n"));
}
}
void
test_get_servant_with_no_set (PortableServer::POA_ptr poa)
{
bool succeed = false;
try
{
// Getting the default servant without one set whould give a NoServant
// exception
PortableServer::Servant servant =
poa->get_servant ();
ACE_UNUSED_ARG (servant);
}
catch (const PortableServer::POA::NoServant& )
{
succeed = true;
}
catch (const CORBA::Exception&)
{
}
if (!succeed)
{
ACE_ERROR ((LM_ERROR,
"(%t) ERROR, get servant without one set failed\n"));
}
}
bool
overwrite_servant_manager (PortableServer::POA_ptr poa)
{
bool succeed = false;
try
{
Servant_Locator servant_locator (poa);
// Setting a servant manager after it is already set should give
// obj_adapter with minor code 6
poa->set_servant_manager (&servant_locator);
}
catch (const CORBA::BAD_INV_ORDER& ex)
{
if ((ex.minor() & 0xFFFU) == 6)
{
succeed = true;
}
}
catch (const CORBA::Exception&)
{
}
if (!succeed)
{
ACE_ERROR ((LM_ERROR,
"(%t) ERROR, overwrite servant manager failed\n"));
}
return succeed;
}
bool
set_nil_servant_manager (PortableServer::POA_ptr poa)
{
bool succeed = false;
try
{
// Setting a nil servant manager should give an OBJ_Adapter exception with
// minor code 4
poa->set_servant_manager (PortableServer::ServantManager::_nil());
}
catch (const CORBA::OBJ_ADAPTER& ex)
{
if ((ex.minor() & 0xFFFU) == 4)
{
succeed = true;
}
}
catch (const CORBA::Exception&)
{
}
if (!succeed)
{
ACE_ERROR ((LM_ERROR,
"(%t) ERROR, set nil servant manager failed\n"));
}
return succeed;
}
int
TAO_CosEventChannelFactory_i::init (PortableServer::POA_ptr poa,
const char* child_poa_name,
CosNaming::NamingContext_ptr naming)
{
// Check if we have a parent poa.
if (CORBA::is_nil (poa))
return -1;
this->naming_ = CosNaming::NamingContext::_duplicate (naming);
// Save the naming context.
// Create a UNIQUE_ID and USER_ID policy because we want the POA
// to detect duplicates for us.
PortableServer::IdUniquenessPolicy_var idpolicy =
poa->create_id_uniqueness_policy (PortableServer::UNIQUE_ID);
PortableServer::IdAssignmentPolicy_var assignpolicy =
poa->create_id_assignment_policy (PortableServer::USER_ID);
// Create a PolicyList
CORBA::PolicyList policy_list;
policy_list.length (2);
policy_list [0] =
PortableServer::IdUniquenessPolicy::_duplicate (idpolicy.in ());
policy_list [1] =
PortableServer::IdAssignmentPolicy::_duplicate (assignpolicy.in ());
PortableServer::POAManager_ptr manager =
poa->the_POAManager ();
// @@ Pradeep : TODO - find a way to destroy the policy_list if we return here.
// Create the child POA.
this->poa_ = poa->create_POA (child_poa_name,
manager,
policy_list);
idpolicy->destroy ();
assignpolicy->destroy ();
//this->poa_ = PortableServer::POA::_duplicate (poa);
// uncomment this if we want to use the parent poa for some reason.
return 0;
}
CosNotifyFilter::MappingFilter_ptr
FilterFactoryImpl::create_mapping_filter(const char* constraint_grammar,
const CORBA::Any& default_value)
throw (CosNotifyFilter::InvalidGrammar)
{
FilterFactoryImpl::CREATE_MAPPING_FILTER[1] = constraint_grammar;
if (_tidorb->trace != NULL)
_tidorb->print_trace(TIDorb::util::TR_USER,
"FilterFactoryImpl::crete_mapping_filter");
PortableServer::POA_ptr poa = globalMappingDiscriminatorPOA();
TIDorb::util::StringBuffer buffer_id;
try {
if (PersistenceManager::isActive())
buffer_id << PersistenceManager::getDB()->getUID();
else
buffer_id << "0";
}
catch (const CORBA::Exception& e1) {
if (_tidorb->trace != NULL)
_tidorb->print_trace(TIDorb::util::TR_ERROR,
"FilterFactoryImpl::crete_mapping_filter Persistence Manager failed",
e1);
throw CORBA::INTERNAL("Persistence Manager failed");
}
MappingFilterData* filterData = new MappingFilterData(buffer_id.str().data(),
default_value);
try {
(dynamic_cast<MappingFilterImpl*> (poa->get_servant()))->register_data( filterData );
}
catch (const CORBA::Exception& e) {
}
if (PersistenceManager::isActive()) {
PersistenceManager::getDB()->save_data( filterData );
PersistenceManager::getDB()->update_data(PersistenceDB::ATTR_DISCRIMINATOR,
filterData);
}
return NotifReference::mappingDiscriminatorReference(filterData->poa,
filterData->id);
}
//
// initialize_poa
//
void Tao_Data_Channel_Service::initialize_poa (::PortableServer::POA_ptr poa)
{
// Construct the policy list for the LoggingServerPOA.
::CORBA::PolicyList policies (6);
policies.length (6);
policies[0] = poa->create_thread_policy (PortableServer::ORB_CTRL_MODEL);
policies[1] = poa->create_servant_retention_policy (PortableServer::RETAIN);
policies[2] = poa->create_id_assignment_policy (PortableServer::SYSTEM_ID);
policies[3] = poa->create_id_uniqueness_policy (PortableServer::UNIQUE_ID);
policies[4] = poa->create_lifespan_policy (PortableServer::TRANSIENT);
policies[5] = poa->create_request_processing_policy (PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY);
// Create the child POA for the test logger factory servants.
this->poa_ =
poa->create_POA ("DataChannelPOA",
::PortableServer::POAManager::_nil (),
policies);
for (size_t i = 0; i < 6; ++ i)
policies[i]->destroy ();
// Activate this POA's manager.
PortableServer::POAManager_var the_mgr = this->poa_->the_POAManager ();
the_mgr->activate ();
}
CosNaming::NamingContext_ptr
TAO_Transient_Naming_Context::make_new_context (PortableServer::POA_ptr poa,
const char *poa_id,
size_t context_size)
{
// Put together a servant for the new Naming Context.
TAO_Transient_Naming_Context *context_impl = 0;
ACE_NEW_THROW_EX (context_impl,
TAO_Transient_Naming_Context (poa,
poa_id,
context_size),
CORBA::NO_MEMORY ());
// Put <context_impl> into the auto pointer temporarily, in case next
// allocation fails.
ACE_Auto_Basic_Ptr<TAO_Transient_Naming_Context> temp (context_impl);
TAO_Naming_Context *context = 0;
ACE_NEW_THROW_EX (context,
TAO_Naming_Context (context_impl),
CORBA::NO_MEMORY ());
// Let <implementation> know about it's <interface>.
context_impl->interface (context);
// Release auto pointer, and start using reference counting to
// control our servant.
temp.release ();
PortableServer::ServantBase_var s = context;
// Register the new context with the POA.
#if defined (CORBA_E_MICRO)
PortableServer::ObjectId_var id = poa->activate_object (context);
#else
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId (poa_id);
poa->activate_object_with_id (id.in (), context);
#endif /* CORBA_E_MICRO */
CosNaming::NamingContext_var result = context->_this ();
return result._retn ();
}
CosNotifyFilter::Filter_ptr
FilterFactoryImpl::create_filter(const char* constraint_grammar)
throw (CosNotifyFilter::InvalidGrammar)
{
FilterFactoryImpl::CREATE_FILTER[1] = constraint_grammar;
if (_tidorb->trace != NULL)
_tidorb->print_trace(TIDorb::util::TR_USER,
"FilterFactoryImpl::crete_filter ");
if (strcmp(constraint_grammar, util::parser::TIDParser::_CONSTRAINT_GRAMMAR))
{
throw CosNotifyFilter::InvalidGrammar();
}
PortableServer::POA_ptr poa = globalFilterPOA();
TIDorb::util::StringBuffer buffer_id;
try {
if (PersistenceManager::isActive())
buffer_id << PersistenceManager::getDB()->getUID();
else
buffer_id << "0";
}
catch (const CORBA::Exception& e1) {
if (_tidorb->trace != NULL)
_tidorb->print_trace(TIDorb::util::TR_ERROR,
"FilterFactoryImpl::crete_filter Persistence Manager failed", e1);
throw CORBA::INTERNAL("Persistence Manager failed");
}
FilterData* filterData = new FilterData(buffer_id.str().data(), poa);
try {
(dynamic_cast<FilterImpl*> (poa->get_servant()))->register_data( filterData );
} catch (CORBA::Exception& e) {}
if (PersistenceManager::isActive()) {
(PersistenceManager::getDB())->save_data( filterData );
(PersistenceManager::getDB())->update_data(PersistenceDB::ATTR_DISCRIMINATOR,
filterData);
}
return NotifReference::discriminatorReference(filterData->poa,
filterData->id);
}
/*!
* @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();
}
/*!
* @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();
}