// Operations for CCMObject interface.
void
Connector_Servant_Impl_Base::remove (void)
{
CIAO_TRACE("Connector_Servant_Impl_Base::remove (void)");
try
{
Container_var cnt_safe = Container::_duplicate(this->container_.in ());
PortableServer::POA_var port_poa = cnt_safe->the_port_POA ();
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
mon,
this->lock_,
CORBA::NO_RESOURCES ());
// Removing Facets
for (FacetTable::const_iterator iter =
this->facet_table_.begin ();
iter != this->facet_table_.end ();
++iter)
{
PortableServer::ObjectId_var facet_id =
port_poa->reference_to_id (iter->second);
port_poa->deactivate_object (facet_id);
}
}
this->ccm_remove ();
PortableServer::ObjectId_var oid;
cnt_safe->uninstall_servant (this,
Container_Types::COMPONENT_t,
oid.out ());
if (this->home_servant_)
{
this->home_servant_->update_component_map (oid);
this->home_servant_->_remove_ref ();
this->home_servant_ = 0;
}
}
catch (const CORBA::Exception& ex)
{
// log error and propagate so error gets reported to deployment framework
CIAO_ERROR (1, (LM_ERROR, CLINFO "Connector_Servant_Impl_Base::remove - CORBA exception : %C\n", ex._info ().c_str ()));
ex._raise (); // propagate
}
}
void
Receiver_exec_i::add_shape_to_list (const char* topic, const char* color, CORBA::UShort size,
CORBA::UShort pos_x, CORBA::UShort pos_y)
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, _guard,
this->mutex_, CORBA::INTERNAL ());
CORBA::ULong seq_length = this->shape_info_seq_.length();
this->shape_info_seq_.length(seq_length + 1);
this->shape_info_seq_[seq_length].shape = CORBA::string_dup (topic);
this->shape_info_seq_[seq_length].color = CORBA::string_dup (color);
this->shape_info_seq_[seq_length].size = size;
this->shape_info_seq_[seq_length].posX = pos_x;
this->shape_info_seq_[seq_length].posY = pos_y;
}
template <class SERVANT_TYPE> void
TAO_Notify_ProxySupplier_T<SERVANT_TYPE>::resume_connection (void)
{
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ());
if (this->is_connected () == 0)
throw CosNotifyChannelAdmin::NotConnected ();
if (this->consumer()->is_suspended () == 0)
throw CosNotifyChannelAdmin::ConnectionAlreadyActive ();
}
this->consumer()->resume ();
}
template <class SERVANT_TYPE> void
TAO_Notify_ProxySupplier_T<SERVANT_TYPE>::subscription_change (const CosNotification::EventTypeSeq & added,
const CosNotification::EventTypeSeq & removed)
{
TAO_Notify_EventTypeSeq seq_added (added);
TAO_Notify_EventTypeSeq seq_removed (removed);
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
CORBA::INTERNAL ());
this->subscribed_types_.add_and_remove (seq_added, seq_removed);
}
this->event_manager().subscription_change (this, seq_added, seq_removed);
}
void
UCCTestComponent_exec_i::write_fixed (void)
{
::UCCFixedSizeStruct_Test::UCCFixedSizedStructTestConnector::Writer_var fixed_writer
= this->ciao_context_->get_connection_fixed_size_write_data ();
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, _guard,
this->fixed_mutex_, CORBA::INTERNAL ());
{
for (CORBA::UShort i = 1; i < NR_OF_KEYS + 1; ++i)
{
ACE_DEBUG ((LM_DEBUG, "Write fixed %i\n", i));
fixed_writer->write_one (*(this->fixed_samples_[i]), ::DDS::HANDLE_NIL);
}
}
}
void
UCCTestComponent_exec_i::write_variable (void)
{
::UCCVariableSizedStruct_Test::UCCVariableSizedStructTestConnector::Writer_var var_writer
= this->ciao_context_->get_connection_var_size_write_data ();
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, _guard,
this->var_mutex_, CORBA::INTERNAL ());
{
for (CORBA::UShort i = 1; i < NR_OF_KEYS + 1; ++i)
{
ACE_DEBUG ((LM_DEBUG, "Write variable %C\n", this->var_samples_[i]->symbol.in ()));
var_writer->write_one (*(this->var_samples_[i]), ::DDS::HANDLE_NIL);
}
}
}
CORBA::Boolean
TAO_CEC_ProxyPushSupplier::consumer_non_existent (
CORBA::Boolean_out disconnected)
{
CORBA::Object_var consumer;
{
ACE_GUARD_THROW_EX (
ACE_Lock, ace_mon, *this->lock_,
CORBA::INTERNAL ());
disconnected = 0;
if (this->is_connected_i () == 0)
{
disconnected = 1;
return 0;
}
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
if (this->is_typed_ec () )
{
if (CORBA::is_nil (this->nopolicy_typed_consumer_.in ()))
{
return 0;
}
consumer = CORBA::Object::_duplicate
(this->nopolicy_typed_consumer_.in ());
}
else
{
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
if (CORBA::is_nil (this->nopolicy_consumer_.in ()))
{
return 0;
}
consumer = CORBA::Object::_duplicate (this->nopolicy_consumer_.in ());
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
} /* ! this->is_typed_ec */
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
}
#if (TAO_HAS_MINIMUM_CORBA == 0)
return consumer->_non_existent ();
#else
return 0;
#endif /* TAO_HAS_MINIMUM_CORBA */
}
void
UCCTestComponent_exec_i::create_fixed_sized_samples (void)
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, _guard,
this->fixed_mutex_, CORBA::INTERNAL ());
ACE_DEBUG ((LM_DEBUG, "Component_exec_i::create_fixed_sized_samples - "
"Create fixed sized samples.\n"));
for (::CORBA::UShort i = 1; i < NR_OF_KEYS + 1; ++i)
{
UCCFixedSizedStructTest_i* new_key = new UCCFixedSizedStructTest_i;
new_key->x = i;
new_key->y = new_key->x;
new_key->z = 2*i;
this->fixed_samples_[i] = new_key;
}
}
void
TAO_Notify_ProxySupplier::connect (TAO_Notify_Consumer *consumer)
{
// Adopt the consumer
TAO_Notify_Consumer::Ptr auto_consumer (consumer);
TAO_Notify_Atomic_Property_Long& consumer_count = this->admin_properties().consumers ();
const TAO_Notify_Property_Long& max_consumers = this->admin_properties().max_consumers ();
if (max_consumers != 0 && consumer_count >= max_consumers.value ())
{
throw CORBA::IMP_LIMIT (); // we've reached the limit of consumers connected.
}
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
CORBA::INTERNAL ());
// if consumer is set and reconnect not allowed we get out.
if (this->is_connected () && TAO_Notify_PROPERTIES::instance()->allow_reconnect() == false)
{
throw CosEventChannelAdmin::AlreadyConnected ();
}
// Adopt the consumer
if (this->consumer_.get() != 0)
auto_consumer->assume_pending_events (*this->consumer_.get ());
this->consumer_ = auto_consumer;
this->consumer_admin_->subscribed_types (this->subscribed_types_); // get the parents subscribed types.
}
// Inform QoS values.
ACE_ASSERT (this->consumer_.get() != 0);
this->consumer_->qos_changed (this->qos_properties_);
TAO_Notify_EventTypeSeq removed;
this->event_manager().subscription_change (this, this->subscribed_types_, removed);
this->event_manager().connect (this);
// Increment the global consumer count
++consumer_count;
}
void
UCCTestComponent_exec_i::create_variable_sized_samples (void)
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, _guard,
this->var_mutex_, CORBA::INTERNAL ());
ACE_DEBUG ((LM_DEBUG, "Component_exec_i::create_variable_sized_samples - "
"Create variable sized samples\n"));
for (::CORBA::UShort i = 1; i < NR_OF_KEYS + 1; ++i)
{
UCCVariableSizedStructTest_i* new_key = new UCCVariableSizedStructTest_i;
char key[7];
ACE_OS::sprintf (key, "KEY_%d", i);
new_key->symbol = CORBA::string_dup (key);
new_key->x = i;
new_key->y = new_key->x;
this->var_samples_[i] = new_key;
}
}
void
Sender_exec_i::ccm_activate (void)
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, _guard,
this->mutex_, CORBA::INTERNAL ());
for (CORBA::UShort i = 1; i < this->keys_ + 1; ++i)
{
char key[7];
UnkeyedTest *new_key = new UnkeyedTest;
ACE_OS::sprintf (key, "KEY_%d", i);
new_key->key = CORBA::string_dup(key);
new_key->iteration = 0;
this->ktests_[key] = new_key;
}
this->last_key = this->ktests_.begin ();
}
void
TAO_EC_ProxyPushSupplier::push (const RtecEventComm::EventSet& event,
TAO_EC_QOS_Info& qos_info)
{
// The mutex is already held by the caller (usually the filter()
// method)
if (!this->is_connected_i ())
return; // TAO_THROW (RtecEventComm::Disconnected ());????
if (this->suspended_)
return;
TAO_ESF_RefCount_Guard<CORBA::ULong> ace_mon (this->refcount_);
// The guard will decrement the reference count, notice that the
// reference count can become 0, but this is not the right spot to
// check for that and destroy the object.
// If we did so then we would destroy the object, and consequently
// the mutex, but the mutex is used later when the stack unwinds and
// the filter() method tries to destroy the mutex (that originally
// acquired the mutex in the first place).
// So the correct thing to do is to just decrement the reference
// count and let the filter() method do the destruction.
RtecEventComm::PushConsumer_var consumer =
RtecEventComm::PushConsumer::_duplicate (this->consumer_.in ());
this->pre_dispatch_hook (const_cast<RtecEventComm::EventSet&> (event));
{
// We have to release the lock to avoid dead-locks.
TAO_EC_Unlock reverse_lock (*this->lock_);
ACE_GUARD_THROW_EX (TAO_EC_Unlock, ace_mon, reverse_lock,
RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
this->event_channel_->dispatching ()->push (this,
consumer.in (),
event,
qos_info);
}
if (this->child_ != 0)
this->child_->clear ();
}
CosNotifyFilter::FilterID
TAO_Notify_FilterAdmin::add_filter (CosNotifyFilter::Filter_ptr new_filter)
{
if (CORBA::is_nil (new_filter))
throw CORBA::BAD_PARAM ();
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
CORBA::INTERNAL ());
CosNotifyFilter::FilterID new_id = this->filter_ids_.id ();
CosNotifyFilter::Filter_var new_filter_var =
CosNotifyFilter::Filter::_duplicate (new_filter);
if (this->filter_list_.bind (new_id, new_filter_var) == -1)
throw CORBA::INTERNAL ();
else
return new_id;
}
void
TAO_Notify_SupplierAdmin::offer_change (const CosNotification::EventTypeSeq & added,
const CosNotification::EventTypeSeq & removed)
{
TAO_Notify_EventTypeSeq seq_added (added);
TAO_Notify_EventTypeSeq seq_removed (removed);
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
CORBA::INTERNAL ());
this->subscribed_types_.add_and_remove (seq_added, seq_removed);
TAO_Notify_Subscription_Change_Worker worker (added, removed);
this->proxy_container().collection ()->for_each (&worker);
}
}
template<class PROXY, class C, class I,ACE_SYNCH_DECL> void
TAO_ESF_Delayed_Changes<PROXY,C,I,ACE_SYNCH_USE>::shutdown (void)
{
ACE_GUARD_THROW_EX (ACE_SYNCH_MUTEX_T, ace_mon, this->busy_lock_,
CORBA::INTERNAL ());
if (this->busy_count_ == 0)
{
// We can shutdown the object immediately
this->shutdown_i ();
}
else
{
ACE_Command_Base* command;
ACE_NEW (command,
Shutdown_Command (this));
this->command_queue_.enqueue_tail (command);
this->write_delay_count_++;
}
}
void
TAO_EC_Default_ProxyPushSupplier::disconnect_push_supplier ()
{
RtecEventComm::PushConsumer_var consumer;
int connected = 0;
{
ACE_GUARD_THROW_EX (
ACE_Lock, ace_mon, *this->lock_,
CORBA::INTERNAL ());
// @@ RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
connected = this->is_connected_i ();
consumer = this->consumer_._retn ();
if (connected)
this->cleanup_i ();
}
// Notify the event channel....
this->event_channel_->disconnected (this);
if (!connected)
{
return;
}
if (this->event_channel_->disconnect_callbacks ())
{
try
{
consumer->disconnect_push_consumer ();
}
catch (const CORBA::Exception& ex)
{
// Ignore exceptions, we must isolate other clients from
// problems on this one.
ex._tao_print_exception ("ProxySupplier::disconnect_push_supplier");
}
}
}
int
TAO_EC_ProxyPushSupplier::filter_nocopy (RtecEventComm::EventSet& event,
TAO_EC_QOS_Info& qos_info)
{
Destroy_Guard auto_destroy (this->refcount_,
this->event_channel_,
this);
int result = 0;
{
ACE_GUARD_THROW_EX (
ACE_Lock, ace_mon, *this->lock_,
RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
if (this->is_connected_i ())
{
result = this->child_->filter_nocopy (event, qos_info);
}
}
return result;
}
void
TAO_Notify_ProxySupplier::init (TAO_Notify_ConsumerAdmin* consumer_admin)
{
ACE_ASSERT (consumer_admin != 0 && this->consumer_admin_.get() == 0);
TAO_Notify_Proxy::initialize (consumer_admin);
this->consumer_admin_.reset (consumer_admin);
this->filter_admin_.event_channel (
this->consumer_admin_->event_channel());
const CosNotification::QoSProperties &default_ps_qos =
TAO_Notify_PROPERTIES::instance ()->default_proxy_supplier_qos_properties ();
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
CORBA::INTERNAL ());
this->TAO_Notify_Object::set_qos (default_ps_qos);
}
}
/// Protected operations.
void
Connector_Servant_Impl_Base::add_facet (
const char *port_name,
::CORBA::Object_ptr port_ref)
{
CIAO_TRACE("Connector_Servant_Impl_Base::add_facet");
if (0 == port_name || ::CORBA::is_nil (port_ref))
{
throw ::CORBA::BAD_PARAM ();
}
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
mon,
this->lock_,
CORBA::NO_RESOURCES ());
this->facet_table_[port_name] = ::CORBA::Object::_duplicate (port_ref);
}
}
void
Sender_exec_i::get_started (void)
{
this->ready_to_start_ = true;
this->start ();
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, _guard,
this->mutex_, CORBA::INTERNAL ());
for (CORBA::UShort i = 1; i < this->keys_ + 1; ++i)
{
char key[7];
KeyedTest *new_key = new KeyedTest;
ACE_OS::sprintf (key, "KEY_%d", i);
new_key->key = CORBA::string_dup(key);
new_key->iteration = 0;
this->ktests_[key] = new_key;
}
this->last_key_ = this->ktests_.begin ();
}
void
TAO_CEC_ProxyPushSupplier::push_to_consumer (const CORBA::Any& event)
{
CosEventComm::PushConsumer_var consumer;
{
ACE_GUARD_THROW_EX (
ACE_Lock, ace_mon, *this->lock_,
CORBA::INTERNAL ());
// @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
if (this->is_connected_i () == 0)
return; // ACE_THROW (CosEventComm::Disconnected ());????
consumer =
CosEventComm::PushConsumer::_duplicate (this->consumer_.in ());
}
TAO_CEC_ConsumerControl *control =
this->event_channel_->consumer_control ();
try
{
consumer->push (event);
// Inform the control that we were able to push something
control->successful_transmission(this);
}
catch (const CORBA::OBJECT_NOT_EXIST&)
{
control->consumer_not_exist (this);
}
catch (CORBA::SystemException& sysex)
{
control->system_exception (this,
sysex);
}
catch (const CORBA::Exception&)
{
// Shouldn't happen, but does not hurt
}
}
RTCORBA::Mutex_ptr
TAO_Named_RT_Mutex_Manager::open_named_mutex (const char *name)
{
#if (TAO_HAS_NAMED_RT_MUTEXES == 1)
// The following should be atomic.
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
monitor,
this->lock_,
CORBA::INTERNAL ());
// If we find the mutex, simply return it.
RTCORBA::Mutex_var mutex;
if (this->map_.find (name, mutex) != 0)
throw RTCORBA::RTORB::MutexNotFound ();
// Return the one we found.
return mutex._retn ();
#else /* TAO_HAS_NAMED_RT_MUTEXES */
ACE_UNUSED_ARG (name);
throw ::CORBA::NO_IMPLEMENT ();
#endif /* TAO_HAS_NAMED_RT_MUTEXES */
}
template<class PROXY, class C, class I,ACE_SYNCH_DECL> void
TAO_ESF_Delayed_Changes<PROXY,C,I,ACE_SYNCH_USE>::
disconnected (PROXY *proxy)
{
ACE_GUARD_THROW_EX (ACE_SYNCH_MUTEX_T, ace_mon, this->busy_lock_,
CORBA::INTERNAL ());
if (this->busy_count_ == 0)
{
// We can remove the object immediately
this->disconnected_i (proxy);
}
else
{
ACE_Command_Base* command;
ACE_NEW (command,
Disconnected_Command (this,
proxy));
this->command_queue_.enqueue_tail (command);
this->write_delay_count_++;
}
}
void
TAO_CEC_ProxyPullSupplier::disconnect_pull_supplier ()
{
CosEventComm::PullConsumer_var consumer;
{
ACE_GUARD_THROW_EX (
ACE_Lock, ace_mon, *this->lock_,
CORBA::INTERNAL ());
// @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
if (this->is_connected_i () == 0)
throw CORBA::BAD_INV_ORDER ();
consumer = this->consumer_._retn ();
this->cleanup_i ();
}
// Notify the event channel....
this->event_channel_->disconnected (this);
if (CORBA::is_nil (consumer.in ()))
return;
if (this->event_channel_->disconnect_callbacks ())
{
try
{
consumer->disconnect_pull_consumer ();
}
catch (const CORBA::Exception& ex)
{
// Ignore exceptions, we must isolate other clients from
// problems on this one.
ex._tao_print_exception ("ProxySupplier::disconnect_pull_supplier");
}
}
}
::Components::ConsumerDescription *
Servant_Impl_Base::lookup_consumer_description (
const char *port_name)
{
CIAO_TRACE("Servant_Impl_Base::lookup_consumer_description");
if (0 == port_name)
{
/// Calling function will throw InvalidName after getting this.
return 0;
}
::Components::ConsumerDescription_var cd;
ConsumerTable::const_iterator iter;
{
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
mon,
this->lock_,
CORBA::NO_RESOURCES ());
iter = this->consumer_table_.find (port_name);
if (iter != this->consumer_table_.end ())
{
::Components::ConsumerDescription *cdp = 0;
ACE_NEW_THROW_EX (cdp,
::OBV_Components::ConsumerDescription,
CORBA::NO_MEMORY ());
cdp->name (iter->first.c_str ());
cdp->type_id (iter->second->_interface_repository_id ());
cdp->consumer (iter->second);
cd = cdp;
}
}
return cd._retn ();
}
void
TAO_CEC_ProxyPushConsumer::disconnect_push_consumer ()
{
CosEventComm::PushSupplier_var supplier;
{
ACE_GUARD_THROW_EX (
ACE_Lock, ace_mon, *this->lock_,
CORBA::INTERNAL ());
// @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
if (!this->is_connected_i ())
throw CORBA::BAD_INV_ORDER (); // @@ add user exception?
supplier = this->supplier_._retn ();
this->cleanup_i ();
}
// Notify the event channel...
this->event_channel_->disconnected (this);
if (CORBA::is_nil (supplier.in ()))
return;
if (this->event_channel_->disconnect_callbacks ())
{
try
{
supplier->disconnect_push_supplier ();
}
catch (const CORBA::Exception&)
{
// Ignore exceptions, we must isolate other clients from
// failures on this one.
}
}
}
void
TAO_EC_ProxyPushConsumer::shutdown (void)
{
RtecEventComm::PushSupplier_var supplier;
{
ACE_GUARD_THROW_EX (
ACE_Lock, ace_mon, *this->lock_,
RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
supplier = this->supplier_._retn ();
this->connected_ = false;
this->shutdown_hook ();
if (this->filter_ != 0)
{
this->filter_->shutdown ();
this->cleanup_i ();
}
}
this->deactivate ();
if (CORBA::is_nil (supplier.in ()))
return;
try
{
supplier->disconnect_push_supplier ();
}
catch (const CORBA::Exception&)
{
// Ignore exceptions, we must isolate other clients from
// failures on this one.
}
}
CORBA::Object_ptr
Connector_Servant_Impl_Base::lookup_facet (const char *port_name)
{
CIAO_TRACE("Connector_Servant_Impl_Base::lookup_facet");
if (!port_name)
{
return CORBA::Object::_nil ();
}
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
mon,
this->lock_,
CORBA::NO_RESOURCES ());
FacetTable::const_iterator iter = this->facet_table_.find (port_name);
if (iter == this->facet_table_.end ())
{
return CORBA::Object::_nil ();
}
return CORBA::Object::_duplicate (iter->second);
}
void
TAO_Named_RT_Mutex_Manager::destroy_mutex (RTCORBA::Mutex_ptr mutex)
{
TAO_RT_Mutex *tao_mutex =
dynamic_cast<TAO_RT_Mutex *> (mutex);
// If this mutex is named, then we need to remove it from our table.
// Otherwise, we don't have to do anything.
const char *name = tao_mutex->name ();
if (name != 0)
{
// The following should be atomic.
ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
monitor,
this->lock_,
CORBA::INTERNAL ());
int result =
this->map_.unbind (name);
if (result != 0)
throw ::CORBA::INTERNAL ();
}
}
void
TAO_Transient_Naming_Context::list (CORBA::ULong how_many,
CosNaming::BindingList_out &bl,
CosNaming::BindingIterator_out &bi)
{
// Allocate nil out parameters in case we won't be able to complete
// the operation.
bi = CosNaming::BindingIterator::_nil ();
ACE_NEW_THROW_EX (bl,
CosNaming::BindingList (0),
CORBA::NO_MEMORY ());
// Obtain a lock before we proceed with the operation.
ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX,
ace_mon,
this->lock_,
CORBA::INTERNAL ());
// Check to make sure this object didn't have <destroy> method
// invoked on it.
if (this->destroyed_)
throw CORBA::OBJECT_NOT_EXIST ();
// Dynamically allocate iterator for traversing the underlying hash map.
HASH_MAP::ITERATOR *hash_iter = 0;
ACE_NEW_THROW_EX (hash_iter,
HASH_MAP::ITERATOR (transient_context_->map ()),
CORBA::NO_MEMORY ());
// Store <hash_iter temporarily in auto pointer, in case we'll have
// some failures and throw an exception.
ACE_Auto_Basic_Ptr<HASH_MAP::ITERATOR> temp (hash_iter);
// Silliness below is required because of broken old g++!!! E.g.,
// without it, we could have just said HASH_MAP::ITERATOR everywhere we use ITER_DEF.
typedef ACE_Hash_Map_Manager<TAO_ExtId, TAO_IntId, ACE_Null_Mutex>::ITERATOR ITER_DEF;
typedef ACE_Hash_Map_Manager<TAO_ExtId, TAO_IntId, ACE_Null_Mutex>::ENTRY ENTRY_DEF;
// Typedef to the type of BindingIterator servant for ease of use.
typedef TAO_Bindings_Iterator<ITER_DEF, ENTRY_DEF>
ITER_SERVANT;
// A pointer to BindingIterator servant.
ITER_SERVANT *bind_iter = 0;
// Number of bindings that will go into the BindingList <bl>.
CORBA::ULong n = 0;
// Calculate number of bindings that will go into <bl>.
if (this->context_->current_size () > how_many)
n = how_many;
else
n = static_cast<CORBA::ULong> (this->context_->current_size ());
// Use the hash map iterator to populate <bl> with bindings.
bl->length (n);
ENTRY_DEF *hash_entry = 0;
for (CORBA::ULong i = 0; i < n; i++)
{
hash_iter->next (hash_entry);
hash_iter->advance ();
if (ITER_SERVANT::populate_binding (hash_entry, bl[i]) == 0)
throw CORBA::NO_MEMORY();
}
// Now we are done with the BindingsList, and we can follow up on
// the BindingIterator business.
// If we do not need to pass back BindingIterator.
if (this->context_->current_size () <= how_many)
return;
else
{
// Create a BindingIterator for return.
ACE_NEW_THROW_EX (bind_iter,
ITER_SERVANT (this, hash_iter, this->poa_.in (), this->lock_),
CORBA::NO_MEMORY ());
// Release <hash_iter> from auto pointer, and start using
// reference counting to control our servant.
temp.release ();
PortableServer::ServantBase_var iter = bind_iter;
// Increment reference count on this Naming Context, so it doesn't get
// deleted before the BindingIterator servant gets deleted.
interface_->_add_ref ();
// Register with the POA.
char poa_id[BUFSIZ];
ACE_OS::sprintf (poa_id,
"%s_%d",
this->poa_id_.c_str (),
this->counter_++);
#if defined (CORBA_E_MICRO)
PortableServer::ObjectId_var id =
this->poa_->activate_object (bind_iter);
#else
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId (poa_id);
this->poa_->activate_object_with_id (id.in (), bind_iter);
#endif /* CORBA_E_MICRO */
bi = bind_iter->_this ();
}
}