DsLogAdmin::LogIdList*
TAO_Hash_LogStore::list_logs_by_id (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
lock_,
CORBA::INTERNAL ());
DsLogAdmin::LogIdList* list;
// Figure out the length of the list.
CORBA::ULong len = static_cast<CORBA::ULong> (hash_map_.current_size ());
// Allocate the list of <len> length.
ACE_NEW_THROW_EX (list,
DsLogAdmin::LogIdList (len),
CORBA::NO_MEMORY ());
list->length (len);
// Create an iterator
HASHMAP::ITERATOR iter (hash_map_);
// Iterate over and populate the list.
HASHMAP::ENTRY *hash_entry = 0;
for (CORBA::ULong i = 0; i < len; i++)
{
iter.next (hash_entry);
iter.advance ();
(*list)[i] = hash_entry->ext_id_;
}
return list;
}
DsLogAdmin::WeekMask*
TAO_Log_i::get_week_mask (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->get_week_mask ();
}
DsLogAdmin::CapacityAlarmThresholdList*
TAO_Log_i::get_capacity_alarm_thresholds (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->get_capacity_alarm_thresholds ();
}
DsLogAdmin::AvailabilityStatus
TAO_Log_i::get_availability_status (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->get_availability_status_i ();
}
DsLogAdmin::TimeInterval
TAO_Log_i::get_interval (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->get_interval ();
}
DsLogAdmin::AdministrativeState
TAO_Log_i::get_administrative_state (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->get_administrative_state ();
}
DsLogAdmin::LogFullActionType
TAO_Log_i::get_log_full_action (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->get_log_full_action();
}
CORBA::ULongLong
TAO_Log_i::get_n_records (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->get_n_records ();
}
bool
TAO_Hash_LogStore::exists (DsLogAdmin::LogId id)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
lock_,
CORBA::INTERNAL ());
return (this->hash_map_.find (id) == 0);
}
DsLogAdmin::NVList*
TAO_Log_i::get_record_attribute (DsLogAdmin::RecordId id)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->get_record_attribute (id);
}
template <class ITERATOR, class TABLE_ENTRY> CORBA::Boolean
TAO_Bindings_Iterator<ITERATOR, TABLE_ENTRY>::next_one (
CosNaming::Binding_out b)
{
CosNaming::Binding *binding = 0;
// Allocate a binding to be returned (even if there no more
// bindings, we need to allocate an out parameter.)
ACE_NEW_THROW_EX (binding,
CosNaming::Binding,
CORBA::NO_MEMORY ());
b = binding;
// Check to make sure this object is still valid.
if (this->destroyed_)
throw CORBA::OBJECT_NOT_EXIST ();
// If the context we are iterating over has been destroyed,
// self-destruct.
if (context_->destroyed ())
{
destroy ();
throw CORBA::OBJECT_NOT_EXIST ();
}
// If there are no more bindings.
if (hash_iter_->done ())
{
b->binding_type = CosNaming::nobject;
b->binding_name.length (0);
return 0;
}
else
{
ACE_READ_GUARD_THROW_EX (TAO_SYNCH_RW_MUTEX,
ace_mon,
this->context_->lock (),
CORBA::INTERNAL ());
// Return a binding.
TABLE_ENTRY *hash_entry = 0;
hash_iter_->next (hash_entry);
if (populate_binding (hash_entry, *binding) == 0)
throw CORBA::NO_MEMORY ();
hash_iter_->advance ();
return 1;
}
}
DsLogAdmin::RecordList*
TAO_Log_i::retrieve (DsLogAdmin::TimeT from_time,
CORBA::Long how_many,
DsLogAdmin::Iterator_out iter_out)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->retrieve (from_time,
how_many,
iter_out);
}
DsLogAdmin::RecordList*
TAO_Log_i::query (const char *grammar,
const char *constraint,
DsLogAdmin::Iterator_out iter_out)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->query (grammar,
constraint,
iter_out);
}
CORBA::ULong
TAO_Log_i::match (const char* grammar,
const char *constraint)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
const CORBA::ULong count =
this->recordstore_->match (grammar,
constraint);
return count;
}
TAO_LogRecordStore*
TAO_Hash_LogStore::get_log_record_store (DsLogAdmin::LogId id)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
lock_,
CORBA::INTERNAL ());
TAO_Hash_LogRecordStore* recordstore = 0;
if (hash_map_.find (id, recordstore) != 0)
{
return 0;
}
return recordstore;
}
DsLogAdmin::Log_ptr
TAO_Hash_LogStore::find_log (DsLogAdmin::LogId id)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
lock_,
CORBA::INTERNAL ());
if (hash_map_.find (id) != 0)
{
return DsLogAdmin::Log::_nil ();
}
else
{
return logmgr_i_->create_log_reference (id);
}
}
CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq *
TAO_Service_Type_Repository::
list_types (const CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes &which_types)
{
ACE_READ_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());
CORBA::ULong i = 0;
CORBA::ULong length = static_cast<CORBA::ULong> (this->type_map_.current_size ());
CosTrading::ServiceTypeName *types =
CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq::allocbuf (length);
if (types == 0)
return 0;
int all = which_types._d () == CosTradingRepos::ServiceTypeRepository::all;
CosTradingRepos::ServiceTypeRepository::IncarnationNumber num =
which_types.incarnation ();
for (Service_Type_Map_Iterator itr (this->type_map_);
itr.done () == 0;
itr++)
{
Type_Info* type_info = (*itr).int_id_;
const char* type_name = (*itr).ext_id_.in ();
if (all
|| num < type_info->type_struct_.incarnation)
{
CORBA::string_free (types[i]);
types[i++] = CORBA::string_dup (type_name);
}
}
CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq *tmp = 0;
ACE_NEW_RETURN (tmp,
CosTradingRepos::ServiceTypeRepository::
ServiceTypeNameSeq (length,
i,
types,
1),
0);
return tmp;
}
DsLogAdmin::QoSList*
TAO_Log_i::get_log_qos (void)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
// @@ The current revision of the specification (formal/03-07-01)
// states that get_log_qos() returns a list of the QoS properties
// supported by the log, not the current value. However, because
// that is inconsistent with both the Log Service's other get
// methods and the Notification Service's QoS get_qos methods, I
// have submitted a defect report to the OMG for clarification.
// --jtc
return this->recordstore_->get_log_qos ();
}
CosTradingRepos::ServiceTypeRepository::TypeStruct *
TAO_Service_Type_Repository::
describe_type (const char * name)
{
if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
{
throw CosTrading::IllegalServiceType (name);
}
ACE_READ_GUARD_THROW_EX
(ACE_Lock,
ace_mon,
*this->lock_,
CORBA::INTERNAL ());
// Make sure the type exists.
CORBA::String_var type_name (name);
Service_Type_Map::ENTRY *type_entry = 0;
if (this->type_map_.find (type_name,
type_entry) == -1)
throw CosTrading::UnknownServiceType (name);
// Return appropriate information about the type.
CosTradingRepos::ServiceTypeRepository::TypeStruct *descr = 0;
ACE_NEW_RETURN (descr,
CosTradingRepos::ServiceTypeRepository::TypeStruct,
0);
CosTradingRepos::ServiceTypeRepository::TypeStruct &s =
type_entry->int_id_->type_struct_;
descr->if_name = s.if_name;
descr->masked = s.masked;
descr->incarnation = s.incarnation;
descr->super_types = s.super_types;
descr->props = s.props;
/*
CORBA::ULong length = s.props.length ();
CosTradingRepos::ServiceTypeRepository::PropStruct* pstructs =
s.props.get_buffer (0);
descr->props.replace (length, length, pstructs, 0);
*/
return descr;
}
CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq *
TAO_Service_Type_Repository::
list_types (const CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes &which_types)
{
ACE_READ_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());
CORBA::ULong const length = static_cast<CORBA::ULong>(this->type_map_.current_size ());
CORBA::ULong found = 0;
// Initial allocate a result seq for maximum expected results.
CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq_var types;
ACE_NEW_RETURN (types,
CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq(length),
0);
types->length(length);
bool const all = which_types._d () == CosTradingRepos::ServiceTypeRepository::all;
// FIXME: && (which_types.all_ () == true) ?
CosTradingRepos::ServiceTypeRepository::IncarnationNumber num =
which_types.incarnation ();
for (Service_Type_Map_Iterator itr (this->type_map_);
itr.done () == 0;
itr++)
{
Type_Info* type_info = (*itr).int_id_;
const char* type_name = (*itr).ext_id_.in ();
if (all
|| num < type_info->type_struct_.incarnation)
{
(*types)[found++] = CORBA::string_dup (type_name);
}
}
// Truncate to results we have found.
types->length(found);
return types._retn();
}
CosTradingRepos::ServiceTypeRepository::TypeStruct *
TAO_Service_Type_Repository::
fully_describe_type (const char *name)
{
if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
throw CosTrading::IllegalServiceType (name);
ACE_READ_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());
// Make sure the type exists.
CORBA::String_var type_name (name);
Service_Type_Map::ENTRY *type_entry = 0;
if (this->type_map_.find (type_name,
type_entry) == -1)
throw CosTrading::UnknownServiceType (name);
// Return appropriate information about the type.
CosTradingRepos::ServiceTypeRepository::TypeStruct *descr = 0;
ACE_NEW_RETURN (descr,
CosTradingRepos::ServiceTypeRepository::TypeStruct,
0);
CosTradingRepos::ServiceTypeRepository::TypeStruct &s =
type_entry->int_id_->type_struct_;
// Aggregate the Properties of this type and all its supertypes.
// Compute the transitive closure of all supertypes.
this->fully_describe_type_i (s,
descr->props,
descr->super_types);
// We do the explicit copy, since otherwise we'd have excessive
// properties copying.
descr->if_name = s.if_name;
descr->masked = s.masked;
descr->incarnation = s.incarnation;
return descr;
}
DsLogAdmin::RecordList*
TAO_Hash_Iterator_i::get (CORBA::ULong position, CORBA::ULong how_many)
{
ACE_READ_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
if (position < current_position_)
{
throw DsLogAdmin::InvalidParam ();
}
if (how_many == 0)
{
how_many = this->max_rec_list_len_;
}
// Use an Interpreter to build an expression tree.
TAO_Log_Constraint_Interpreter interpreter (constraint_.in ());
// Sequentially iterate over all the records and pick the ones that
// meet the constraints.
// Allocate the list of <how_many> length.
DsLogAdmin::RecordList* rec_list = 0;
ACE_NEW_THROW_EX (rec_list,
DsLogAdmin::RecordList (how_many),
CORBA::NO_MEMORY ());
rec_list->length (how_many);
CORBA::ULong count = 0;
CORBA::ULong current_position = this->current_position_;
for ( ;
((this->iter_ != this->iter_end_) && (count < how_many));
++this->iter_)
{
// Use an evaluator.
TAO_Log_Constraint_Visitor visitor (this->iter_->item ());
// Does it match the constraint?
if (interpreter.evaluate (visitor) == 1)
{
if (++current_position >= position)
{
(*rec_list)[count] = this->iter_->item ();
// copy the log record.
count++;
}
}
}
rec_list->length (count);
this->current_position_ = current_position;
if (count == 0 && this->iter_ == this->iter_end_)
{
// destroy this object..
this->destroy ();
}
return rec_list;
}
template <class ITERATOR, class TABLE_ENTRY> CORBA::Boolean
TAO_Bindings_Iterator<ITERATOR, TABLE_ENTRY>::next_n (
CORBA::ULong how_many,
CosNaming::BindingList_out bl)
{
// We perform an allocation before obtaining the lock so that an out
// parameter is allocated in case we fail to obtain the lock.
ACE_NEW_THROW_EX (bl,
CosNaming::BindingList (0),
CORBA::NO_MEMORY ());
// Check to make sure this object is still valid.
if (this->destroyed_)
throw CORBA::OBJECT_NOT_EXIST ();
// If the context we are iterating over has been destroyed,
// self-destruct.
if (context_->destroyed ())
{
destroy ();
throw CORBA::OBJECT_NOT_EXIST ();
}
// Check for illegal parameter values.
if (how_many == 0)
throw CORBA::BAD_PARAM ();
// If there are no more bindings...
if (hash_iter_->done ())
return 0;
else
{
ACE_READ_GUARD_THROW_EX (TAO_SYNCH_RW_MUTEX,
ace_mon,
this->context_->lock (),
CORBA::INTERNAL ());
// Initially assume that the iterator has the requested number of
// bindings.
bl->length (how_many);
TABLE_ENTRY *hash_entry = 0;
// Iterate and populate the BindingList.
for (CORBA::ULong i = 0; i < how_many; i++)
{
hash_iter_->next (hash_entry);
if (populate_binding (hash_entry, bl[i]) == 0)
throw CORBA::NO_MEMORY ();
if (hash_iter_->advance () == 0)
{
// If no more bindings are left, reset length to the actual
// number of bindings populated, and get out of the loop.
bl->length (i + 1);
break;
}
}
return 1;
}
}
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_READ_GUARD_THROW_EX (TAO_SYNCH_RW_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 ()),
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 ();
}
}
CORBA::Object_ptr
TAO_Hash_Naming_Context::resolve (const CosNaming::Name& n)
{
// Check to make sure this object didn't have <destroy> method
// invoked on it.
if (this->destroyed_)
throw CORBA::OBJECT_NOT_EXIST ();
// Get the length of the name.
CORBA::ULong const name_len = n.length ();
// Check for invalid name.
if (name_len == 0)
throw CosNaming::NamingContext::InvalidName();
// Resolve the first component of the name.
// Stores the binding type for the first name component.
CosNaming::BindingType type;
// Stores the object reference bound to the first name component.
CORBA::Object_var result;
{
ACE_READ_GUARD_THROW_EX (TAO_SYNCH_RW_MUTEX, ace_mon, this->lock_,
CORBA::INTERNAL ());
if (this->context_->find (n[0].id,
n[0].kind,
result.out (),
type) == -1)
throw CosNaming::NamingContext::NotFound
(CosNaming::NamingContext::missing_node, n);
}
// If the name we have to resolve is a compound name, we need to
// resolve it recursively.
if (name_len > 1)
{
CosNaming::NamingContext_var context =
CosNaming::NamingContext::_nil ();
if (type == CosNaming::ncontext)
{
// Narrow to NamingContext.
context = CosNaming::NamingContext::_narrow (result.in ());
}
else
// The first name component wasn't bound to a NamingContext.
throw CosNaming::NamingContext::NotFound(
CosNaming::NamingContext::not_context,
n);
// If narrow failed...
if (CORBA::is_nil (context.in ()))
throw CosNaming::NamingContext::NotFound(
CosNaming::NamingContext::not_context,
n);
else
{
// Successfully resolved the first name component, need to
// recursively call resolve on <n> without the first component.
// We need a name just like <n> but without the first
// component. Instead of copying data we can reuse <n>'s
// buffer since we will only be using it for 'in' parameters
// (no modifications).
CosNaming::Name rest_of_name
(n.maximum () - 1,
n.length () - 1,
const_cast<CosNaming::NameComponent*> (n.get_buffer ())
+ 1);
// If there are any exceptions, they will propagate up.
try
{
CORBA::Object_ptr resolved_ref;
resolved_ref = context->resolve (rest_of_name);
return resolved_ref;
}
catch (const CORBA::SystemException&)
{
throw CosNaming::NamingContext::CannotProceed
(context.in (), rest_of_name);
}
}
}
else
{
ACE_READ_GUARD_THROW_EX (TAO_SYNCH_RW_MUTEX, ace_mon,
this->lock_,
CORBA::INTERNAL ());
if (this->context_->find (n[0].id,
n[0].kind,
result.out (),
type) == -1)
throw CosNaming::NamingContext::NotFound
(CosNaming::NamingContext::missing_node, n);
}
// If the name we had to resolve was simple, we just need to return
// the result.
return result._retn ();
}
