TAO_PG_GenericFactory Class Reference

PortableGroup::GenericFactory implementation used by the load balancer when creating object groups. More...

#include <PG_GenericFactory.h>

Inheritance diagram for TAO_PG_GenericFactory:

[legend]Collaboration diagram for TAO_PG_GenericFactory:

[legend]List of all members.

Public Member Functions
	TAO_PG_GenericFactory (TAO_PG_ObjectGroupManager &object_group_map, TAO_PG_PropertyManager &property_manager)
	Constructor.
	~TAO_PG_GenericFactory (void)
	Destructor.
void	poa (PortableServer::POA_ptr p)
	Set the POA to use when creating object references.
void	delete_object_i (TAO_PG_Factory_Set &factory_set, CORBA::Boolean ignore_exceptions)
void	delete_member (CORBA::ULong group_id, const PortableGroup::Location &location)
void	check_minimum_number_members (PortableGroup::ObjectGroup_ptr object_group, CORBA::ULong group_id, const char *type_id)
	Verify that the MinimumNumberMembers criterion is satisfied.
PortableGroup::GenericFactory::FactoryCreationId *	create_member (PortableGroup::ObjectGroup_ptr object_group, const PortableGroup::FactoryInfo &factory_info, const char *type_id, const CORBA::Boolean propagate_member_already_present) throw (CORBA::SystemException, PortableGroup::NoFactory, PortableGroup::ObjectNotCreated, PortableGroup::InvalidCriteria, PortableGroup::InvalidProperty, PortableGroup::CannotMeetCriteria, PortableGroup::MemberAlreadyPresent)
TAO_LoadBalancer::GenericFactory methods
virtual CORBA::Object_ptr	create_object (const char *type_id, const PortableGroup::Criteria &the_criteria, PortableGroup::GenericFactory::FactoryCreationId_out factory_creation_id) throw (CORBA::SystemException, PortableGroup::NoFactory, PortableGroup::ObjectNotCreated, PortableGroup::InvalidCriteria, PortableGroup::InvalidProperty, PortableGroup::CannotMeetCriteria)
virtual void	delete_object (const PortableGroup::GenericFactory::FactoryCreationId &factory_creation_id) throw (CORBA::SystemException, PortableGroup::ObjectNotFound)
Private Member Functions
void	populate_object_group (PortableGroup::ObjectGroup_ptr object_group, const char *type_id, const PortableGroup::FactoryInfos &factory_infos, PortableGroup::InitialNumberMembersValue initial_number_members, TAO_PG_Factory_Set &factory_set)
void	get_ObjectId (CORBA::ULong fcid, PortableServer::ObjectId_out oid)
	Get a new ObjectId to be used when creating a new ObjectGroup.
void	process_criteria (const char *type_id, const PortableGroup::Criteria &criteria, PortableGroup::MembershipStyleValue &membership_style, PortableGroup::FactoriesValue &factory_infos, PortableGroup::InitialNumberMembersValue &initial_number_members, PortableGroup::MinimumNumberMembersValue &minimum_number_members)
Private Attributes
PortableServer::POA_var	poa_
	Reference to the POA used to create object group references.
TAO_PG_ObjectGroupManager &	object_group_manager_
	Reference to the ObjectGroup map.
TAO_PG_PropertyManager &	property_manager_
	Reference to the PropertyManager.
TAO_PG_Factory_Map	factory_map_
	Table that maps FactoryCreationId to TAO_PG_Factory_Set.
CORBA::ULong	next_fcid_
TAO_SYNCH_MUTEX	lock_

---

Detailed Description

PortableGroup::GenericFactory implementation used by the load balancer when creating object groups.

This GenericFactory creates an object group reference for given set of replicas. Those replicas will be created by this GenericFactory if the "infrastructure-controlled" membership style is configured.

Definition at line 50 of file PG_GenericFactory.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_PG_GenericFactory::TAO_PG_GenericFactory (  TAO_PG_ObjectGroupManager &  object_group_map, TAO_PG_PropertyManager &  property_manager )

Constructor. Definition at line 19 of file PG_GenericFactory.cpp. References TAO_PG_ObjectGroupManager::generic_factory(), object_group_manager_, and TAO_PG_MAX_OBJECT_GROUPS. : poa_ (), object_group_manager_ (object_group_manager), property_manager_ (property_manager), factory_map_ (TAO_PG_MAX_OBJECT_GROUPS), next_fcid_ (0), lock_ () { this->object_group_manager_.generic_factory (this); }

TAO_PG_GenericFactory::~TAO_PG_GenericFactory (  void   )

Destructor. Definition at line 32 of file PG_GenericFactory.cpp. References ACE_CATCHANY, ACE_DECLARE_NEW_CORBA_ENV, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_TRY, ACE_TRY_CHECK, delete_object_i(), factory_map_, and TAO_PG_Factory_Set. { ACE_DECLARE_NEW_CORBA_ENV; TAO_PG_Factory_Map::iterator end = this->factory_map_.end (); for (TAO_PG_Factory_Map::iterator i = this->factory_map_.begin (); i != end; ++i) { TAO_PG_Factory_Set & factory_set = (*i).int_id_; ACE_TRY { this->delete_object_i (factory_set, 1 /* Ignore exceptions */ ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { // Ignore all exceptions. } ACE_ENDTRY; } (void) this->factory_map_.close (); }

---

Member Function Documentation

void TAO_PG_GenericFactory::check_minimum_number_members (  PortableGroup::ObjectGroup_ptr  object_group, CORBA::ULong  group_id, const char *  type_id )

Verify that the MinimumNumberMembers criterion is satisfied. If the current number of members in the given object group is less than the MinimumNumberMembers criterion in effect for that group, the infrastructure will attempt create and add more members to the group by invoking any unused application-supplied GenericFactorys. Definition at line 593 of file PG_GenericFactory.cpp. References ACE_CATCH, ACE_CHECK, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_THROW, ACE_TRY, ACE_TRY_CHECK, create_member(), TAO_PG_Factory_Node::factory_creation_id, TAO_PG_Factory_Node::factory_info, factory_map_, PortableGroup::GenericFactory::FactoryCreationId, TAO_PG_PropertyManager::get_properties(), TAO_PG::get_property_value(), TAO_PG_ObjectGroupManager::member_count(), PortableGroup::MinimumNumberMembersValue, object_group_manager_, property_manager_, ACE_Array_Base< T >::size(), CORBA::string_dup(), TAO_PG_Factory_Set, and PortableGroup::Value. { // Check if we've dropped below the MinimumNumberMembers threshold. // If so, attempt to create enough new members to fill the gap. // If no entry exists in the factory map, infrastructure (this // GenericFactory implementation) controlled membership was not // used. TAO_PG_Factory_Map::ENTRY *entry = 0; if (this->factory_map_.find (group_id, entry) != 0) return; TAO_PG_Factory_Set & factory_set = entry->int_id_; PortableGroup::Properties_var props = this->property_manager_.get_properties (object_group ACE_ENV_ARG_PARAMETER); ACE_CHECK; PortableGroup::Name name (1); name.length (1); PortableGroup::Value value; // MinimumNumberMembers name[0].id = CORBA::string_dup ("org.omg.PortableGroup.MinimumNumberMembers"); PortableGroup::MinimumNumberMembersValue minimum_number_members; if (TAO_PG::get_property_value (name, props.in (), value)) { if (!(value >>= minimum_number_members)) { // This only occurs if extraction of the actual value from // the Any fails. It shouldn't fail at this point. ACE_THROW (CORBA::INTERNAL ()); } const CORBA::ULong count = this->object_group_manager_.member_count (object_group ACE_ENV_ARG_PARAMETER); ACE_CHECK; if (count >= static_cast<CORBA::ULong> (minimum_number_members)) return; const CORBA::ULong gap = static_cast<CORBA::ULong> (minimum_number_members) - count; CORBA::ULong creation_count = 0; const size_t len = factory_set.size (); static const PortableGroup::GenericFactory::FactoryCreationId * nil_fcid = 0; for (size_t i = 0; i < len; ++i) { TAO_PG_Factory_Node & node = factory_set[i]; PortableGroup::GenericFactory::FactoryCreationId * const tmp_fcid = node.factory_creation_id; // Check if the application supplied GenericFactory was // already invoked. if (tmp_fcid != nil_fcid) continue; ACE_TRY { const CORBA::Boolean propagate_member_already_present = 1; node.factory_creation_id = this->create_member (object_group, node.factory_info, type_id, propagate_member_already_present ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ++creation_count; // Check if the MinimumNumberMembers threshold gap has // been filled. if (gap == creation_count) return; } ACE_CATCH (PortableGroup::MemberAlreadyPresent, ex) { // Ignore this exception and continue. } ACE_ENDTRY; ACE_CHECK; } // @todo If we get this far, and the MinimumNumberMembers // threshold gap hasn't been filled, what do we do? Throw // a CORBA::TRANSIENT? } }

PortableGroup::GenericFactory::FactoryCreationId * TAO_PG_GenericFactory::create_member (  PortableGroup::ObjectGroup_ptr  object_group, const PortableGroup::FactoryInfo &  factory_info, const char *  type_id, const CORBA::Boolean  propagate_member_already_present )  throw (CORBA::SystemException, PortableGroup::NoFactory, PortableGroup::ObjectNotCreated, PortableGroup::InvalidCriteria, PortableGroup::InvalidProperty, PortableGroup::CannotMeetCriteria, PortableGroup::MemberAlreadyPresent)

Note: This method is only used by the infrastructure. Definition at line 700 of file PG_GenericFactory.cpp. References ACE_CATCHANY, ACE_CHECK_RETURN, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_RE_THROW, ACE_TRY, ACE_TRY_CHECK, ACE_TRY_THROW, and CORBA::is_nil(). Referenced by check_minimum_number_members(), and populate_object_group(). { PortableGroup::GenericFactory::FactoryCreationId_var fcid; CORBA::Object_var member = factory_info.the_factory->create_object (type_id, factory_info.the_criteria, fcid.out () ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); ACE_TRY { // @@ Should an "_is_a()" be performed here? While it // appears to be the right thing to do, it can be // expensive. // // Make sure an Object of the correct type was created. // It is possible that an object of the wrong type was // created if the type_id parameter does not match the // type of object the GenericFactory creates. CORBA::Boolean right_type_id = member->_is_a (type_id ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // @todo Strategize this -- e.g. strict type checking. if (!right_type_id) { // An Object of incorrect type was created. Delete // it, and throw a NoFactory exception. factory_info.the_factory->delete_object (fcid.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_TRY_THROW (PortableGroup::NoFactory (factory_info.the_location, type_id)); } this->object_group_manager_._tao_add_member ( object_group, factory_info.the_location, member.in (), type_id, propagate_member_already_present ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { // If the member reference is not nil, then the factory // was successfully invoked. Since an exception was // thrown, clean up the up created member. if (!CORBA::is_nil (member.in ())) { factory_info.the_factory->delete_object (fcid.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_RE_THROW; } ACE_ENDTRY; ACE_CHECK_RETURN (0); return fcid._retn (); }

CORBA::Object_ptr TAO_PG_GenericFactory::create_object (  const char *  type_id, const PortableGroup::Criteria &  the_criteria, PortableGroup::GenericFactory::FactoryCreationId_out  factory_creation_id )  throw (CORBA::SystemException, PortableGroup::NoFactory, PortableGroup::ObjectNotCreated, PortableGroup::InvalidCriteria, PortableGroup::InvalidProperty, PortableGroup::CannotMeetCriteria) [virtual]

Create an object of the specified type that adheres to the restrictions defined by the provided Criteria. The out FactoryCreationId parameter may be passed to the delete_object() method to delete the object. Definition at line 61 of file PG_GenericFactory.cpp. References ACE_CATCHANY, ACE_CHECK_RETURN, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_GUARD_RETURN, ACE_NEW_THROW_EX, ACE_RE_THROW, ACE_THROW_RETURN, ACE_TRY, ACE_TRY_CHECK, ACE_TRY_THROW, PortableGroup::Criteria, PortableGroup::FactoriesValue, PortableGroup::GenericFactory::FactoryCreationId, PortableGroup::InitialNumberMembersValue, PortableGroup::MembershipStyleValue, PortableGroup::MinimumNumberMembersValue, TAO_PG_Factory_Set, TAO_PG_INITIAL_NUMBER_MEMBERS, TAO_PG_MEMBERSHIP_STYLE, TAO_PG_MINIMUM_NUMBER_MEMBERS, and TAO_SYNCH_MUTEX. { PortableGroup::Properties_var properties = this->property_manager_.get_type_properties (type_id ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); PortableGroup::MembershipStyleValue membership_style = TAO_PG_MEMBERSHIP_STYLE; PortableGroup::FactoriesValue factory_infos(0); PortableGroup::InitialNumberMembersValue initial_number_members = TAO_PG_INITIAL_NUMBER_MEMBERS; PortableGroup::MinimumNumberMembersValue minimum_number_members = TAO_PG_MINIMUM_NUMBER_MEMBERS; // Make sure the criteria for the object group being created are // valid. this->process_criteria (type_id, the_criteria, membership_style, factory_infos, initial_number_members, minimum_number_members ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); CORBA::ULong fcid = 0; { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->lock_, CORBA::Object::_nil ()); // Start out with an initial value. fcid = this->next_fcid_; // Loop until a free FactoryCreationId is found, being careful to // search through the range of FactoryCreationIds only once. while (this->factory_map_.find (this->next_fcid_) == 0) { this->next_fcid_++; // If this is true, then no FactoryCreationIds are available. // This is highly unlikely since TAO implements a // FactoryCreationId as a 32 bit unsigned integer, meaning // that over 4 billion object groups are being managed by this // generic factory! if (this->next_fcid_ == fcid) ACE_THROW_RETURN (PortableGroup::ObjectNotCreated (), CORBA::Object::_nil ()); } // Just in case this->next_fcid_ was modified in the above search, // reassign the value. fcid = this->next_fcid_; } // The ObjectId for the newly created object group is comprised // solely of the FactoryCreationId. PortableServer::ObjectId_var oid; this->get_ObjectId (fcid, oid.out ()); PortableGroup::ObjectGroup_var object_group = this->object_group_manager_.create_object_group (fcid, oid.in (), type_id, the_criteria ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); TAO_PG_Factory_Set factory_set; const CORBA::ULong factory_infos_count = factory_infos.length (); ACE_TRY { if (factory_infos_count > 0 && membership_style == PortableGroup::MEMB_INF_CTRL) { this->populate_object_group (object_group.in (), type_id, factory_infos, initial_number_members, factory_set ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (this->factory_map_.bind (fcid, factory_set) != 0) ACE_TRY_THROW (PortableGroup::ObjectNotCreated ()); } // Allocate a new FactoryCreationId for use as an "out" parameter. PortableGroup::GenericFactory::FactoryCreationId * tmp = 0; ACE_NEW_THROW_EX (tmp, PortableGroup::GenericFactory::FactoryCreationId, CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); ACE_CHECK_RETURN (CORBA::Object::_nil ()); factory_creation_id = tmp; *tmp <<= fcid; } ACE_CATCHANY { this->delete_object_i (factory_set, 1 /* Ignore exceptions */ ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->object_group_manager_.destroy_object_group (oid.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_RE_THROW; } ACE_ENDTRY; ACE_CHECK_RETURN (CORBA::Object::_nil ()); { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->lock_, CORBA::Object::_nil ()); // Object group was successfully created. Increment the next // FactoryCreationId in preparation for the next object group. this->next_fcid_++; } return object_group._retn (); }

void TAO_PG_GenericFactory::delete_member (  CORBA::ULong  group_id, const PortableGroup::Location &  location )

This method is only used by the TAO_PG_ObjectGroupManager class when ObjectGroupManager::remove_member() is explicitly called. Definition at line 312 of file PG_GenericFactory.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD, TAO_PG_Factory_Node::factory_creation_id, TAO_PG_Factory_Node::factory_info, factory_map_, PortableGroup::Location, ACE_Array_Base< T >::size(), TAO_PG_Factory_Set, TAO_SYNCH_MUTEX, PortableGroup::FactoryInfo::the_factory, and PortableGroup::FactoryInfo::the_location. { ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->lock_); // If no entry exists in the factory map, infrastructure // controlled membership was not used. TAO_PG_Factory_Map::ENTRY *entry = 0; if (this->factory_map_.find (group_id, entry) == 0) { TAO_PG_Factory_Set & factory_set = entry->int_id_; const size_t len = factory_set.size (); // Iterate through the factory_set until a location match // occurs. If a location match occurs, the member was created // by the infrastructure, i.e. this GenericFactory // implementation. If no location matches, the member was // created by the application, and no operation will be // performed. // // @todo This is linear search. Change to use a container with // better search times. for (size_t i = 0; i < len; ++i) { TAO_PG_Factory_Node & node = factory_set[i]; PortableGroup::FactoryInfo & info = node.factory_info; if (info.the_location == location) { info.the_factory->delete_object (node.factory_creation_id.in () ACE_ENV_ARG_PARAMETER); ACE_CHECK; // The member has been successfully deleted. Reduce the // size of the factory_set accordingly. if (len > 1) { // Move the last element to the location of the // current one and reduce the size of the set by // one. const size_t new_len = len - 1; node = factory_set[new_len]; // Memberwise copy factory_set.size (new_len); } else { // A copy isn't necessary if the last member was // deleted. factory_set.size (0); } return; } } } }

void TAO_PG_GenericFactory::delete_object (  const PortableGroup::GenericFactory::FactoryCreationId &  factory_creation_id  )  throw (CORBA::SystemException, PortableGroup::ObjectNotFound) [virtual]

Delete the object corresponding to the provided FactoryCreationId. If the object is actually an ObjectGroup, then all members within the ObjectGroup will be deleted. Afterward, the ObjectGroup itself will be deleted. Definition at line 211 of file PG_GenericFactory.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD, ACE_THROW, PortableGroup::GenericFactory::FactoryCreationId, TAO_PG_Factory_Set, and TAO_SYNCH_MUTEX. { CORBA::ULong fcid = 0; if (factory_creation_id >>= fcid) // Extract the actual FactoryCreationId. { // Successfully extracted the FactoryCreationId. Now find the // TAO_PG_Factory_Set corresponding to it. ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->lock_); // If no entry exists in the factory map, infrastructure // controlled membership was not used. TAO_PG_Factory_Map::ENTRY *entry = 0; if (this->factory_map_.find (fcid, entry) == 0) { TAO_PG_Factory_Set & factory_set = entry->int_id_; this->delete_object_i (factory_set, 0 /* Do not ignore exceptions */ ACE_ENV_ARG_PARAMETER); ACE_CHECK; if (this->factory_map_.unbind (fcid) != 0) ACE_THROW (CORBA::INTERNAL ()); } } else ACE_THROW (PortableGroup::ObjectNotFound ()); // @@ // CORBA::BAD_PARAM // instead? // The ObjectId for the newly created object group is comprised // solely of the FactoryCreationId. PortableServer::ObjectId_var oid; this->get_ObjectId (fcid, oid.out ()); // Destroy the object group entry. this->object_group_manager_.destroy_object_group ( oid.in () ACE_ENV_ARG_PARAMETER); ACE_CHECK; }

void TAO_PG_GenericFactory::delete_object_i (  TAO_PG_Factory_Set &  factory_set, CORBA::Boolean  ignore_exceptions )

If ignore_exceptions is true, any exception returned from the delete_object() call on the remote factory will be ignored in order to allow other objects to be deleted via other registered factories. Definition at line 261 of file PG_GenericFactory.cpp. References ACE_CATCHANY, ACE_CHECK, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_RE_THROW, ACE_TRY, ACE_TRY_CHECK, TAO_PG_Factory_Node::factory_creation_id, TAO_PG_Factory_Node::factory_info, PortableGroup::GenericFactory::FactoryCreationId, ACE_Array_Base< T >::size(), TAO_PG_Factory_Set, and PortableGroup::FactoryInfo::the_factory. Referenced by ~TAO_PG_GenericFactory(), and TAO_PG_Group_Guard::~TAO_PG_Group_Guard(). { const size_t len = factory_set.size (); size_t ilen = len; for (size_t i = 0; i != len; ++i) { // Destroy the object group member in reverse order in case the // array list is only partially destroyed and another call to // GenericFactory::delete_object() occurs afterwards. --ilen; TAO_PG_Factory_Node & factory_node = factory_set[ilen]; PortableGroup::GenericFactory_ptr factory = factory_node.factory_info.the_factory.in (); const PortableGroup::GenericFactory::FactoryCreationId & member_fcid = factory_node.factory_creation_id.in (); ACE_TRY { factory->delete_object (member_fcid ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { // Exceptions are generally only ignored when this // GenericFactory (not the one being invoked above) is // destroyed. The idea is to allow the GenericFactory to be // destroyed regardless of whether or not all object group // members have been destroyed, and minimize the number of // object group members that have not been destroyed. if (!ignore_exceptions) ACE_RE_THROW; } ACE_ENDTRY; ACE_CHECK; // Since GenericFactory::delete_object() can throw an exception, // decrease the size of the factory array incrementally since // some object group members may not have been destroyed yet. // Note that this size reduction is fast since no memory is // actually deallocated. factory_set.size (ilen); } }

void TAO_PG_GenericFactory::get_ObjectId (  CORBA::ULong  fcid, PortableServer::ObjectId_out  oid )  [private]

Get a new ObjectId to be used when creating a new ObjectGroup. An ObjectId created by this method will never be reused within the scope of a given ReplicationManager. A value suitable for use in a map association is also returned. Definition at line 429 of file PG_GenericFactory.cpp. References ACE_OS::sprintf(), and PortableServer::string_to_ObjectId(). { // Since the POA used by the LoadManager uses the NON_RETAIN // policy, explicitly choose an ObjectId that is unique to a given // type. // Make the ObjectId be the next value of the number of types that // have been registered with the LoadManager. For example, if two // types of objects have been registered with the LoadManager, then // the ObjectId for the object currently being registered will be // "3" since the object will be the third type of object registered // with the LoadManager. Previously used values will not be reused // to ensure that a ServantLocator does not inadvertently return a // reference to an object that had a previously used ObjectId. // Specifcally, the numerical value used for the ObjectId increases // monotonically. // 4294967295UL -- Largest 32 bit unsigned integer // 123456789012 -- 10 digits // + 2 for "UL" (unnecessary, but let's be safe) // + 1 for null terminator // + 1 for good luck. :-) const size_t MAX_OID_LEN = 14; char oid_str[MAX_OID_LEN] = { 0 }; ACE_OS::sprintf (oid_str, "%ul", fcid); oid = PortableServer::string_to_ObjectId (oid_str); }

void TAO_PG_GenericFactory::poa (  PortableServer::POA_ptr  p  )

Set the POA to use when creating object references. Definition at line 373 of file PG_GenericFactory.cpp. References ACE_ASSERT, and CORBA::is_nil(). { ACE_ASSERT (CORBA::is_nil (this->poa_.in ()) && !CORBA::is_nil (p)); this->poa_ = PortableServer::POA::_duplicate (p); }

void TAO_PG_GenericFactory::populate_object_group (  PortableGroup::ObjectGroup_ptr  object_group, const char *  type_id, const PortableGroup::FactoryInfos &  factory_infos, PortableGroup::InitialNumberMembersValue  initial_number_members, TAO_PG_Factory_Set &  factory_set )  [private]

Populate the object group being created. Called when the infrastructure-controlled membership style is used for the object group being created. Definition at line 382 of file PG_GenericFactory.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_THROW, create_member(), TAO_PG_Factory_Node::factory_creation_id, TAO_PG_Factory_Node::factory_info, PortableGroup::FactoryInfos, PortableGroup::InitialNumberMembersValue, CORBA::is_nil(), TAO_PG_Factory_Set, PortableGroup::FactoryInfo::the_factory, and PortableGroup::FactoryInfo::the_location. { CORBA::ULong factory_infos_count = factory_infos.length (); factory_set.size (factory_infos_count); for (CORBA::ULong j = 0; j < factory_infos_count; ++j) { TAO_PG_Factory_Node & factory_node = factory_set[j]; const PortableGroup::FactoryInfo &factory_info = factory_infos[j]; if (j < static_cast<CORBA::ULong> (initial_number_members)) { PortableGroup::GenericFactory_ptr factory = factory_info.the_factory.in (); if (CORBA::is_nil (factory)) { // @@ instead InvalidProperty? ACE_THROW (PortableGroup::NoFactory (factory_info.the_location, type_id)); } // Do not allow the PortableGroup::MemberAlreadyPresent // exception to be propagated to this scope. const CORBA::Boolean propagate_member_already_present = 0; factory_node.factory_creation_id = this->create_member (object_group, factory_info, type_id, propagate_member_already_present ACE_ENV_ARG_PARAMETER); ACE_CHECK; } factory_node.factory_info = factory_info; // Memberwise copy } }

void TAO_PG_GenericFactory::process_criteria (  const char *  type_id, const PortableGroup::Criteria &  criteria, PortableGroup::MembershipStyleValue &  membership_style, PortableGroup::FactoriesValue &  factory_infos, PortableGroup::InitialNumberMembersValue &  initial_number_members, PortableGroup::MinimumNumberMembersValue &  minimum_number_members )  [private]

Only the MemberShipStyle, Factories, InitialNumberMembers and MinimumNumberMembers criteria/properties are defined by the PortableGroup IDL. Other services that implement the GenericFactory interface, such as load balancing and fault tolerance, may choose to support more. The extracted criteria are object group-specific. In particular, they are the object group creation time criteria. Definition at line 464 of file PG_GenericFactory.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_THROW, PortableGroup::Criteria, PortableGroup::FactoriesValue, PortableGroup::FactoryInfos, TAO_PG::get_property_value(), TAO_PG_PropertyManager::get_type_properties(), PortableGroup::InitialNumberMembersValue, PortableGroup::MembershipStyleValue, PortableGroup::MinimumNumberMembersValue, TAO_PG::override_properties(), property_manager_, CORBA::string_dup(), and PortableGroup::Value. { // Get type-specific properties. PortableGroup::Properties_var props = this->property_manager_.get_type_properties (type_id ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Merge the given criteria with the type-specific criteria. TAO_PG::override_properties (criteria, props.inout ()); PortableGroup::Criteria unmet_criteria; unmet_criteria.length (4); // The four criteria understood by this // method. // Unmet criteria count. CORBA::ULong uc = 0; PortableGroup::Name name (1); name.length (1); PortableGroup::Value value; PortableGroup::Value value1; PortableGroup::Value value2; PortableGroup::Value value3; // MembershipStyle name[0].id = CORBA::string_dup ("org.omg.PortableGroup.MembershipStyle"); if (TAO_PG::get_property_value (name, props.in (), value) && (!(value >>= membership_style) || (membership_style != PortableGroup::MEMB_APP_CTRL && membership_style != PortableGroup::MEMB_INF_CTRL))) { // This only occurs if extraction of the actual value from the // Any fails. ACE_THROW (PortableGroup::InvalidProperty (name, value)); } // Factories const PortableGroup::FactoryInfos * factory_infos_tmp = 0; name[0].id = CORBA::string_dup ("org.omg.PortableGroup.Factories"); if (TAO_PG::get_property_value (name, props.in (), value1) && !(value1 >>= factory_infos_tmp)) { // This only occurs if extraction of the actual value from the // Any fails. ACE_THROW (PortableGroup::InvalidProperty (name, value1)); } const CORBA::ULong factory_infos_count = (factory_infos_tmp == 0 ? 0 : factory_infos_tmp->length ()); // InitialNumberMembers name[0].id = CORBA::string_dup ("org.omg.PortableGroup.InitialNumberMembers"); if (TAO_PG::get_property_value (name, props.in (), value2) && !(value2 >>= initial_number_members)) { // This only occurs if extraction of the actual value from the // Any fails. ACE_THROW (PortableGroup::InvalidProperty (name, value2)); } if (membership_style == PortableGroup::MEMB_INF_CTRL) { // If the number of factories is less than the initial number of // members or the desired number of initial members cannot // possibly be created. if (factory_infos_count < static_cast<CORBA::ULong> (initial_number_members)) { unmet_criteria[uc].nam = name; unmet_criteria[uc++].val = value2; } } // MinimumNumberMembers name[0].id = CORBA::string_dup ("org.omg.PortableGroup.MinimumNumberMembers"); if (TAO_PG::get_property_value (name, props.in (), value3) && !(value3 >>= minimum_number_members)) { // This only occurs if extraction of the actual value from the // Any fails. ACE_THROW (PortableGroup::InvalidProperty (name, value3)); } // If the minimum number of members is less than the initial number // of members, the MinimumNumberMembers property is cannot be // initially met. // // @note This code is not part of the above "MEMB_INF_CTRL" criteria // check since the "name" and "value" variables have been // changed. if (membership_style == PortableGroup::MEMB_INF_CTRL) { if (minimum_number_members < initial_number_members || static_cast<CORBA::ULong> (minimum_number_members) > factory_infos_count) { unmet_criteria[uc].nam = name; unmet_criteria[uc++].val = value3; } else if (factory_infos_tmp != 0) { factory_infos.length (factory_infos_count); factory_infos = *factory_infos_tmp; } } if (uc > 0) { // Reduce the length of the unmet criteria sequence in an effort // to optimize the copying that will occur when the below // exception is thrown. Reducing the length is fast since no // deallocations should occur. unmet_criteria.length (uc); ACE_THROW (PortableGroup::CannotMeetCriteria (unmet_criteria)); } }

---

Member Data Documentation

TAO_PG_Factory_Map TAO_PG_GenericFactory::factory_map_ [private]

Table that maps FactoryCreationId to TAO_PG_Factory_Set. The TAO_PG_Factory_Set corresponding to a given FactoryCreationId contains the information necessary to clean up objects (members) that were created by the infrastructure, i.e. this GenericFactory. For example, this GenericFactory will invoke other application defined GenericFactorys when creating new object group members. The information returned from those application defined GenericFactorys is stored in a TAO_PG_Factory_Set, and thus this table. Definition at line 225 of file PG_GenericFactory.h. Referenced by check_minimum_number_members(), delete_member(), and ~TAO_PG_GenericFactory().

TAO_SYNCH_MUTEX TAO_PG_GenericFactory::lock_ [private]

Lock used to synchronize access to the factory creation id index (i.e. next_fcid_). Definition at line 240 of file PG_GenericFactory.h.

CORBA::ULong TAO_PG_GenericFactory::next_fcid_ [private]

Value that is used when assigning a FactoryCreationId to the factory that was used to create a given ObjectGroup. The FactoryCreationId is typically comprised of this value in addition to another value that makes it unique to a given Load Balancer. Definition at line 236 of file PG_GenericFactory.h.

TAO_PG_ObjectGroupManager& TAO_PG_GenericFactory::object_group_manager_ [private]

Reference to the ObjectGroup map. Definition at line 209 of file PG_GenericFactory.h. Referenced by check_minimum_number_members(), and TAO_PG_GenericFactory().

PortableServer::POA_var TAO_PG_GenericFactory::poa_ [private]

Reference to the POA used to create object group references. Definition at line 206 of file PG_GenericFactory.h.

TAO_PG_PropertyManager& TAO_PG_GenericFactory::property_manager_ [private]

Reference to the PropertyManager. Definition at line 212 of file PG_GenericFactory.h. Referenced by check_minimum_number_members(), and process_criteria().

---

The documentation for this class was generated from the following files:

• PG_GenericFactory.h
• PG_GenericFactory.cpp

---